io.vertx.rxjava.redis

## Class RedisClient

- java.lang.Object
- - io.vertx.rxjava.redis.RedisClient

-     public class RedisClient
      extends Object

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static TypeArg<RedisClient>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `RedisClient(RedisClient delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `RedisClient` | `append(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a key
    `rx.Observable<Long>` | `appendObservable(String key, String value)` Deprecated. use `rxAppend(java.lang.String, java.lang.String)` instead
    `RedisClient` | `auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `rx.Observable<String>` | `authObservable(String password)` Deprecated. use `rxAuth(java.lang.String)` instead
    `RedisClient` | `bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `rx.Observable<String>` | `bgrewriteaofObservable()` Deprecated. use `rxBgrewriteaof()` instead
    `RedisClient` | `bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `rx.Observable<String>` | `bgsaveObservable()` Deprecated. use `rxBgsave()` instead
    `RedisClient` | `bitcount(String key, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `rx.Observable<Long>` | `bitcountObservable(String key)` Deprecated. use `rxBitcount(java.lang.String)` instead
    `RedisClient` | `bitcountRange(String key, long start, long end, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `rx.Observable<Long>` | `bitcountRangeObservable(String key, long start, long end)` Deprecated. use `rxBitcountRange(java.lang.String, long, long)` instead
    `RedisClient` | `bitfield(String key, BitFieldOptions bitFieldOptions, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `rx.Observable<JsonArray>` | `bitfieldObservable(String key, BitFieldOptions bitFieldOptions)` Deprecated. use `rxBitfield(java.lang.String, io.vertx.redis.op.BitFieldOptions)` instead
    `RedisClient` | `bitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `rx.Observable<JsonArray>` | `bitfieldWithOverflowObservable(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow)` Deprecated. use `rxBitfieldWithOverflow(java.lang.String, io.vertx.redis.op.BitFieldOptions, io.vertx.redis.op.BitFieldOverflowOptions)` instead
    `RedisClient` | `bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Perform bitwise operations between strings
    `rx.Observable<Long>` | `bitopObservable(BitOperation operation, String destkey, List<String> keys)` Deprecated. use `rxBitop(io.vertx.redis.op.BitOperation, java.lang.String, java.util.List<java.lang.String>)` instead
    `RedisClient` | `bitpos(String key, int bit, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string
    `RedisClient` | `bitposFrom(String key, int bit, int start, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
    `rx.Observable<Long>` | `bitposFromObservable(String key, int bit, int start)` Deprecated. use `rxBitposFrom(java.lang.String, int, int)` instead
    `rx.Observable<Long>` | `bitposObservable(String key, int bit)` Deprecated. use `rxBitpos(java.lang.String, int)` instead
    `RedisClient` | `bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<Long>> handler)` Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
    `rx.Observable<Long>` | `bitposRangeObservable(String key, int bit, int start, int stop)` Deprecated. use `rxBitposRange(java.lang.String, int, int, int)` instead
    `RedisClient` | `blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisClient` | `blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `rx.Observable<JsonArray>` | `blpopManyObservable(List<String> keys, int seconds)` Deprecated. use `rxBlpopMany(java.util.List<java.lang.String>, int)` instead
    `rx.Observable<JsonArray>` | `blpopObservable(String key, int seconds)` Deprecated. use `rxBlpop(java.lang.String, int)` instead
    `RedisClient` | `brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisClient` | `brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler)` Pop a value from a list, push it to another list and return it; or block until one is available
    `rx.Observable<String>` | `brpoplpushObservable(String key, String destkey, int seconds)` Deprecated. use `rxBrpoplpush(java.lang.String, java.lang.String, int)` instead
    `RedisClient` | `brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `rx.Observable<JsonArray>` | `brpopManyObservable(List<String> keys, int seconds)` Deprecated. use `rxBrpopMany(java.util.List<java.lang.String>, int)` instead
    `rx.Observable<JsonArray>` | `brpopObservable(String key, int seconds)` Deprecated. use `rxBrpop(java.lang.String, int)` instead
    `RedisClient` | `clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `rx.Observable<String>` | `clientGetnameObservable()` Deprecated. use `rxClientGetname()` instead
    `RedisClient` | `clientKill(KillFilter filter, Handler<AsyncResult<Long>> handler)` Kill the connection of a client
    `rx.Observable<Long>` | `clientKillObservable(KillFilter filter)` Deprecated. use `rxClientKill(io.vertx.redis.op.KillFilter)` instead
    `RedisClient` | `clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `rx.Observable<String>` | `clientListObservable()` Deprecated. use `rxClientList()` instead
    `RedisClient` | `clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `rx.Observable<String>` | `clientPauseObservable(long millis)` Deprecated. use `rxClientPause(long)` instead
    `RedisClient` | `clientReply(ClientReplyOptions options, Handler<AsyncResult<String>> handler)` Instruct the server whether to reply to commands.
    `rx.Observable<String>` | `clientReplyObservable(ClientReplyOptions options)` Deprecated. use `rxClientReply(io.vertx.redis.op.ClientReplyOptions)` instead
    `RedisClient` | `clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
    `rx.Observable<String>` | `clientSetnameObservable(String name)` Deprecated. use `rxClientSetname(java.lang.String)` instead
    `void` | `close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `rx.Observable<Void>` | `closeObservable()` Deprecated. use `rxClose()` instead
    `RedisClient` | `clusterAddslots(List<Long> slots, Handler<AsyncResult<Void>> handler)` Assign new hash slots to receiving node.
    `rx.Observable<Void>` | `clusterAddslotsObservable(List<Long> slots)` Deprecated. use `rxClusterAddslots(java.util.List<java.lang.Long>)` instead
    `RedisClient` | `clusterCountFailureReports(String nodeId, Handler<AsyncResult<Long>> handler)` Return the number of failure reports active for a given node.
    `rx.Observable<Long>` | `clusterCountFailureReportsObservable(String nodeId)` Deprecated. use `rxClusterCountFailureReports(java.lang.String)` instead
    `RedisClient` | `clusterCountkeysinslot(long slot, Handler<AsyncResult<Long>> handler)` Return the number of local keys in the specified hash slot.
    `rx.Observable<Long>` | `clusterCountkeysinslotObservable(long slot)` Deprecated. use `rxClusterCountkeysinslot(long)` instead
    `RedisClient` | `clusterDelslots(long slot, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `RedisClient` | `clusterDelslotsMany(List<Long> slots, Handler<AsyncResult<Void>> handler)` Set hash slots as unbound in receiving node.
    `rx.Observable<Void>` | `clusterDelslotsManyObservable(List<Long> slots)` Deprecated. use `rxClusterDelslotsMany(java.util.List<java.lang.Long>)` instead
    `rx.Observable<Void>` | `clusterDelslotsObservable(long slot)` Deprecated. use `rxClusterDelslots(long)` instead
    `RedisClient` | `clusterFailover(Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `rx.Observable<Void>` | `clusterFailoverObservable()` Deprecated. use `rxClusterFailover()` instead
    `RedisClient` | `clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `rx.Observable<Void>` | `clusterFailOverWithOptionsObservable(FailoverOptions options)` Deprecated. use `rxClusterFailOverWithOptions(io.vertx.redis.op.FailoverOptions)` instead
    `RedisClient` | `clusterForget(String nodeId, Handler<AsyncResult<Void>> handler)` Remove a node from the nodes table.
    `rx.Observable<Void>` | `clusterForgetObservable(String nodeId)` Deprecated. use `rxClusterForget(java.lang.String)` instead
    `RedisClient` | `clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Return local key names in the specified hash slot.
    `rx.Observable<JsonArray>` | `clusterGetkeysinslotObservable(long slot, long count)` Deprecated. use `rxClusterGetkeysinslot(long, long)` instead
    `RedisClient` | `clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Provides info about Redis Cluster node state.
    `rx.Observable<JsonArray>` | `clusterInfoObservable()` Deprecated. use `rxClusterInfo()` instead
    `RedisClient` | `clusterKeyslot(String key, Handler<AsyncResult<Long>> handler)` Returns the hash slot of the specified key.
    `rx.Observable<Long>` | `clusterKeyslotObservable(String key)` Deprecated. use `rxClusterKeyslot(java.lang.String)` instead
    `RedisClient` | `clusterMeet(String ip, long port, Handler<AsyncResult<Void>> handler)` Force a node cluster to handshake with another node.
    `rx.Observable<Void>` | `clusterMeetObservable(String ip, long port)` Deprecated. use `rxClusterMeet(java.lang.String, long)` instead
    `RedisClient` | `clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Get Cluster config for the node.
    `rx.Observable<JsonArray>` | `clusterNodesObservable()` Deprecated. use `rxClusterNodes()` instead
    `RedisClient` | `clusterReplicate(String nodeId, Handler<AsyncResult<Void>> handler)` Reconfigure a node as a slave of the specified master node.
    `rx.Observable<Void>` | `clusterReplicateObservable(String nodeId)` Deprecated. use `rxClusterReplicate(java.lang.String)` instead
    `RedisClient` | `clusterReset(Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `rx.Observable<Void>` | `clusterResetObservable()` Deprecated. use `rxClusterReset()` instead
    `RedisClient` | `clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `rx.Observable<Void>` | `clusterResetWithOptionsObservable(ResetOptions options)` Deprecated. use `rxClusterResetWithOptions(io.vertx.redis.op.ResetOptions)` instead
    `RedisClient` | `clusterSaveconfig(Handler<AsyncResult<Void>> handler)` Forces the node to save cluster state on disk.
    `rx.Observable<Void>` | `clusterSaveconfigObservable()` Deprecated. use `rxClusterSaveconfig()` instead
    `RedisClient` | `clusterSetConfigEpoch(long epoch, Handler<AsyncResult<Void>> handler)` Set the configuration epoch in a new node.
    `rx.Observable<Void>` | `clusterSetConfigEpochObservable(long epoch)` Deprecated. use `rxClusterSetConfigEpoch(long)` instead
    `RedisClient` | `clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `rx.Observable<Void>` | `clusterSetslotObservable(long slot, SlotCmd subcommand)` Deprecated. use `rxClusterSetslot(long, io.vertx.redis.op.SlotCmd)` instead
    `RedisClient` | `clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `rx.Observable<Void>` | `clusterSetslotWithNodeObservable(long slot, SlotCmd subcommand, String nodeId)` Deprecated. use `rxClusterSetslotWithNode(long, io.vertx.redis.op.SlotCmd, java.lang.String)` instead
    `RedisClient` | `clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` List slave nodes of the specified master node.
    `rx.Observable<JsonArray>` | `clusterSlavesObservable(String nodeId)` Deprecated. use `rxClusterSlaves(java.lang.String)` instead
    `RedisClient` | `clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
    `rx.Observable<JsonArray>` | `clusterSlotsObservable()` Deprecated. use `rxClusterSlots()` instead
    `RedisClient` | `command(Handler<AsyncResult<JsonArray>> handler)` Get array of Redis command details
    `RedisClient` | `commandCount(Handler<AsyncResult<Long>> handler)` Get total number of Redis commands
    `rx.Observable<Long>` | `commandCountObservable()` Deprecated. use `rxCommandCount()` instead
    `RedisClient` | `commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
    `rx.Observable<JsonArray>` | `commandGetkeysObservable()` Deprecated. use `rxCommandGetkeys()` instead
    `RedisClient` | `commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
    `rx.Observable<JsonArray>` | `commandInfoObservable(List<String> commands)` Deprecated. use `rxCommandInfo(java.util.List<java.lang.String>)` instead
    `rx.Observable<JsonArray>` | `commandObservable()` Deprecated. use `rxCommand()` instead
    `RedisClient` | `configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
    `rx.Observable<JsonArray>` | `configGetObservable(String parameter)` Deprecated. use `rxConfigGet(java.lang.String)` instead
    `RedisClient` | `configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `rx.Observable<String>` | `configResetstatObservable()` Deprecated. use `rxConfigResetstat()` instead
    `RedisClient` | `configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `rx.Observable<String>` | `configRewriteObservable()` Deprecated. use `rxConfigRewrite()` instead
    `RedisClient` | `configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
    `rx.Observable<String>` | `configSetObservable(String parameter, String value)` Deprecated. use `rxConfigSet(java.lang.String, java.lang.String)` instead
    `static RedisClient` | `create(Vertx vertx)`
    `static RedisClient` | `create(Vertx vertx, RedisOptions config)`
    `RedisClient` | `dbsize(Handler<AsyncResult<Long>> handler)` Return the number of keys in the selected database
    `rx.Observable<Long>` | `dbsizeObservable()` Deprecated. use `rxDbsize()` instead
    `RedisClient` | `debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `rx.Observable<String>` | `debugObjectObservable(String key)` Deprecated. use `rxDebugObject(java.lang.String)` instead
    `RedisClient` | `debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `rx.Observable<String>` | `debugSegfaultObservable()` Deprecated. use `rxDebugSegfault()` instead
    `RedisClient` | `decr(String key, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by one
    `RedisClient` | `decrby(String key, long decrement, Handler<AsyncResult<Long>> handler)` Decrement the integer value of a key by the given number
    `rx.Observable<Long>` | `decrbyObservable(String key, long decrement)` Deprecated. use `rxDecrby(java.lang.String, long)` instead
    `rx.Observable<Long>` | `decrObservable(String key)` Deprecated. use `rxDecr(java.lang.String)` instead
    `RedisClient` | `del(String key, Handler<AsyncResult<Long>> handler)` Delete a key
    `RedisClient` | `delMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete many keys
    `rx.Observable<Long>` | `delManyObservable(List<String> keys)` Deprecated. use `rxDelMany(java.util.List<java.lang.String>)` instead
    `rx.Observable<Long>` | `delObservable(String key)` Deprecated. use `rxDel(java.lang.String)` instead
    `RedisClient` | `dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `rx.Observable<String>` | `dumpObservable(String key)` Deprecated. use `rxDump(java.lang.String)` instead
    `RedisClient` | `echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `rx.Observable<String>` | `echoObservable(String message)` Deprecated. use `rxEcho(java.lang.String)` instead
    `RedisClient` | `eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `rx.Observable<JsonArray>` | `evalObservable(String script, List<String> keys, List<String> args)` Deprecated. use `rxEval(java.lang.String, java.util.List<java.lang.String>, java.util.List<java.lang.String>)` instead
    `RedisClient` | `evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `rx.Observable<JsonArray>` | `evalshaObservable(String sha1, List<String> keys, List<String> values)` Deprecated. use `rxEvalsha(java.lang.String, java.util.List<java.lang.String>, java.util.List<java.lang.String>)` instead
    `RedisClient` | `exists(String key, Handler<AsyncResult<Long>> handler)` Determine if a key exists
    `rx.Observable<Long>` | `existsObservable(String key)` Deprecated. use `rxExists(java.lang.String)` instead
    `RedisClient` | `expire(String key, long seconds, Handler<AsyncResult<Long>> handler)` Set a key's time to live in seconds
    `RedisClient` | `expireat(String key, long seconds, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp
    `rx.Observable<Long>` | `expireatObservable(String key, long seconds)` Deprecated. use `rxExpireat(java.lang.String, long)` instead
    `rx.Observable<Long>` | `expireObservable(String key, long seconds)` Deprecated. use `rxExpire(java.lang.String, long)` instead
    `RedisClient` | `flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `rx.Observable<String>` | `flushallObservable()` Deprecated. use `rxFlushall()` instead
    `RedisClient` | `flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `rx.Observable<String>` | `flushdbObservable()` Deprecated. use `rxFlushdb()` instead
    `RedisClient` | `geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<Long>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisClient` | `geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<Long>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `rx.Observable<Long>` | `geoaddManyObservable(String key, List<GeoMember> members)` Deprecated. use `rxGeoaddMany(java.lang.String, java.util.List<io.vertx.redis.op.GeoMember>)` instead
    `rx.Observable<Long>` | `geoaddObservable(String key, double longitude, double latitude, String member)` Deprecated. use `rxGeoadd(java.lang.String, double, double, java.lang.String)` instead
    `RedisClient` | `geodist(String key, String member1, String member2, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `rx.Observable<String>` | `geodistObservable(String key, String member1, String member2)` Deprecated. use `rxGeodist(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisClient` | `geodistWithUnit(String key, String member1, String member2, GeoUnit unit, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `rx.Observable<String>` | `geodistWithUnitObservable(String key, String member1, String member2, GeoUnit unit)` Deprecated. use `rxGeodistWithUnit(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.GeoUnit)` instead
    `RedisClient` | `geohash(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisClient` | `geohashMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `rx.Observable<JsonArray>` | `geohashManyObservable(String key, List<String> members)` Deprecated. use `rxGeohashMany(java.lang.String, java.util.List<java.lang.String>)` instead
    `rx.Observable<JsonArray>` | `geohashObservable(String key, String member)` Deprecated. use `rxGeohash(java.lang.String, java.lang.String)` instead
    `RedisClient` | `geopos(String key, String member, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisClient` | `geoposMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `rx.Observable<JsonArray>` | `geoposManyObservable(String key, List<String> members)` Deprecated. use `rxGeoposMany(java.lang.String, java.util.List<java.lang.String>)` instead
    `rx.Observable<JsonArray>` | `geoposObservable(String key, String member)` Deprecated. use `rxGeopos(java.lang.String, java.lang.String)` instead
    `RedisClient` | `georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisClient` | `georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `rx.Observable<JsonArray>` | `georadiusbymemberObservable(String key, String member, double radius, GeoUnit unit)` Deprecated. use `rxGeoradiusbymember(java.lang.String, java.lang.String, double, io.vertx.redis.op.GeoUnit)` instead
    `RedisClient` | `georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `rx.Observable<JsonArray>` | `georadiusbymemberWithOptionsObservable(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options)` Deprecated. use `rxGeoradiusbymemberWithOptions(java.lang.String, java.lang.String, double, io.vertx.redis.op.GeoUnit, io.vertx.redis.op.GeoRadiusOptions)` instead
    `rx.Observable<JsonArray>` | `georadiusObservable(String key, double longitude, double latitude, double radius, GeoUnit unit)` Deprecated. use `rxGeoradius(java.lang.String, double, double, double, io.vertx.redis.op.GeoUnit)` instead
    `RedisClient` | `georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `rx.Observable<JsonArray>` | `georadiusWithOptionsObservable(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options)` Deprecated. use `rxGeoradiusWithOptions(java.lang.String, double, double, double, io.vertx.redis.op.GeoUnit, io.vertx.redis.op.GeoRadiusOptions)` instead
    `RedisClient` | `get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisClient` | `getBinary(String key, Handler<AsyncResult<Buffer>> handler)` Get the value of a key - without decoding as utf-8
    `rx.Observable<Buffer>` | `getBinaryObservable(String key)` Deprecated. use `rxGetBinary(java.lang.String)` instead
    `RedisClient` | `getbit(String key, long offset, Handler<AsyncResult<Long>> handler)` Returns the bit value at offset in the string value stored at key
    `rx.Observable<Long>` | `getbitObservable(String key, long offset)` Deprecated. use `rxGetbit(java.lang.String, long)` instead
    `RedisClient` | `getDelegate()`
    `rx.Observable<String>` | `getObservable(String key)` Deprecated. use `rxGet(java.lang.String)` instead
    `RedisClient` | `getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `rx.Observable<String>` | `getrangeObservable(String key, long start, long end)` Deprecated. use `rxGetrange(java.lang.String, long, long)` instead
    `RedisClient` | `getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
    `rx.Observable<String>` | `getsetObservable(String key, String value)` Deprecated. use `rxGetset(java.lang.String, java.lang.String)` instead
    `RedisClient` | `hdel(String key, String field, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `RedisClient` | `hdelMany(String key, List<String> fields, Handler<AsyncResult<Long>> handler)` Delete one or more hash fields
    `rx.Observable<Long>` | `hdelManyObservable(String key, List<String> fields)` Deprecated. use `rxHdelMany(java.lang.String, java.util.List<java.lang.String>)` instead
    `rx.Observable<Long>` | `hdelObservable(String key, String field)` Deprecated. use `rxHdel(java.lang.String, java.lang.String)` instead
    `RedisClient` | `hexists(String key, String field, Handler<AsyncResult<Long>> handler)` Determine if a hash field exists
    `rx.Observable<Long>` | `hexistsObservable(String key, String field)` Deprecated. use `rxHexists(java.lang.String, java.lang.String)` instead
    `RedisClient` | `hget(String key, String field, Handler<AsyncResult<String>> handler)` Get the value of a hash field
    `RedisClient` | `hgetall(String key, Handler<AsyncResult<JsonObject>> handler)` Get all the fields and values in a hash
    `rx.Observable<JsonObject>` | `hgetallObservable(String key)` Deprecated. use `rxHgetall(java.lang.String)` instead
    `rx.Observable<String>` | `hgetObservable(String key, String field)` Deprecated. use `rxHget(java.lang.String, java.lang.String)` instead
    `RedisClient` | `hincrby(String key, String field, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a hash field by the given number
    `RedisClient` | `hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a hash field by the given amount
    `rx.Observable<String>` | `hincrbyfloatObservable(String key, String field, double increment)` Deprecated. use `rxHincrbyfloat(java.lang.String, java.lang.String, double)` instead
    `rx.Observable<Long>` | `hincrbyObservable(String key, String field, long increment)` Deprecated. use `rxHincrby(java.lang.String, java.lang.String, long)` instead
    `RedisClient` | `hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
    `rx.Observable<JsonArray>` | `hkeysObservable(String key)` Deprecated. use `rxHkeys(java.lang.String)` instead
    `RedisClient` | `hlen(String key, Handler<AsyncResult<Long>> handler)` Get the number of fields in a hash
    `rx.Observable<Long>` | `hlenObservable(String key)` Deprecated. use `rxHlen(java.lang.String)` instead
    `RedisClient` | `hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given hash fields
    `rx.Observable<JsonArray>` | `hmgetObservable(String key, List<String> fields)` Deprecated. use `rxHmget(java.lang.String, java.util.List<java.lang.String>)` instead
    `RedisClient` | `hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `rx.Observable<String>` | `hmsetObservable(String key, JsonObject values)` Deprecated. use `rxHmset(java.lang.String, io.vertx.core.json.JsonObject)` instead
    `RedisClient` | `hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate hash fields and associated values
    `rx.Observable<JsonArray>` | `hscanObservable(String key, String cursor, ScanOptions options)` Deprecated. use `rxHscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions)` instead
    `RedisClient` | `hset(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the string value of a hash field
    `RedisClient` | `hsetnx(String key, String field, String value, Handler<AsyncResult<Long>> handler)` Set the value of a hash field, only if the field does not exist
    `rx.Observable<Long>` | `hsetnxObservable(String key, String field, String value)` Deprecated. use `rxHsetnx(java.lang.String, java.lang.String, java.lang.String)` instead
    `rx.Observable<Long>` | `hsetObservable(String key, String field, String value)` Deprecated. use `rxHset(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisClient` | `hstrlen(String key, String field, Handler<AsyncResult<Long>> handler)` Get the length of the value of a hash field.
    `rx.Observable<Long>` | `hstrlenObservable(String key, String field)` Deprecated. use `rxHstrlen(java.lang.String, java.lang.String)` instead
    `RedisClient` | `hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
    `rx.Observable<JsonArray>` | `hvalsObservable(String key)` Deprecated. use `rxHvals(java.lang.String)` instead
    `RedisClient` | `incr(String key, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by one
    `RedisClient` | `incrby(String key, long increment, Handler<AsyncResult<Long>> handler)` Increment the integer value of a key by the given amount
    `RedisClient` | `incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a key by the given amount
    `rx.Observable<String>` | `incrbyfloatObservable(String key, double increment)` Deprecated. use `rxIncrbyfloat(java.lang.String, double)` instead
    `rx.Observable<Long>` | `incrbyObservable(String key, long increment)` Deprecated. use `rxIncrby(java.lang.String, long)` instead
    `rx.Observable<Long>` | `incrObservable(String key)` Deprecated. use `rxIncr(java.lang.String)` instead
    `RedisClient` | `info(Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `rx.Observable<JsonObject>` | `infoObservable()` Deprecated. use `rxInfo()` instead
    `RedisClient` | `infoSection(String section, Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `rx.Observable<JsonObject>` | `infoSectionObservable(String section)` Deprecated. use `rxInfoSection(java.lang.String)` instead
    `RedisClient` | `keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
    `rx.Observable<JsonArray>` | `keysObservable(String pattern)` Deprecated. use `rxKeys(java.lang.String)` instead
    `RedisClient` | `lastsave(Handler<AsyncResult<Long>> handler)` Get the UNIX time stamp of the last successful save to disk
    `rx.Observable<Long>` | `lastsaveObservable()` Deprecated. use `rxLastsave()` instead
    `RedisClient` | `lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
    `rx.Observable<String>` | `lindexObservable(String key, int index)` Deprecated. use `rxLindex(java.lang.String, int)` instead
    `RedisClient` | `linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<Long>> handler)` Insert an element before or after another element in a list
    `rx.Observable<Long>` | `linsertObservable(String key, InsertOptions option, String pivot, String value)` Deprecated. use `rxLinsert(java.lang.String, io.vertx.redis.op.InsertOptions, java.lang.String, java.lang.String)` instead
    `RedisClient` | `llen(String key, Handler<AsyncResult<Long>> handler)` Get the length of a list
    `rx.Observable<Long>` | `llenObservable(String key)` Deprecated. use `rxLlen(java.lang.String)` instead
    `RedisClient` | `lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `rx.Observable<String>` | `lpopObservable(String key)` Deprecated. use `rxLpop(java.lang.String)` instead
    `RedisClient` | `lpush(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend one value to a list
    `RedisClient` | `lpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Prepend one or multiple values to a list
    `rx.Observable<Long>` | `lpushManyObservable(String key, List<String> values)` Deprecated. use `rxLpushMany(java.lang.String, java.util.List<java.lang.String>)` instead
    `rx.Observable<Long>` | `lpushObservable(String key, String value)` Deprecated. use `rxLpush(java.lang.String, java.lang.String)` instead
    `RedisClient` | `lpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend a value to a list, only if the list exists
    `rx.Observable<Long>` | `lpushxObservable(String key, String value)` Deprecated. use `rxLpushx(java.lang.String, java.lang.String)` instead
    `RedisClient` | `lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Get a range of elements from a list
    `rx.Observable<JsonArray>` | `lrangeObservable(String key, long from, long to)` Deprecated. use `rxLrange(java.lang.String, long, long)` instead
    `RedisClient` | `lrem(String key, long count, String value, Handler<AsyncResult<Long>> handler)` Remove elements from a list
    `rx.Observable<Long>` | `lremObservable(String key, long count, String value)` Deprecated. use `rxLrem(java.lang.String, long, java.lang.String)` instead
    `RedisClient` | `lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
    `rx.Observable<String>` | `lsetObservable(String key, long index, String value)` Deprecated. use `rxLset(java.lang.String, long, java.lang.String)` instead
    `RedisClient` | `ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
    `rx.Observable<String>` | `ltrimObservable(String key, long from, long to)` Deprecated. use `rxLtrim(java.lang.String, long, long)` instead
    `RedisClient` | `mget(String key, Handler<AsyncResult<JsonArray>> handler)` Get the value of the given key
    `RedisClient` | `mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given keys
    `rx.Observable<JsonArray>` | `mgetManyObservable(List<String> keys)` Deprecated. use `rxMgetMany(java.util.List<java.lang.String>)` instead
    `rx.Observable<JsonArray>` | `mgetObservable(String key)` Deprecated. use `rxMget(java.lang.String)` instead
    `RedisClient` | `migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler)` Atomically transfer a key from a Redis instance to another one.
    `rx.Observable<String>` | `migrateObservable(String host, int port, String key, int destdb, long timeout, MigrateOptions options)` Deprecated. use `rxMigrate(java.lang.String, int, java.lang.String, int, long, io.vertx.redis.op.MigrateOptions)` instead
    `RedisClient` | `monitor(Handler<AsyncResult<Void>> handler)` Listen for all requests received by the server in real time
    `rx.Observable<Void>` | `monitorObservable()` Deprecated. use `rxMonitor()` instead
    `RedisClient` | `move(String key, int destdb, Handler<AsyncResult<Long>> handler)` Move a key to another database
    `rx.Observable<Long>` | `moveObservable(String key, int destdb)` Deprecated. use `rxMove(java.lang.String, int)` instead
    `RedisClient` | `mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisClient` | `msetnx(JsonObject keyvals, Handler<AsyncResult<Long>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `rx.Observable<Long>` | `msetnxObservable(JsonObject keyvals)` Deprecated. use `rxMsetnx(io.vertx.core.json.JsonObject)` instead
    `rx.Observable<String>` | `msetObservable(JsonObject keyvals)` Deprecated. use `rxMset(io.vertx.core.json.JsonObject)` instead
    `static RedisClient` | `newInstance(RedisClient arg)`
    `RedisClient` | `object(String key, ObjectCmd cmd, Handler<AsyncResult<Void>> handler)` Inspect the internals of Redis objects
    `rx.Observable<Void>` | `objectObservable(String key, ObjectCmd cmd)` Deprecated. use `rxObject(java.lang.String, io.vertx.redis.op.ObjectCmd)` instead
    `RedisClient` | `persist(String key, Handler<AsyncResult<Long>> handler)` Remove the expiration from a key
    `rx.Observable<Long>` | `persistObservable(String key)` Deprecated. use `rxPersist(java.lang.String)` instead
    `RedisClient` | `pexpire(String key, long millis, Handler<AsyncResult<Long>> handler)` Set a key's time to live in milliseconds
    `RedisClient` | `pexpireat(String key, long millis, Handler<AsyncResult<Long>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `rx.Observable<Long>` | `pexpireatObservable(String key, long millis)` Deprecated. use `rxPexpireat(java.lang.String, long)` instead
    `rx.Observable<Long>` | `pexpireObservable(String key, long millis)` Deprecated. use `rxPexpire(java.lang.String, long)` instead
    `RedisClient` | `pfadd(String key, String element, Handler<AsyncResult<Long>> handler)` Adds the specified element to the specified HyperLogLog.
    `RedisClient` | `pfaddMany(String key, List<String> elements, Handler<AsyncResult<Long>> handler)` Adds the specified elements to the specified HyperLogLog.
    `rx.Observable<Long>` | `pfaddManyObservable(String key, List<String> elements)` Deprecated. use `rxPfaddMany(java.lang.String, java.util.List<java.lang.String>)` instead
    `rx.Observable<Long>` | `pfaddObservable(String key, String element)` Deprecated. use `rxPfadd(java.lang.String, java.lang.String)` instead
    `RedisClient` | `pfcount(String key, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisClient` | `pfcountMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `rx.Observable<Long>` | `pfcountManyObservable(List<String> keys)` Deprecated. use `rxPfcountMany(java.util.List<java.lang.String>)` instead
    `rx.Observable<Long>` | `pfcountObservable(String key)` Deprecated. use `rxPfcount(java.lang.String)` instead
    `RedisClient` | `pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `rx.Observable<String>` | `pfmergeObservable(String destkey, List<String> keys)` Deprecated. use `rxPfmerge(java.lang.String, java.util.List<java.lang.String>)` instead
    `RedisClient` | `ping(Handler<AsyncResult<String>> handler)` Ping the server
    `rx.Observable<String>` | `pingObservable()` Deprecated. use `rxPing()` instead
    `RedisClient` | `psetex(String key, long millis, String value, Handler<AsyncResult<Void>> handler)` Set the value and expiration in milliseconds of a key
    `rx.Observable<Void>` | `psetexObservable(String key, long millis, String value)` Deprecated. use `rxPsetex(java.lang.String, long, java.lang.String)` instead
    `RedisClient` | `psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given pattern
    `RedisClient` | `psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to channels matching the given patterns
    `rx.Observable<JsonArray>` | `psubscribeManyObservable(List<String> patterns)` Deprecated. use `rxPsubscribeMany(java.util.List<java.lang.String>)` instead
    `rx.Observable<JsonArray>` | `psubscribeObservable(String pattern)` Deprecated. use `rxPsubscribe(java.lang.String)` instead
    `RedisClient` | `pttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key in milliseconds
    `rx.Observable<Long>` | `pttlObservable(String key)` Deprecated. use `rxPttl(java.lang.String)` instead
    `RedisClient` | `publish(String channel, String message, Handler<AsyncResult<Long>> handler)` Post a message to a channel
    `rx.Observable<Long>` | `publishObservable(String channel, String message)` Deprecated. use `rxPublish(java.lang.String, java.lang.String)` instead
    `RedisClient` | `pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
    `rx.Observable<JsonArray>` | `pubsubChannelsObservable(String pattern)` Deprecated. use `rxPubsubChannels(java.lang.String)` instead
    `RedisClient` | `pubsubNumpat(Handler<AsyncResult<Long>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `rx.Observable<Long>` | `pubsubNumpatObservable()` Deprecated. use `rxPubsubNumpat()` instead
    `RedisClient` | `pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `rx.Observable<JsonArray>` | `pubsubNumsubObservable(List<String> channels)` Deprecated. use `rxPubsubNumsub(java.util.List<java.lang.String>)` instead
    `RedisClient` | `punsubscribe(List<String> patterns, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to channels matching the given patterns
    `rx.Observable<Void>` | `punsubscribeObservable(List<String> patterns)` Deprecated. use `rxPunsubscribe(java.util.List<java.lang.String>)` instead
    `RedisClient` | `randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `rx.Observable<String>` | `randomkeyObservable()` Deprecated. use `rxRandomkey()` instead
    `RedisClient` | `rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key
    `RedisClient` | `renamenx(String key, String newkey, Handler<AsyncResult<Long>> handler)` Rename a key, only if the new key does not exist
    `rx.Observable<Long>` | `renamenxObservable(String key, String newkey)` Deprecated. use `rxRenamenx(java.lang.String, java.lang.String)` instead
    `rx.Observable<String>` | `renameObservable(String key, String newkey)` Deprecated. use `rxRename(java.lang.String, java.lang.String)` instead
    `RedisClient` | `restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `rx.Observable<String>` | `restoreObservable(String key, long millis, String serialized)` Deprecated. use `rxRestore(java.lang.String, long, java.lang.String)` instead
    `RedisClient` | `role(Handler<AsyncResult<JsonArray>> handler)` Return the role of the instance in the context of replication
    `rx.Observable<JsonArray>` | `roleObservable()` Deprecated. use `rxRole()` instead
    `RedisClient` | `rpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list
    `RedisClient` | `rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Remove the last element in a list, append it to another list and return it
    `rx.Observable<String>` | `rpoplpushObservable(String key, String destkey)` Deprecated. use `rxRpoplpush(java.lang.String, java.lang.String)` instead
    `rx.Observable<String>` | `rpopObservable(String key)` Deprecated. use `rxRpop(java.lang.String)` instead
    `RedisClient` | `rpush(String key, String value, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `RedisClient` | `rpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler)` Append one or multiple values to a list
    `rx.Observable<Long>` | `rpushManyObservable(String key, List<String> values)` Deprecated. use `rxRpushMany(java.lang.String, java.util.List<java.lang.String>)` instead
    `rx.Observable<Long>` | `rpushObservable(String key, String value)` Deprecated. use `rxRpush(java.lang.String, java.lang.String)` instead
    `RedisClient` | `rpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a list, only if the list exists
    `rx.Observable<Long>` | `rpushxObservable(String key, String value)` Deprecated. use `rxRpushx(java.lang.String, java.lang.String)` instead
    `rx.Single<Long>` | `rxAppend(String key, String value)` Append a value to a key
    `rx.Single<String>` | `rxAuth(String password)` Authenticate to the server
    `rx.Single<String>` | `rxBgrewriteaof()` Asynchronously rewrite the append-only file
    `rx.Single<String>` | `rxBgsave()` Asynchronously save the dataset to disk
    `rx.Single<Long>` | `rxBitcount(String key)` Count set bits in a string
    `rx.Single<Long>` | `rxBitcountRange(String key, long start, long end)` Count set bits in a string
    `rx.Single<JsonArray>` | `rxBitfield(String key, BitFieldOptions bitFieldOptions)` Perform arbitrary bitfield integer operations on strings.
    `rx.Single<JsonArray>` | `rxBitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow)` Perform arbitrary bitfield integer operations on strings.
    `rx.Single<Long>` | `rxBitop(BitOperation operation, String destkey, List<String> keys)` Perform bitwise operations between strings
    `rx.Single<Long>` | `rxBitpos(String key, int bit)` Find first bit set or clear in a string
    `rx.Single<Long>` | `rxBitposFrom(String key, int bit, int start)` Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
    `rx.Single<Long>` | `rxBitposRange(String key, int bit, int start, int stop)` Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
    `rx.Single<JsonArray>` | `rxBlpop(String key, int seconds)` Remove and get the first element in a list, or block until one is available
    `rx.Single<JsonArray>` | `rxBlpopMany(List<String> keys, int seconds)` Remove and get the first element in any of the lists, or block until one is available
    `rx.Single<JsonArray>` | `rxBrpop(String key, int seconds)` Remove and get the last element in a list, or block until one is available
    `rx.Single<String>` | `rxBrpoplpush(String key, String destkey, int seconds)` Pop a value from a list, push it to another list and return it; or block until one is available
    `rx.Single<JsonArray>` | `rxBrpopMany(List<String> keys, int seconds)` Remove and get the last element in any of the lists, or block until one is available
    `rx.Single<String>` | `rxClientGetname()` Get the current connection name
    `rx.Single<Long>` | `rxClientKill(KillFilter filter)` Kill the connection of a client
    `rx.Single<String>` | `rxClientList()` Get the list of client connections
    `rx.Single<String>` | `rxClientPause(long millis)` Stop processing commands from clients for some time
    `rx.Single<String>` | `rxClientReply(ClientReplyOptions options)` Instruct the server whether to reply to commands.
    `rx.Single<String>` | `rxClientSetname(String name)` Set the current connection name
    `rx.Single<Void>` | `rxClose()` Close the client - when it is fully closed the handler will be called.
    `rx.Single<Void>` | `rxClusterAddslots(List<Long> slots)` Assign new hash slots to receiving node.
    `rx.Single<Long>` | `rxClusterCountFailureReports(String nodeId)` Return the number of failure reports active for a given node.
    `rx.Single<Long>` | `rxClusterCountkeysinslot(long slot)` Return the number of local keys in the specified hash slot.
    `rx.Single<Void>` | `rxClusterDelslots(long slot)` Set hash slots as unbound in receiving node.
    `rx.Single<Void>` | `rxClusterDelslotsMany(List<Long> slots)` Set hash slots as unbound in receiving node.
    `rx.Single<Void>` | `rxClusterFailover()` Forces a slave to perform a manual failover of its master.
    `rx.Single<Void>` | `rxClusterFailOverWithOptions(FailoverOptions options)` Forces a slave to perform a manual failover of its master.
    `rx.Single<Void>` | `rxClusterForget(String nodeId)` Remove a node from the nodes table.
    `rx.Single<JsonArray>` | `rxClusterGetkeysinslot(long slot, long count)` Return local key names in the specified hash slot.
    `rx.Single<JsonArray>` | `rxClusterInfo()` Provides info about Redis Cluster node state.
    `rx.Single<Long>` | `rxClusterKeyslot(String key)` Returns the hash slot of the specified key.
    `rx.Single<Void>` | `rxClusterMeet(String ip, long port)` Force a node cluster to handshake with another node.
    `rx.Single<JsonArray>` | `rxClusterNodes()` Get Cluster config for the node.
    `rx.Single<Void>` | `rxClusterReplicate(String nodeId)` Reconfigure a node as a slave of the specified master node.
    `rx.Single<Void>` | `rxClusterReset()` Reset a Redis Cluster node.
    `rx.Single<Void>` | `rxClusterResetWithOptions(ResetOptions options)` Reset a Redis Cluster node.
    `rx.Single<Void>` | `rxClusterSaveconfig()` Forces the node to save cluster state on disk.
    `rx.Single<Void>` | `rxClusterSetConfigEpoch(long epoch)` Set the configuration epoch in a new node.
    `rx.Single<Void>` | `rxClusterSetslot(long slot, SlotCmd subcommand)` Bind an hash slot to a specific node.
    `rx.Single<Void>` | `rxClusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId)` Bind an hash slot to a specific node.
    `rx.Single<JsonArray>` | `rxClusterSlaves(String nodeId)` List slave nodes of the specified master node.
    `rx.Single<JsonArray>` | `rxClusterSlots()` Get array of Cluster slot to node mappings
    `rx.Single<JsonArray>` | `rxCommand()` Get array of Redis command details
    `rx.Single<Long>` | `rxCommandCount()` Get total number of Redis commands
    `rx.Single<JsonArray>` | `rxCommandGetkeys()` Extract keys given a full Redis command
    `rx.Single<JsonArray>` | `rxCommandInfo(List<String> commands)` Get array of specific Redis command details
    `rx.Single<JsonArray>` | `rxConfigGet(String parameter)` Get the value of a configuration parameter
    `rx.Single<String>` | `rxConfigResetstat()` Reset the stats returned by INFO
    `rx.Single<String>` | `rxConfigRewrite()` Rewrite the configuration file with the in memory configuration
    `rx.Single<String>` | `rxConfigSet(String parameter, String value)` Set a configuration parameter to the given value
    `rx.Single<Long>` | `rxDbsize()` Return the number of keys in the selected database
    `rx.Single<String>` | `rxDebugObject(String key)` Get debugging information about a key
    `rx.Single<String>` | `rxDebugSegfault()` Make the server crash
    `rx.Single<Long>` | `rxDecr(String key)` Decrement the integer value of a key by one
    `rx.Single<Long>` | `rxDecrby(String key, long decrement)` Decrement the integer value of a key by the given number
    `rx.Single<Long>` | `rxDel(String key)` Delete a key
    `rx.Single<Long>` | `rxDelMany(List<String> keys)` Delete many keys
    `rx.Single<String>` | `rxDump(String key)` Return a serialized version of the value stored at the specified key.
    `rx.Single<String>` | `rxEcho(String message)` Echo the given string
    `rx.Single<JsonArray>` | `rxEval(String script, List<String> keys, List<String> args)` Execute a Lua script server side.
    `rx.Single<JsonArray>` | `rxEvalsha(String sha1, List<String> keys, List<String> values)` Execute a Lua script server side.
    `rx.Single<Long>` | `rxExists(String key)` Determine if a key exists
    `rx.Single<Long>` | `rxExpire(String key, long seconds)` Set a key's time to live in seconds
    `rx.Single<Long>` | `rxExpireat(String key, long seconds)` Set the expiration for a key as a UNIX timestamp
    `rx.Single<String>` | `rxFlushall()` Remove all keys from all databases
    `rx.Single<String>` | `rxFlushdb()` Remove all keys from the current database
    `rx.Single<Long>` | `rxGeoadd(String key, double longitude, double latitude, String member)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `rx.Single<Long>` | `rxGeoaddMany(String key, List<GeoMember> members)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `rx.Single<String>` | `rxGeodist(String key, String member1, String member2)` Return the distance between two members in the geospatial index represented by the sorted set.
    `rx.Single<String>` | `rxGeodistWithUnit(String key, String member1, String member2, GeoUnit unit)` Return the distance between two members in the geospatial index represented by the sorted set.
    `rx.Single<JsonArray>` | `rxGeohash(String key, String member)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `rx.Single<JsonArray>` | `rxGeohashMany(String key, List<String> members)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `rx.Single<JsonArray>` | `rxGeopos(String key, String member)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `rx.Single<JsonArray>` | `rxGeoposMany(String key, List<String> members)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `rx.Single<JsonArray>` | `rxGeoradius(String key, double longitude, double latitude, double radius, GeoUnit unit)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `rx.Single<JsonArray>` | `rxGeoradiusbymember(String key, String member, double radius, GeoUnit unit)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `rx.Single<JsonArray>` | `rxGeoradiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `rx.Single<JsonArray>` | `rxGeoradiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `rx.Single<String>` | `rxGet(String key)` Get the value of a key
    `rx.Single<Buffer>` | `rxGetBinary(String key)` Get the value of a key - without decoding as utf-8
    `rx.Single<Long>` | `rxGetbit(String key, long offset)` Returns the bit value at offset in the string value stored at key
    `rx.Single<String>` | `rxGetrange(String key, long start, long end)` Get a substring of the string stored at a key
    `rx.Single<String>` | `rxGetset(String key, String value)` Set the string value of a key and return its old value
    `rx.Single<Long>` | `rxHdel(String key, String field)` Delete one or more hash fields
    `rx.Single<Long>` | `rxHdelMany(String key, List<String> fields)` Delete one or more hash fields
    `rx.Single<Long>` | `rxHexists(String key, String field)` Determine if a hash field exists
    `rx.Single<String>` | `rxHget(String key, String field)` Get the value of a hash field
    `rx.Single<JsonObject>` | `rxHgetall(String key)` Get all the fields and values in a hash
    `rx.Single<Long>` | `rxHincrby(String key, String field, long increment)` Increment the integer value of a hash field by the given number
    `rx.Single<String>` | `rxHincrbyfloat(String key, String field, double increment)` Increment the float value of a hash field by the given amount
    `rx.Single<JsonArray>` | `rxHkeys(String key)` Get all the fields in a hash
    `rx.Single<Long>` | `rxHlen(String key)` Get the number of fields in a hash
    `rx.Single<JsonArray>` | `rxHmget(String key, List<String> fields)` Get the values of all the given hash fields
    `rx.Single<String>` | `rxHmset(String key, JsonObject values)` Set multiple hash fields to multiple values
    `rx.Single<JsonArray>` | `rxHscan(String key, String cursor, ScanOptions options)` Incrementally iterate hash fields and associated values
    `rx.Single<Long>` | `rxHset(String key, String field, String value)` Set the string value of a hash field
    `rx.Single<Long>` | `rxHsetnx(String key, String field, String value)` Set the value of a hash field, only if the field does not exist
    `rx.Single<Long>` | `rxHstrlen(String key, String field)` Get the length of the value of a hash field.
    `rx.Single<JsonArray>` | `rxHvals(String key)` Get all the values in a hash
    `rx.Single<Long>` | `rxIncr(String key)` Increment the integer value of a key by one
    `rx.Single<Long>` | `rxIncrby(String key, long increment)` Increment the integer value of a key by the given amount
    `rx.Single<String>` | `rxIncrbyfloat(String key, double increment)` Increment the float value of a key by the given amount
    `rx.Single<JsonObject>` | `rxInfo()` Get information and statistics about the server
    `rx.Single<JsonObject>` | `rxInfoSection(String section)` Get information and statistics about the server
    `rx.Single<JsonArray>` | `rxKeys(String pattern)` Find all keys matching the given pattern
    `rx.Single<Long>` | `rxLastsave()` Get the UNIX time stamp of the last successful save to disk
    `rx.Single<String>` | `rxLindex(String key, int index)` Get an element from a list by its index
    `rx.Single<Long>` | `rxLinsert(String key, InsertOptions option, String pivot, String value)` Insert an element before or after another element in a list
    `rx.Single<Long>` | `rxLlen(String key)` Get the length of a list
    `rx.Single<String>` | `rxLpop(String key)` Remove and get the first element in a list
    `rx.Single<Long>` | `rxLpush(String key, String value)` Prepend one value to a list
    `rx.Single<Long>` | `rxLpushMany(String key, List<String> values)` Prepend one or multiple values to a list
    `rx.Single<Long>` | `rxLpushx(String key, String value)` Prepend a value to a list, only if the list exists
    `rx.Single<JsonArray>` | `rxLrange(String key, long from, long to)` Get a range of elements from a list
    `rx.Single<Long>` | `rxLrem(String key, long count, String value)` Remove elements from a list
    `rx.Single<String>` | `rxLset(String key, long index, String value)` Set the value of an element in a list by its index
    `rx.Single<String>` | `rxLtrim(String key, long from, long to)` Trim a list to the specified range
    `rx.Single<JsonArray>` | `rxMget(String key)` Get the value of the given key
    `rx.Single<JsonArray>` | `rxMgetMany(List<String> keys)` Get the values of all the given keys
    `rx.Single<String>` | `rxMigrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options)` Atomically transfer a key from a Redis instance to another one.
    `rx.Single<Void>` | `rxMonitor()` Listen for all requests received by the server in real time
    `rx.Single<Long>` | `rxMove(String key, int destdb)` Move a key to another database
    `rx.Single<String>` | `rxMset(JsonObject keyvals)` Set multiple keys to multiple values
    `rx.Single<Long>` | `rxMsetnx(JsonObject keyvals)` Set multiple keys to multiple values, only if none of the keys exist
    `rx.Single<Void>` | `rxObject(String key, ObjectCmd cmd)` Inspect the internals of Redis objects
    `rx.Single<Long>` | `rxPersist(String key)` Remove the expiration from a key
    `rx.Single<Long>` | `rxPexpire(String key, long millis)` Set a key's time to live in milliseconds
    `rx.Single<Long>` | `rxPexpireat(String key, long millis)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `rx.Single<Long>` | `rxPfadd(String key, String element)` Adds the specified element to the specified HyperLogLog.
    `rx.Single<Long>` | `rxPfaddMany(String key, List<String> elements)` Adds the specified elements to the specified HyperLogLog.
    `rx.Single<Long>` | `rxPfcount(String key)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `rx.Single<Long>` | `rxPfcountMany(List<String> keys)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `rx.Single<String>` | `rxPfmerge(String destkey, List<String> keys)` Merge N different HyperLogLogs into a single one.
    `rx.Single<String>` | `rxPing()` Ping the server
    `rx.Single<Void>` | `rxPsetex(String key, long millis, String value)` Set the value and expiration in milliseconds of a key
    `rx.Single<JsonArray>` | `rxPsubscribe(String pattern)` Listen for messages published to channels matching the given pattern
    `rx.Single<JsonArray>` | `rxPsubscribeMany(List<String> patterns)` Listen for messages published to channels matching the given patterns
    `rx.Single<Long>` | `rxPttl(String key)` Get the time to live for a key in milliseconds
    `rx.Single<Long>` | `rxPublish(String channel, String message)` Post a message to a channel
    `rx.Single<JsonArray>` | `rxPubsubChannels(String pattern)` Lists the currently active channels - only those matching the pattern
    `rx.Single<Long>` | `rxPubsubNumpat()` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `rx.Single<JsonArray>` | `rxPubsubNumsub(List<String> channels)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `rx.Single<Void>` | `rxPunsubscribe(List<String> patterns)` Stop listening for messages posted to channels matching the given patterns
    `rx.Single<String>` | `rxRandomkey()` Return a random key from the keyspace
    `rx.Single<String>` | `rxRename(String key, String newkey)` Rename a key
    `rx.Single<Long>` | `rxRenamenx(String key, String newkey)` Rename a key, only if the new key does not exist
    `rx.Single<String>` | `rxRestore(String key, long millis, String serialized)` Create a key using the provided serialized value, previously obtained using DUMP.
    `rx.Single<JsonArray>` | `rxRole()` Return the role of the instance in the context of replication
    `rx.Single<String>` | `rxRpop(String key)` Remove and get the last element in a list
    `rx.Single<String>` | `rxRpoplpush(String key, String destkey)` Remove the last element in a list, append it to another list and return it
    `rx.Single<Long>` | `rxRpush(String key, String value)` Append one or multiple values to a list
    `rx.Single<Long>` | `rxRpushMany(String key, List<String> values)` Append one or multiple values to a list
    `rx.Single<Long>` | `rxRpushx(String key, String value)` Append a value to a list, only if the list exists
    `rx.Single<Long>` | `rxSadd(String key, String member)` Add a member to a set
    `rx.Single<Long>` | `rxSaddMany(String key, List<String> members)` Add one or more members to a set
    `rx.Single<String>` | `rxSave()` Synchronously save the dataset to disk
    `rx.Single<JsonArray>` | `rxScan(String cursor, ScanOptions options)` Incrementally iterate the keys space
    `rx.Single<Long>` | `rxScard(String key)` Get the number of members in a set
    `rx.Single<String>` | `rxScriptDebug(ScriptDebugOptions scriptDebugOptions)` Set the debug mode for executed scripts.
    `rx.Single<JsonArray>` | `rxScriptExists(String script)` Check existence of script in the script cache.
    `rx.Single<JsonArray>` | `rxScriptExistsMany(List<String> scripts)` Check existence of scripts in the script cache.
    `rx.Single<String>` | `rxScriptFlush()` Remove all the scripts from the script cache.
    `rx.Single<String>` | `rxScriptKill()` Kill the script currently in execution.
    `rx.Single<String>` | `rxScriptLoad(String script)` Load the specified Lua script into the script cache.
    `rx.Single<JsonArray>` | `rxSdiff(String key, List<String> cmpkeys)` Subtract multiple sets
    `rx.Single<Long>` | `rxSdiffstore(String destkey, String key, List<String> cmpkeys)` Subtract multiple sets and store the resulting set in a key
    `rx.Single<String>` | `rxSelect(int dbindex)` Change the selected database for the current connection
    `rx.Single<Void>` | `rxSet(String key, String value)` Set the string value of a key
    `rx.Single<Void>` | `rxSetBinary(String key, Buffer value)` Set the binary string value of a key - without encoding as utf-8
    `rx.Single<Void>` | `rxSetBinaryWithOptions(String key, Buffer value, SetOptions options)` Set the string value of a key
    `rx.Single<Long>` | `rxSetbit(String key, long offset, int bit)` Sets or clears the bit at offset in the string value stored at key
    `rx.Single<String>` | `rxSetex(String key, long seconds, String value)` Set the value and expiration of a key
    `rx.Single<Long>` | `rxSetnx(String key, String value)` Set the value of a key, only if the key does not exist
    `rx.Single<Long>` | `rxSetrange(String key, int offset, String value)` Overwrite part of a string at key starting at the specified offset
    `rx.Single<String>` | `rxSetWithOptions(String key, String value, SetOptions options)` Set the string value of a key
    `rx.Single<JsonArray>` | `rxSinter(List<String> keys)` Intersect multiple sets
    `rx.Single<Long>` | `rxSinterstore(String destkey, List<String> keys)` Intersect multiple sets and store the resulting set in a key
    `rx.Single<Long>` | `rxSismember(String key, String member)` Determine if a given value is a member of a set
    `rx.Single<String>` | `rxSlaveof(String host, int port)` Make the server a slave of another instance
    `rx.Single<String>` | `rxSlaveofNoone()` Make this server a master
    `rx.Single<JsonArray>` | `rxSlowlogGet(int limit)` Read the Redis slow queries log
    `rx.Single<Long>` | `rxSlowlogLen()` Get the length of the Redis slow queries log
    `rx.Single<Void>` | `rxSlowlogReset()` Reset the Redis slow queries log
    `rx.Single<JsonArray>` | `rxSmembers(String key)` Get all the members in a set
    `rx.Single<Long>` | `rxSmove(String key, String destkey, String member)` Move a member from one set to another
    `rx.Single<JsonArray>` | `rxSort(String key, SortOptions options)` Sort the elements in a list, set or sorted set
    `rx.Single<String>` | `rxSpop(String key)` Remove and return a random member from a set
    `rx.Single<JsonArray>` | `rxSpopMany(String key, int count)` Remove and return random members from a set
    `rx.Single<String>` | `rxSrandmember(String key)` Get one or multiple random members from a set
    `rx.Single<JsonArray>` | `rxSrandmemberCount(String key, int count)` Get one or multiple random members from a set
    `rx.Single<Long>` | `rxSrem(String key, String member)` Remove one member from a set
    `rx.Single<Long>` | `rxSremMany(String key, List<String> members)` Remove one or more members from a set
    `rx.Single<JsonArray>` | `rxSscan(String key, String cursor, ScanOptions options)` Incrementally iterate Set elements
    `rx.Single<Long>` | `rxStrlen(String key)` Get the length of the value stored in a key
    `rx.Single<JsonArray>` | `rxSubscribe(String channel)` Listen for messages published to the given channels
    `rx.Single<JsonArray>` | `rxSubscribeMany(List<String> channels)` Listen for messages published to the given channels
    `rx.Single<JsonArray>` | `rxSunion(List<String> keys)` Add multiple sets
    `rx.Single<Long>` | `rxSunionstore(String destkey, List<String> keys)` Add multiple sets and store the resulting set in a key
    `rx.Single<Void>` | `rxSync()` Internal command used for replication
    `rx.Single<JsonArray>` | `rxTime()` Return the current server time
    `rx.Single<Long>` | `rxTouch(String key)` Alters the last access time of a key(s).
    `rx.Single<Long>` | `rxTouchMany(List<String> keys)` Alters the last access time of a key(s).
    `rx.Single<Long>` | `rxTtl(String key)` Get the time to live for a key
    `rx.Single<String>` | `rxType(String key)` Determine the type stored at key
    `rx.Single<Void>` | `rxUnsubscribe(List<String> channels)` Stop listening for messages posted to the given channels
    `rx.Single<String>` | `rxWait(long numSlaves, long timeout)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `rx.Single<Long>` | `rxZadd(String key, double score, String member)` Add one or more members to a sorted set, or update its score if it already exists
    `rx.Single<Long>` | `rxZaddMany(String key, Map<String,Double> members)` Add one or more members to a sorted set, or update its score if it already exists
    `rx.Single<Long>` | `rxZcard(String key)` Get the number of members in a sorted set
    `rx.Single<Long>` | `rxZcount(String key, double min, double max)` Count the members in a sorted set with scores within the given values
    `rx.Single<String>` | `rxZincrby(String key, double increment, String member)` Increment the score of a member in a sorted set
    `rx.Single<Long>` | `rxZinterstore(String destkey, List<String> sets, AggregateOptions options)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `rx.Single<Long>` | `rxZinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `rx.Single<Long>` | `rxZlexcount(String key, String min, String max)` Count the number of members in a sorted set between a given lexicographical range
    `rx.Single<JsonArray>` | `rxZrange(String key, long start, long stop)` Return a range of members in a sorted set, by index
    `rx.Single<JsonArray>` | `rxZrangebylex(String key, String min, String max, LimitOptions options)` Return a range of members in a sorted set, by lexicographical range
    `rx.Single<JsonArray>` | `rxZrangebyscore(String key, String min, String max, RangeLimitOptions options)` Return a range of members in a sorted set, by score
    `rx.Single<JsonArray>` | `rxZrangeWithOptions(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index
    `rx.Single<Long>` | `rxZrank(String key, String member)` Determine the index of a member in a sorted set
    `rx.Single<Long>` | `rxZrem(String key, String member)` Remove one member from a sorted set
    `rx.Single<Long>` | `rxZremMany(String key, List<String> members)` Remove one or more members from a sorted set
    `rx.Single<Long>` | `rxZremrangebylex(String key, String min, String max)` Remove all members in a sorted set between the given lexicographical range
    `rx.Single<Long>` | `rxZremrangebyrank(String key, long start, long stop)` Remove all members in a sorted set within the given indexes
    `rx.Single<Long>` | `rxZremrangebyscore(String key, String min, String max)` Remove all members in a sorted set within the given scores
    `rx.Single<JsonArray>` | `rxZrevrange(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `rx.Single<JsonArray>` | `rxZrevrangebylex(String key, String max, String min, LimitOptions options)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `rx.Single<JsonArray>` | `rxZrevrangebyscore(String key, String max, String min, RangeLimitOptions options)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `rx.Single<Long>` | `rxZrevrank(String key, String member)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `rx.Single<JsonArray>` | `rxZscan(String key, String cursor, ScanOptions options)` Incrementally iterate sorted sets elements and associated scores
    `rx.Single<String>` | `rxZscore(String key, String member)` Get the score associated with the given member in a sorted set
    `rx.Single<Long>` | `rxZunionstore(String destkey, List<String> sets, AggregateOptions options)` Add multiple sorted sets and store the resulting sorted set in a new key
    `rx.Single<Long>` | `rxZunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key
    `RedisClient` | `sadd(String key, String member, Handler<AsyncResult<Long>> handler)` Add a member to a set
    `RedisClient` | `saddMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a set
    `rx.Observable<Long>` | `saddManyObservable(String key, List<String> members)` Deprecated. use `rxSaddMany(java.lang.String, java.util.List<java.lang.String>)` instead
    `rx.Observable<Long>` | `saddObservable(String key, String member)` Deprecated. use `rxSadd(java.lang.String, java.lang.String)` instead
    `RedisClient` | `save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `rx.Observable<String>` | `saveObservable()` Deprecated. use `rxSave()` instead
    `RedisClient` | `scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate the keys space
    `rx.Observable<JsonArray>` | `scanObservable(String cursor, ScanOptions options)` Deprecated. use `rxScan(java.lang.String, io.vertx.redis.op.ScanOptions)` instead
    `RedisClient` | `scard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a set
    `rx.Observable<Long>` | `scardObservable(String key)` Deprecated. use `rxScard(java.lang.String)` instead
    `RedisClient` | `scriptDebug(ScriptDebugOptions scriptDebugOptions, Handler<AsyncResult<String>> handler)` Set the debug mode for executed scripts.
    `rx.Observable<String>` | `scriptDebugObservable(ScriptDebugOptions scriptDebugOptions)` Deprecated. use `rxScriptDebug(io.vertx.redis.op.ScriptDebugOptions)` instead
    `RedisClient` | `scriptExists(String script, Handler<AsyncResult<JsonArray>> handler)` Check existence of script in the script cache.
    `RedisClient` | `scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler)` Check existence of scripts in the script cache.
    `rx.Observable<JsonArray>` | `scriptExistsManyObservable(List<String> scripts)` Deprecated. use `rxScriptExistsMany(java.util.List<java.lang.String>)` instead
    `rx.Observable<JsonArray>` | `scriptExistsObservable(String script)` Deprecated. use `rxScriptExists(java.lang.String)` instead
    `RedisClient` | `scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `rx.Observable<String>` | `scriptFlushObservable()` Deprecated. use `rxScriptFlush()` instead
    `RedisClient` | `scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `rx.Observable<String>` | `scriptKillObservable()` Deprecated. use `rxScriptKill()` instead
    `RedisClient` | `scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `rx.Observable<String>` | `scriptLoadObservable(String script)` Deprecated. use `rxScriptLoad(java.lang.String)` instead
    `RedisClient` | `sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
    `rx.Observable<JsonArray>` | `sdiffObservable(String key, List<String> cmpkeys)` Deprecated. use `rxSdiff(java.lang.String, java.util.List<java.lang.String>)` instead
    `RedisClient` | `sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<Long>> handler)` Subtract multiple sets and store the resulting set in a key
    `rx.Observable<Long>` | `sdiffstoreObservable(String destkey, String key, List<String> cmpkeys)` Deprecated. use `rxSdiffstore(java.lang.String, java.lang.String, java.util.List<java.lang.String>)` instead
    `RedisClient` | `select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
    `rx.Observable<String>` | `selectObservable(int dbindex)` Deprecated. use `rxSelect(int)` instead
    `RedisClient` | `set(String key, String value, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `RedisClient` | `setBinary(String key, Buffer value, Handler<AsyncResult<Void>> handler)` Set the binary string value of a key - without encoding as utf-8
    `rx.Observable<Void>` | `setBinaryObservable(String key, Buffer value)` Deprecated. use `rxSetBinary(java.lang.String, io.vertx.rxjava.core.buffer.Buffer)` instead
    `RedisClient` | `setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `rx.Observable<Void>` | `setBinaryWithOptionsObservable(String key, Buffer value, SetOptions options)` Deprecated. use `rxSetBinaryWithOptions(java.lang.String, io.vertx.rxjava.core.buffer.Buffer, io.vertx.redis.op.SetOptions)` instead
    `RedisClient` | `setbit(String key, long offset, int bit, Handler<AsyncResult<Long>> handler)` Sets or clears the bit at offset in the string value stored at key
    `rx.Observable<Long>` | `setbitObservable(String key, long offset, int bit)` Deprecated. use `rxSetbit(java.lang.String, long, int)` instead
    `RedisClient` | `setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
    `rx.Observable<String>` | `setexObservable(String key, long seconds, String value)` Deprecated. use `rxSetex(java.lang.String, long, java.lang.String)` instead
    `RedisClient` | `setnx(String key, String value, Handler<AsyncResult<Long>> handler)` Set the value of a key, only if the key does not exist
    `rx.Observable<Long>` | `setnxObservable(String key, String value)` Deprecated. use `rxSetnx(java.lang.String, java.lang.String)` instead
    `rx.Observable<Void>` | `setObservable(String key, String value)` Deprecated. use `rxSet(java.lang.String, java.lang.String)` instead
    `RedisClient` | `setrange(String key, int offset, String value, Handler<AsyncResult<Long>> handler)` Overwrite part of a string at key starting at the specified offset
    `rx.Observable<Long>` | `setrangeObservable(String key, int offset, String value)` Deprecated. use `rxSetrange(java.lang.String, int, java.lang.String)` instead
    `RedisClient` | `setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `rx.Observable<String>` | `setWithOptionsObservable(String key, String value, SetOptions options)` Deprecated. use `rxSetWithOptions(java.lang.String, java.lang.String, io.vertx.redis.op.SetOptions)` instead
    `RedisClient` | `sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
    `rx.Observable<JsonArray>` | `sinterObservable(List<String> keys)` Deprecated. use `rxSinter(java.util.List<java.lang.String>)` instead
    `RedisClient` | `sinterstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Intersect multiple sets and store the resulting set in a key
    `rx.Observable<Long>` | `sinterstoreObservable(String destkey, List<String> keys)` Deprecated. use `rxSinterstore(java.lang.String, java.util.List<java.lang.String>)` instead
    `RedisClient` | `sismember(String key, String member, Handler<AsyncResult<Long>> handler)` Determine if a given value is a member of a set
    `rx.Observable<Long>` | `sismemberObservable(String key, String member)` Deprecated. use `rxSismember(java.lang.String, java.lang.String)` instead
    `RedisClient` | `slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Make the server a slave of another instance
    `RedisClient` | `slaveofNoone(Handler<AsyncResult<String>> handler)` Make this server a master
    `rx.Observable<String>` | `slaveofNooneObservable()` Deprecated. use `rxSlaveofNoone()` instead
    `rx.Observable<String>` | `slaveofObservable(String host, int port)` Deprecated. use `rxSlaveof(java.lang.String, int)` instead
    `RedisClient` | `slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
    `rx.Observable<JsonArray>` | `slowlogGetObservable(int limit)` Deprecated. use `rxSlowlogGet(int)` instead
    `RedisClient` | `slowlogLen(Handler<AsyncResult<Long>> handler)` Get the length of the Redis slow queries log
    `rx.Observable<Long>` | `slowlogLenObservable()` Deprecated. use `rxSlowlogLen()` instead
    `RedisClient` | `slowlogReset(Handler<AsyncResult<Void>> handler)` Reset the Redis slow queries log
    `rx.Observable<Void>` | `slowlogResetObservable()` Deprecated. use `rxSlowlogReset()` instead
    `RedisClient` | `smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `rx.Observable<JsonArray>` | `smembersObservable(String key)` Deprecated. use `rxSmembers(java.lang.String)` instead
    `RedisClient` | `smove(String key, String destkey, String member, Handler<AsyncResult<Long>> handler)` Move a member from one set to another
    `rx.Observable<Long>` | `smoveObservable(String key, String destkey, String member)` Deprecated. use `rxSmove(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisClient` | `sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Sort the elements in a list, set or sorted set
    `rx.Observable<JsonArray>` | `sortObservable(String key, SortOptions options)` Deprecated. use `rxSort(java.lang.String, io.vertx.redis.op.SortOptions)` instead
    `RedisClient` | `spop(String key, Handler<AsyncResult<String>> handler)` Remove and return a random member from a set
    `RedisClient` | `spopMany(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Remove and return random members from a set
    `rx.Observable<JsonArray>` | `spopManyObservable(String key, int count)` Deprecated. use `rxSpopMany(java.lang.String, int)` instead
    `rx.Observable<String>` | `spopObservable(String key)` Deprecated. use `rxSpop(java.lang.String)` instead
    `RedisClient` | `srandmember(String key, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisClient` | `srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler)` Get one or multiple random members from a set
    `rx.Observable<JsonArray>` | `srandmemberCountObservable(String key, int count)` Deprecated. use `rxSrandmemberCount(java.lang.String, int)` instead
    `rx.Observable<String>` | `srandmemberObservable(String key)` Deprecated. use `rxSrandmember(java.lang.String)` instead
    `RedisClient` | `srem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a set
    `RedisClient` | `sremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a set
    `rx.Observable<Long>` | `sremManyObservable(String key, List<String> members)` Deprecated. use `rxSremMany(java.lang.String, java.util.List<java.lang.String>)` instead
    `rx.Observable<Long>` | `sremObservable(String key, String member)` Deprecated. use `rxSrem(java.lang.String, java.lang.String)` instead
    `RedisClient` | `sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate Set elements
    `rx.Observable<JsonArray>` | `sscanObservable(String key, String cursor, ScanOptions options)` Deprecated. use `rxSscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions)` instead
    `RedisClient` | `strlen(String key, Handler<AsyncResult<Long>> handler)` Get the length of the value stored in a key
    `rx.Observable<Long>` | `strlenObservable(String key)` Deprecated. use `rxStrlen(java.lang.String)` instead
    `RedisClient` | `subscribe(String channel, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `RedisClient` | `subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Listen for messages published to the given channels
    `rx.Observable<JsonArray>` | `subscribeManyObservable(List<String> channels)` Deprecated. use `rxSubscribeMany(java.util.List<java.lang.String>)` instead
    `rx.Observable<JsonArray>` | `subscribeObservable(String channel)` Deprecated. use `rxSubscribe(java.lang.String)` instead
    `RedisClient` | `sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
    `rx.Observable<JsonArray>` | `sunionObservable(List<String> keys)` Deprecated. use `rxSunion(java.util.List<java.lang.String>)` instead
    `RedisClient` | `sunionstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Add multiple sets and store the resulting set in a key
    `rx.Observable<Long>` | `sunionstoreObservable(String destkey, List<String> keys)` Deprecated. use `rxSunionstore(java.lang.String, java.util.List<java.lang.String>)` instead
    `RedisClient` | `sync(Handler<AsyncResult<Void>> handler)` Internal command used for replication
    `rx.Observable<Void>` | `syncObservable()` Deprecated. use `rxSync()` instead
    `RedisClient` | `time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `rx.Observable<JsonArray>` | `timeObservable()` Deprecated. use `rxTime()` instead
    `RedisClient` | `touch(String key, Handler<AsyncResult<Long>> handler)` Alters the last access time of a key(s).
    `RedisClient` | `touchMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Alters the last access time of a key(s).
    `rx.Observable<Long>` | `touchManyObservable(List<String> keys)` Deprecated. use `rxTouchMany(java.util.List<java.lang.String>)` instead
    `rx.Observable<Long>` | `touchObservable(String key)` Deprecated. use `rxTouch(java.lang.String)` instead
    `RedisTransaction` | `transaction()` Return a RedisTransaction instance
    `RedisClient` | `ttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key
    `rx.Observable<Long>` | `ttlObservable(String key)` Deprecated. use `rxTtl(java.lang.String)` instead
    `RedisClient` | `type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `rx.Observable<String>` | `typeObservable(String key)` Deprecated. use `rxType(java.lang.String)` instead
    `RedisClient` | `unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to the given channels
    `rx.Observable<Void>` | `unsubscribeObservable(List<String> channels)` Deprecated. use `rxUnsubscribe(java.util.List<java.lang.String>)` instead
    `RedisClient` | `wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `rx.Observable<String>` | `waitObservable(long numSlaves, long timeout)` Deprecated. use `rxWait(long, long)` instead
    `RedisClient` | `zadd(String key, double score, String member, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisClient` | `zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<Long>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `rx.Observable<Long>` | `zaddManyObservable(String key, Map<String,Double> members)` Deprecated. use `rxZaddMany(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>)` instead
    `rx.Observable<Long>` | `zaddObservable(String key, double score, String member)` Deprecated. use `rxZadd(java.lang.String, double, java.lang.String)` instead
    `RedisClient` | `zcard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a sorted set
    `rx.Observable<Long>` | `zcardObservable(String key)` Deprecated. use `rxZcard(java.lang.String)` instead
    `RedisClient` | `zcount(String key, double min, double max, Handler<AsyncResult<Long>> handler)` Count the members in a sorted set with scores within the given values
    `rx.Observable<Long>` | `zcountObservable(String key, double min, double max)` Deprecated. use `rxZcount(java.lang.String, double, double)` instead
    `RedisClient` | `zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
    `rx.Observable<String>` | `zincrbyObservable(String key, double increment, String member)` Deprecated. use `rxZincrby(java.lang.String, double, java.lang.String)` instead
    `RedisClient` | `zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `rx.Observable<Long>` | `zinterstoreObservable(String destkey, List<String> sets, AggregateOptions options)` Deprecated. use `rxZinterstore(java.lang.String, java.util.List<java.lang.String>, io.vertx.redis.op.AggregateOptions)` instead
    `RedisClient` | `zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `rx.Observable<Long>` | `zinterstoreWeighedObservable(String destkey, Map<String,Double> sets, AggregateOptions options)` Deprecated. use `rxZinterstoreWeighed(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>, io.vertx.redis.op.AggregateOptions)` instead
    `RedisClient` | `zlexcount(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Count the number of members in a sorted set between a given lexicographical range
    `rx.Observable<Long>` | `zlexcountObservable(String key, String min, String max)` Deprecated. use `rxZlexcount(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisClient` | `zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `RedisClient` | `zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by lexicographical range
    `rx.Observable<JsonArray>` | `zrangebylexObservable(String key, String min, String max, LimitOptions options)` Deprecated. use `rxZrangebylex(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.LimitOptions)` instead
    `RedisClient` | `zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score
    `rx.Observable<JsonArray>` | `zrangebyscoreObservable(String key, String min, String max, RangeLimitOptions options)` Deprecated. use `rxZrangebyscore(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.RangeLimitOptions)` instead
    `rx.Observable<JsonArray>` | `zrangeObservable(String key, long start, long stop)` Deprecated. use `rxZrange(java.lang.String, long, long)` instead
    `RedisClient` | `zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index
    `rx.Observable<JsonArray>` | `zrangeWithOptionsObservable(String key, long start, long stop, RangeOptions options)` Deprecated. use `rxZrangeWithOptions(java.lang.String, long, long, io.vertx.redis.op.RangeOptions)` instead
    `RedisClient` | `zrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set
    `rx.Observable<Long>` | `zrankObservable(String key, String member)` Deprecated. use `rxZrank(java.lang.String, java.lang.String)` instead
    `RedisClient` | `zrem(String key, String member, Handler<AsyncResult<Long>> handler)` Remove one member from a sorted set
    `RedisClient` | `zremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler)` Remove one or more members from a sorted set
    `rx.Observable<Long>` | `zremManyObservable(String key, List<String> members)` Deprecated. use `rxZremMany(java.lang.String, java.util.List<java.lang.String>)` instead
    `rx.Observable<Long>` | `zremObservable(String key, String member)` Deprecated. use `rxZrem(java.lang.String, java.lang.String)` instead
    `RedisClient` | `zremrangebylex(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set between the given lexicographical range
    `rx.Observable<Long>` | `zremrangebylexObservable(String key, String min, String max)` Deprecated. use `rxZremrangebylex(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisClient` | `zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given indexes
    `rx.Observable<Long>` | `zremrangebyrankObservable(String key, long start, long stop)` Deprecated. use `rxZremrangebyrank(java.lang.String, long, long)` instead
    `RedisClient` | `zremrangebyscore(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given scores
    `rx.Observable<Long>` | `zremrangebyscoreObservable(String key, String min, String max)` Deprecated. use `rxZremrangebyscore(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisClient` | `zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisClient` | `zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `rx.Observable<JsonArray>` | `zrevrangebylexObservable(String key, String max, String min, LimitOptions options)` Deprecated. use `rxZrevrangebylex(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.LimitOptions)` instead
    `RedisClient` | `zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `rx.Observable<JsonArray>` | `zrevrangebyscoreObservable(String key, String max, String min, RangeLimitOptions options)` Deprecated. use `rxZrevrangebyscore(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.RangeLimitOptions)` instead
    `rx.Observable<JsonArray>` | `zrevrangeObservable(String key, long start, long stop, RangeOptions options)` Deprecated. use `rxZrevrange(java.lang.String, long, long, io.vertx.redis.op.RangeOptions)` instead
    `RedisClient` | `zrevrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `rx.Observable<Long>` | `zrevrankObservable(String key, String member)` Deprecated. use `rxZrevrank(java.lang.String, java.lang.String)` instead
    `RedisClient` | `zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate sorted sets elements and associated scores
    `rx.Observable<JsonArray>` | `zscanObservable(String key, String cursor, ScanOptions options)` Deprecated. use `rxZscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions)` instead
    `RedisClient` | `zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
    `rx.Observable<String>` | `zscoreObservable(String key, String member)` Deprecated. use `rxZscore(java.lang.String, java.lang.String)` instead
    `RedisClient` | `zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key
    `rx.Observable<Long>` | `zunionstoreObservable(String destkey, List<String> sets, AggregateOptions options)` Deprecated. use `rxZunionstore(java.lang.String, java.util.List<java.lang.String>, io.vertx.redis.op.AggregateOptions)` instead
    `RedisClient` | `zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key
    `rx.Observable<Long>` | `zunionstoreWeighedObservable(String key, Map<String,Double> sets, AggregateOptions options)` Deprecated. use `rxZunionstoreWeighed(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>, io.vertx.redis.op.AggregateOptions)` instead

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final TypeArg<RedisClient> __TYPE_ARG

  - ### Constructor Detail

    - #### RedisClient

          public RedisClient(RedisClient delegate)

  - ### Method Detail

    - #### getDelegate

          public RedisClient getDelegate()

    - #### create

          public static RedisClient create(Vertx vertx)

    - #### create

          public static RedisClient create(Vertx vertx,
                                           RedisOptions config)

    - #### close

          public void close(Handler<AsyncResult<Void>> handler)

      Close the client - when it is fully closed the handler will be called.
      Parameters:
        `handler` -

    - #### closeObservable

          @Deprecated
          public rx.Observable<Void> closeObservable()

      Deprecated. use `rxClose()` instead
      Close the client - when it is fully closed the handler will be called.
      Returns:

    - #### rxClose

          public rx.Single<Void> rxClose()

      Close the client - when it is fully closed the handler will be called.
      Returns:

    - #### append

          public RedisClient append(String key,
                                    String value,
                                    Handler<AsyncResult<Long>> handler)

      Append a value to a key
      Parameters:
        `key` - Key string
        `value` - Value to append
        `handler` - Handler for the result of this call.
      Returns:

    - #### appendObservable

          @Deprecated
          public rx.Observable<Long> appendObservable(String key,
                                                                  String value)

      Deprecated. use `rxAppend(java.lang.String, java.lang.String)` instead
      Append a value to a key
      Parameters:
        `key` - Key string
        `value` - Value to append
      Returns:

    - #### rxAppend

          public rx.Single<Long> rxAppend(String key,
                                          String value)

      Append a value to a key
      Parameters:
        `key` - Key string
        `value` - Value to append
      Returns:

    - #### auth

          public RedisClient auth(String password,
                                  Handler<AsyncResult<String>> handler)

      Authenticate to the server
      Parameters:
        `password` - Password for authentication
        `handler` - Handler for the result of this call.
      Returns:

    - #### authObservable

          @Deprecated
          public rx.Observable<String> authObservable(String password)

      Deprecated. use `rxAuth(java.lang.String)` instead
      Authenticate to the server
      Parameters:
        `password` - Password for authentication
      Returns:

    - #### rxAuth

          public rx.Single<String> rxAuth(String password)

      Authenticate to the server
      Parameters:
        `password` - Password for authentication
      Returns:

    - #### bgrewriteaof

          public RedisClient bgrewriteaof(Handler<AsyncResult<String>> handler)

      Asynchronously rewrite the append-only file
      Parameters:
        `handler` -
      Returns:

    - #### bgrewriteaofObservable

          @Deprecated
          public rx.Observable<String> bgrewriteaofObservable()

      Deprecated. use `rxBgrewriteaof()` instead
      Asynchronously rewrite the append-only file
      Returns:

    - #### rxBgrewriteaof

          public rx.Single<String> rxBgrewriteaof()

      Asynchronously rewrite the append-only file
      Returns:

    - #### bgsave

          public RedisClient bgsave(Handler<AsyncResult<String>> handler)

      Asynchronously save the dataset to disk
      Parameters:
        `handler` -
      Returns:

    - #### bgsaveObservable

          @Deprecated
          public rx.Observable<String> bgsaveObservable()

      Deprecated. use `rxBgsave()` instead
      Asynchronously save the dataset to disk
      Returns:

    - #### rxBgsave

          public rx.Single<String> rxBgsave()

      Asynchronously save the dataset to disk
      Returns:

    - #### bitcount

          public RedisClient bitcount(String key,
                                      Handler<AsyncResult<Long>> handler)

      Count set bits in a string
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitcountObservable

          @Deprecated
          public rx.Observable<Long> bitcountObservable(String key)

      Deprecated. use `rxBitcount(java.lang.String)` instead
      Count set bits in a string
      Parameters:
        `key` - Key string
      Returns:

    - #### rxBitcount

          public rx.Single<Long> rxBitcount(String key)

      Count set bits in a string
      Parameters:
        `key` - Key string
      Returns:

    - #### bitcountRange

          public RedisClient bitcountRange(String key,
                                           long start,
                                           long end,
                                           Handler<AsyncResult<Long>> handler)

      Count set bits in a string
      Parameters:
        `key` - Key string
        `start` - Start index
        `end` - End index
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitcountRangeObservable

          @Deprecated
          public rx.Observable<Long> bitcountRangeObservable(String key,
                                                                         long start,
                                                                         long end)

      Deprecated. use `rxBitcountRange(java.lang.String, long, long)` instead
      Count set bits in a string
      Parameters:
        `key` - Key string
        `start` - Start index
        `end` - End index
      Returns:

    - #### rxBitcountRange

          public rx.Single<Long> rxBitcountRange(String key,
                                                 long start,
                                                 long end)

      Count set bits in a string
      Parameters:
        `key` - Key string
        `start` - Start index
        `end` - End index
      Returns:

    - #### bitop

          public RedisClient bitop(BitOperation operation,
                                   String destkey,
                                   List<String> keys,
                                   Handler<AsyncResult<Long>> handler)

      Perform bitwise operations between strings
      Parameters:
        `operation` - Bitwise operation to perform
        `destkey` - Destination key where result is stored
        `keys` - List of keys on which to perform the operation
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitopObservable

          @Deprecated
          public rx.Observable<Long> bitopObservable(BitOperation operation,
                                                                 String destkey,
                                                                 List<String> keys)

      Deprecated. use `rxBitop(io.vertx.redis.op.BitOperation, java.lang.String, java.util.List<java.lang.String>)` instead
      Perform bitwise operations between strings
      Parameters:
        `operation` - Bitwise operation to perform
        `destkey` - Destination key where result is stored
        `keys` - List of keys on which to perform the operation
      Returns:

    - #### rxBitop

          public rx.Single<Long> rxBitop(BitOperation operation,
                                         String destkey,
                                         List<String> keys)

      Perform bitwise operations between strings
      Parameters:
        `operation` - Bitwise operation to perform
        `destkey` - Destination key where result is stored
        `keys` - List of keys on which to perform the operation
      Returns:

    - #### bitpos

          public RedisClient bitpos(String key,
                                    int bit,
                                    Handler<AsyncResult<Long>> handler)

      Find first bit set or clear in a string
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitposObservable

          @Deprecated
          public rx.Observable<Long> bitposObservable(String key,
                                                                  int bit)

      Deprecated. use `rxBitpos(java.lang.String, int)` instead
      Find first bit set or clear in a string
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
      Returns:

    - #### rxBitpos

          public rx.Single<Long> rxBitpos(String key,
                                          int bit)

      Find first bit set or clear in a string
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
      Returns:

    - #### bitposFrom

          public RedisClient bitposFrom(String key,
                                        int bit,
                                        int start,
                                        Handler<AsyncResult<Long>> handler)

      Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitposFromObservable

          @Deprecated
          public rx.Observable<Long> bitposFromObservable(String key,
                                                                      int bit,
                                                                      int start)

      Deprecated. use `rxBitposFrom(java.lang.String, int, int)` instead
      Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
      Returns:

    - #### rxBitposFrom

          public rx.Single<Long> rxBitposFrom(String key,
                                              int bit,
                                              int start)

      Find first bit set or clear in a string See also bitposRange() method, which takes start, and stop offset.
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
      Returns:

    - #### bitposRange

          public RedisClient bitposRange(String key,
                                         int bit,
                                         int start,
                                         int stop,
                                         Handler<AsyncResult<Long>> handler)

      Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
        `stop` - End offset - inclusive
        `handler` - Handler for the result of this call.
      Returns:

    - #### bitposRangeObservable

          @Deprecated
          public rx.Observable<Long> bitposRangeObservable(String key,
                                                                       int bit,
                                                                       int start,
                                                                       int stop)

      Deprecated. use `rxBitposRange(java.lang.String, int, int, int)` instead
      Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
        `stop` - End offset - inclusive
      Returns:

    - #### rxBitposRange

          public rx.Single<Long> rxBitposRange(String key,
                                               int bit,
                                               int start,
                                               int stop)

      Find first bit set or clear in a string Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified
      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
        `stop` - End offset - inclusive
      Returns:

    - #### blpop

          public RedisClient blpop(String key,
                                   int seconds,
                                   Handler<AsyncResult<JsonArray>> handler)

      Remove and get the first element in a list, or block until one is available
      Parameters:
        `key` - Key string identifying a list to watch
        `seconds` - Timeout in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### blpopObservable

          @Deprecated
          public rx.Observable<JsonArray> blpopObservable(String key,
                                                                      int seconds)

      Deprecated. use `rxBlpop(java.lang.String, int)` instead
      Remove and get the first element in a list, or block until one is available
      Parameters:
        `key` - Key string identifying a list to watch
        `seconds` - Timeout in seconds
      Returns:

    - #### rxBlpop

          public rx.Single<JsonArray> rxBlpop(String key,
                                              int seconds)

      Remove and get the first element in a list, or block until one is available
      Parameters:
        `key` - Key string identifying a list to watch
        `seconds` - Timeout in seconds
      Returns:

    - #### blpopMany

          public RedisClient blpopMany(List<String> keys,
                                       int seconds,
                                       Handler<AsyncResult<JsonArray>> handler)

      Remove and get the first element in any of the lists, or block until one is available
      Parameters:
        `keys` - List of key strings identifying lists to watch
        `seconds` - Timeout in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### blpopManyObservable

          @Deprecated
          public rx.Observable<JsonArray> blpopManyObservable(List<String> keys,
                                                                          int seconds)

      Deprecated. use `rxBlpopMany(java.util.List<java.lang.String>, int)` instead
      Remove and get the first element in any of the lists, or block until one is available
      Parameters:
        `keys` - List of key strings identifying lists to watch
        `seconds` - Timeout in seconds
      Returns:

    - #### rxBlpopMany

          public rx.Single<JsonArray> rxBlpopMany(List<String> keys,
                                                  int seconds)

      Remove and get the first element in any of the lists, or block until one is available
      Parameters:
        `keys` - List of key strings identifying lists to watch
        `seconds` - Timeout in seconds
      Returns:

    - #### brpop

          public RedisClient brpop(String key,
                                   int seconds,
                                   Handler<AsyncResult<JsonArray>> handler)

      Remove and get the last element in a list, or block until one is available
      Parameters:
        `key` - Key string identifying a list to watch
        `seconds` - Timeout in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### brpopObservable

          @Deprecated
          public rx.Observable<JsonArray> brpopObservable(String key,
                                                                      int seconds)

      Deprecated. use `rxBrpop(java.lang.String, int)` instead
      Remove and get the last element in a list, or block until one is available
      Parameters:
        `key` - Key string identifying a list to watch
        `seconds` - Timeout in seconds
      Returns:

    - #### rxBrpop

          public rx.Single<JsonArray> rxBrpop(String key,
                                              int seconds)

      Remove and get the last element in a list, or block until one is available
      Parameters:
        `key` - Key string identifying a list to watch
        `seconds` - Timeout in seconds
      Returns:

    - #### brpopMany

          public RedisClient brpopMany(List<String> keys,
                                       int seconds,
                                       Handler<AsyncResult<JsonArray>> handler)

      Remove and get the last element in any of the lists, or block until one is available
      Parameters:
        `keys` - List of key strings identifying lists to watch
        `seconds` - Timeout in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### brpopManyObservable

          @Deprecated
          public rx.Observable<JsonArray> brpopManyObservable(List<String> keys,
                                                                          int seconds)

      Deprecated. use `rxBrpopMany(java.util.List<java.lang.String>, int)` instead
      Remove and get the last element in any of the lists, or block until one is available
      Parameters:
        `keys` - List of key strings identifying lists to watch
        `seconds` - Timeout in seconds
      Returns:

    - #### rxBrpopMany

          public rx.Single<JsonArray> rxBrpopMany(List<String> keys,
                                                  int seconds)

      Remove and get the last element in any of the lists, or block until one is available
      Parameters:
        `keys` - List of key strings identifying lists to watch
        `seconds` - Timeout in seconds
      Returns:

    - #### brpoplpush

          public RedisClient brpoplpush(String key,
                                        String destkey,
                                        int seconds,
                                        Handler<AsyncResult<String>> handler)

      Pop a value from a list, push it to another list and return it; or block until one is available
      Parameters:
        `key` - Key string identifying the source list
        `destkey` - Key string identifying the destination list
        `seconds` - Timeout in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### brpoplpushObservable

          @Deprecated
          public rx.Observable<String> brpoplpushObservable(String key,
                                                                        String destkey,
                                                                        int seconds)

      Deprecated. use `rxBrpoplpush(java.lang.String, java.lang.String, int)` instead
      Pop a value from a list, push it to another list and return it; or block until one is available
      Parameters:
        `key` - Key string identifying the source list
        `destkey` - Key string identifying the destination list
        `seconds` - Timeout in seconds
      Returns:

    - #### rxBrpoplpush

          public rx.Single<String> rxBrpoplpush(String key,
                                                String destkey,
                                                int seconds)

      Pop a value from a list, push it to another list and return it; or block until one is available
      Parameters:
        `key` - Key string identifying the source list
        `destkey` - Key string identifying the destination list
        `seconds` - Timeout in seconds
      Returns:

    - #### clientKill

          public RedisClient clientKill(KillFilter filter,
                                        Handler<AsyncResult<Long>> handler)

      Kill the connection of a client
      Parameters:
        `filter` - Filter options
        `handler` - Handler for the result of this call.
      Returns:

    - #### clientKillObservable

          @Deprecated
          public rx.Observable<Long> clientKillObservable(KillFilter filter)

      Deprecated. use `rxClientKill(io.vertx.redis.op.KillFilter)` instead
      Kill the connection of a client
      Parameters:
        `filter` - Filter options
      Returns:

    - #### rxClientKill

          public rx.Single<Long> rxClientKill(KillFilter filter)

      Kill the connection of a client
      Parameters:
        `filter` - Filter options
      Returns:

    - #### clientList

          public RedisClient clientList(Handler<AsyncResult<String>> handler)

      Get the list of client connections
      Parameters:
        `handler` -
      Returns:

    - #### clientListObservable

          @Deprecated
          public rx.Observable<String> clientListObservable()

      Deprecated. use `rxClientList()` instead
      Get the list of client connections
      Returns:

    - #### rxClientList

          public rx.Single<String> rxClientList()

      Get the list of client connections
      Returns:

    - #### clientGetname

          public RedisClient clientGetname(Handler<AsyncResult<String>> handler)

      Get the current connection name
      Parameters:
        `handler` -
      Returns:

    - #### clientGetnameObservable

          @Deprecated
          public rx.Observable<String> clientGetnameObservable()

      Deprecated. use `rxClientGetname()` instead
      Get the current connection name
      Returns:

    - #### rxClientGetname

          public rx.Single<String> rxClientGetname()

      Get the current connection name
      Returns:

    - #### clientPause

          public RedisClient clientPause(long millis,
                                         Handler<AsyncResult<String>> handler)

      Stop processing commands from clients for some time
      Parameters:
        `millis` - Pause time in milliseconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### clientPauseObservable

          @Deprecated
          public rx.Observable<String> clientPauseObservable(long millis)

      Deprecated. use `rxClientPause(long)` instead
      Stop processing commands from clients for some time
      Parameters:
        `millis` - Pause time in milliseconds
      Returns:

    - #### rxClientPause

          public rx.Single<String> rxClientPause(long millis)

      Stop processing commands from clients for some time
      Parameters:
        `millis` - Pause time in milliseconds
      Returns:

    - #### clientSetname

          public RedisClient clientSetname(String name,
                                           Handler<AsyncResult<String>> handler)

      Set the current connection name
      Parameters:
        `name` - New name for current connection
        `handler` - Handler for the result of this call.
      Returns:

    - #### clientSetnameObservable

          @Deprecated
          public rx.Observable<String> clientSetnameObservable(String name)

      Deprecated. use `rxClientSetname(java.lang.String)` instead
      Set the current connection name
      Parameters:
        `name` - New name for current connection
      Returns:

    - #### rxClientSetname

          public rx.Single<String> rxClientSetname(String name)

      Set the current connection name
      Parameters:
        `name` - New name for current connection
      Returns:

    - #### clusterAddslots

          public RedisClient clusterAddslots(List<Long> slots,
                                             Handler<AsyncResult<Void>> handler)

      Assign new hash slots to receiving node.
      Parameters:
        `slots` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterAddslotsObservable

          @Deprecated
          public rx.Observable<Void> clusterAddslotsObservable(List<Long> slots)

      Deprecated. use `rxClusterAddslots(java.util.List<java.lang.Long>)` instead
      Assign new hash slots to receiving node.
      Parameters:
        `slots` -
      Returns:

    - #### rxClusterAddslots

          public rx.Single<Void> rxClusterAddslots(List<Long> slots)

      Assign new hash slots to receiving node.
      Parameters:
        `slots` -
      Returns:

    - #### clusterCountFailureReports

          public RedisClient clusterCountFailureReports(String nodeId,
                                                        Handler<AsyncResult<Long>> handler)

      Return the number of failure reports active for a given node.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterCountFailureReportsObservable

          @Deprecated
          public rx.Observable<Long> clusterCountFailureReportsObservable(String nodeId)

      Deprecated. use `rxClusterCountFailureReports(java.lang.String)` instead
      Return the number of failure reports active for a given node.
      Parameters:
        `nodeId` -
      Returns:

    - #### rxClusterCountFailureReports

          public rx.Single<Long> rxClusterCountFailureReports(String nodeId)

      Return the number of failure reports active for a given node.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterCountkeysinslot

          public RedisClient clusterCountkeysinslot(long slot,
                                                    Handler<AsyncResult<Long>> handler)

      Return the number of local keys in the specified hash slot.
      Parameters:
        `slot` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterCountkeysinslotObservable

          @Deprecated
          public rx.Observable<Long> clusterCountkeysinslotObservable(long slot)

      Deprecated. use `rxClusterCountkeysinslot(long)` instead
      Return the number of local keys in the specified hash slot.
      Parameters:
        `slot` -
      Returns:

    - #### rxClusterCountkeysinslot

          public rx.Single<Long> rxClusterCountkeysinslot(long slot)

      Return the number of local keys in the specified hash slot.
      Parameters:
        `slot` -
      Returns:

    - #### clusterDelslots

          public RedisClient clusterDelslots(long slot,
                                             Handler<AsyncResult<Void>> handler)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slot` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterDelslotsObservable

          @Deprecated
          public rx.Observable<Void> clusterDelslotsObservable(long slot)

      Deprecated. use `rxClusterDelslots(long)` instead
      Set hash slots as unbound in receiving node.
      Parameters:
        `slot` -
      Returns:

    - #### rxClusterDelslots

          public rx.Single<Void> rxClusterDelslots(long slot)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slot` -
      Returns:

    - #### clusterDelslotsMany

          public RedisClient clusterDelslotsMany(List<Long> slots,
                                                 Handler<AsyncResult<Void>> handler)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slots` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterDelslotsManyObservable

          @Deprecated
          public rx.Observable<Void> clusterDelslotsManyObservable(List<Long> slots)

      Deprecated. use `rxClusterDelslotsMany(java.util.List<java.lang.Long>)` instead
      Set hash slots as unbound in receiving node.
      Parameters:
        `slots` -
      Returns:

    - #### rxClusterDelslotsMany

          public rx.Single<Void> rxClusterDelslotsMany(List<Long> slots)

      Set hash slots as unbound in receiving node.
      Parameters:
        `slots` -
      Returns:

    - #### clusterFailover

          public RedisClient clusterFailover(Handler<AsyncResult<Void>> handler)

      Forces a slave to perform a manual failover of its master.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterFailoverObservable

          @Deprecated
          public rx.Observable<Void> clusterFailoverObservable()

      Deprecated. use `rxClusterFailover()` instead
      Forces a slave to perform a manual failover of its master.
      Returns:

    - #### rxClusterFailover

          public rx.Single<Void> rxClusterFailover()

      Forces a slave to perform a manual failover of its master.
      Returns:

    - #### clusterFailOverWithOptions

          public RedisClient clusterFailOverWithOptions(FailoverOptions options,
                                                        Handler<AsyncResult<Void>> handler)

      Forces a slave to perform a manual failover of its master.
      Parameters:
        `options` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterFailOverWithOptionsObservable

          @Deprecated
          public rx.Observable<Void> clusterFailOverWithOptionsObservable(FailoverOptions options)

      Deprecated. use `rxClusterFailOverWithOptions(io.vertx.redis.op.FailoverOptions)` instead
      Forces a slave to perform a manual failover of its master.
      Parameters:
        `options` -
      Returns:

    - #### rxClusterFailOverWithOptions

          public rx.Single<Void> rxClusterFailOverWithOptions(FailoverOptions options)

      Forces a slave to perform a manual failover of its master.
      Parameters:
        `options` -
      Returns:

    - #### clusterForget

          public RedisClient clusterForget(String nodeId,
                                           Handler<AsyncResult<Void>> handler)

      Remove a node from the nodes table.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterForgetObservable

          @Deprecated
          public rx.Observable<Void> clusterForgetObservable(String nodeId)

      Deprecated. use `rxClusterForget(java.lang.String)` instead
      Remove a node from the nodes table.
      Parameters:
        `nodeId` -
      Returns:

    - #### rxClusterForget

          public rx.Single<Void> rxClusterForget(String nodeId)

      Remove a node from the nodes table.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterGetkeysinslot

          public RedisClient clusterGetkeysinslot(long slot,
                                                  long count,
                                                  Handler<AsyncResult<JsonArray>> handler)

      Return local key names in the specified hash slot.
      Parameters:
        `slot` -
        `count` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterGetkeysinslotObservable

          @Deprecated
          public rx.Observable<JsonArray> clusterGetkeysinslotObservable(long slot,
                                                                                     long count)

      Deprecated. use `rxClusterGetkeysinslot(long, long)` instead
      Return local key names in the specified hash slot.
      Parameters:
        `slot` -
        `count` -
      Returns:

    - #### rxClusterGetkeysinslot

          public rx.Single<JsonArray> rxClusterGetkeysinslot(long slot,
                                                             long count)

      Return local key names in the specified hash slot.
      Parameters:
        `slot` -
        `count` -
      Returns:

    - #### clusterInfo

          public RedisClient clusterInfo(Handler<AsyncResult<JsonArray>> handler)

      Provides info about Redis Cluster node state.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterInfoObservable

          @Deprecated
          public rx.Observable<JsonArray> clusterInfoObservable()

      Deprecated. use `rxClusterInfo()` instead
      Provides info about Redis Cluster node state.
      Returns:

    - #### rxClusterInfo

          public rx.Single<JsonArray> rxClusterInfo()

      Provides info about Redis Cluster node state.
      Returns:

    - #### clusterKeyslot

          public RedisClient clusterKeyslot(String key,
                                            Handler<AsyncResult<Long>> handler)

      Returns the hash slot of the specified key.
      Parameters:
        `key` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterKeyslotObservable

          @Deprecated
          public rx.Observable<Long> clusterKeyslotObservable(String key)

      Deprecated. use `rxClusterKeyslot(java.lang.String)` instead
      Returns the hash slot of the specified key.
      Parameters:
        `key` -
      Returns:

    - #### rxClusterKeyslot

          public rx.Single<Long> rxClusterKeyslot(String key)

      Returns the hash slot of the specified key.
      Parameters:
        `key` -
      Returns:

    - #### clusterMeet

          public RedisClient clusterMeet(String ip,
                                         long port,
                                         Handler<AsyncResult<Void>> handler)

      Force a node cluster to handshake with another node.
      Parameters:
        `ip` -
        `port` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterMeetObservable

          @Deprecated
          public rx.Observable<Void> clusterMeetObservable(String ip,
                                                                       long port)

      Deprecated. use `rxClusterMeet(java.lang.String, long)` instead
      Force a node cluster to handshake with another node.
      Parameters:
        `ip` -
        `port` -
      Returns:

    - #### rxClusterMeet

          public rx.Single<Void> rxClusterMeet(String ip,
                                               long port)

      Force a node cluster to handshake with another node.
      Parameters:
        `ip` -
        `port` -
      Returns:

    - #### clusterNodes

          public RedisClient clusterNodes(Handler<AsyncResult<JsonArray>> handler)

      Get Cluster config for the node.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterNodesObservable

          @Deprecated
          public rx.Observable<JsonArray> clusterNodesObservable()

      Deprecated. use `rxClusterNodes()` instead
      Get Cluster config for the node.
      Returns:

    - #### rxClusterNodes

          public rx.Single<JsonArray> rxClusterNodes()

      Get Cluster config for the node.
      Returns:

    - #### clusterReplicate

          public RedisClient clusterReplicate(String nodeId,
                                              Handler<AsyncResult<Void>> handler)

      Reconfigure a node as a slave of the specified master node.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterReplicateObservable

          @Deprecated
          public rx.Observable<Void> clusterReplicateObservable(String nodeId)

      Deprecated. use `rxClusterReplicate(java.lang.String)` instead
      Reconfigure a node as a slave of the specified master node.
      Parameters:
        `nodeId` -
      Returns:

    - #### rxClusterReplicate

          public rx.Single<Void> rxClusterReplicate(String nodeId)

      Reconfigure a node as a slave of the specified master node.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterReset

          public RedisClient clusterReset(Handler<AsyncResult<Void>> handler)

      Reset a Redis Cluster node.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterResetObservable

          @Deprecated
          public rx.Observable<Void> clusterResetObservable()

      Deprecated. use `rxClusterReset()` instead
      Reset a Redis Cluster node.
      Returns:

    - #### rxClusterReset

          public rx.Single<Void> rxClusterReset()

      Reset a Redis Cluster node.
      Returns:

    - #### clusterResetWithOptions

          public RedisClient clusterResetWithOptions(ResetOptions options,
                                                     Handler<AsyncResult<Void>> handler)

      Reset a Redis Cluster node.
      Parameters:
        `options` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterResetWithOptionsObservable

          @Deprecated
          public rx.Observable<Void> clusterResetWithOptionsObservable(ResetOptions options)

      Deprecated. use `rxClusterResetWithOptions(io.vertx.redis.op.ResetOptions)` instead
      Reset a Redis Cluster node.
      Parameters:
        `options` -
      Returns:

    - #### rxClusterResetWithOptions

          public rx.Single<Void> rxClusterResetWithOptions(ResetOptions options)

      Reset a Redis Cluster node.
      Parameters:
        `options` -
      Returns:

    - #### clusterSaveconfig

          public RedisClient clusterSaveconfig(Handler<AsyncResult<Void>> handler)

      Forces the node to save cluster state on disk.
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSaveconfigObservable

          @Deprecated
          public rx.Observable<Void> clusterSaveconfigObservable()

      Deprecated. use `rxClusterSaveconfig()` instead
      Forces the node to save cluster state on disk.
      Returns:

    - #### rxClusterSaveconfig

          public rx.Single<Void> rxClusterSaveconfig()

      Forces the node to save cluster state on disk.
      Returns:

    - #### clusterSetConfigEpoch

          public RedisClient clusterSetConfigEpoch(long epoch,
                                                   Handler<AsyncResult<Void>> handler)

      Set the configuration epoch in a new node.
      Parameters:
        `epoch` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSetConfigEpochObservable

          @Deprecated
          public rx.Observable<Void> clusterSetConfigEpochObservable(long epoch)

      Deprecated. use `rxClusterSetConfigEpoch(long)` instead
      Set the configuration epoch in a new node.
      Parameters:
        `epoch` -
      Returns:

    - #### rxClusterSetConfigEpoch

          public rx.Single<Void> rxClusterSetConfigEpoch(long epoch)

      Set the configuration epoch in a new node.
      Parameters:
        `epoch` -
      Returns:

    - #### clusterSetslot

          public RedisClient clusterSetslot(long slot,
                                            SlotCmd subcommand,
                                            Handler<AsyncResult<Void>> handler)

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSetslotObservable

          @Deprecated
          public rx.Observable<Void> clusterSetslotObservable(long slot,
                                                                          SlotCmd subcommand)

      Deprecated. use `rxClusterSetslot(long, io.vertx.redis.op.SlotCmd)` instead
      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
      Returns:

    - #### rxClusterSetslot

          public rx.Single<Void> rxClusterSetslot(long slot,
                                                  SlotCmd subcommand)

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
      Returns:

    - #### clusterSetslotWithNode

          public RedisClient clusterSetslotWithNode(long slot,
                                                    SlotCmd subcommand,
                                                    String nodeId,
                                                    Handler<AsyncResult<Void>> handler)

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSetslotWithNodeObservable

          @Deprecated
          public rx.Observable<Void> clusterSetslotWithNodeObservable(long slot,
                                                                                  SlotCmd subcommand,
                                                                                  String nodeId)

      Deprecated. use `rxClusterSetslotWithNode(long, io.vertx.redis.op.SlotCmd, java.lang.String)` instead
      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
        `nodeId` -
      Returns:

    - #### rxClusterSetslotWithNode

          public rx.Single<Void> rxClusterSetslotWithNode(long slot,
                                                          SlotCmd subcommand,
                                                          String nodeId)

      Bind an hash slot to a specific node.
      Parameters:
        `slot` -
        `subcommand` -
        `nodeId` -
      Returns:

    - #### clusterSlaves

          public RedisClient clusterSlaves(String nodeId,
                                           Handler<AsyncResult<JsonArray>> handler)

      List slave nodes of the specified master node.
      Parameters:
        `nodeId` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### clusterSlavesObservable

          @Deprecated
          public rx.Observable<JsonArray> clusterSlavesObservable(String nodeId)

      Deprecated. use `rxClusterSlaves(java.lang.String)` instead
      List slave nodes of the specified master node.
      Parameters:
        `nodeId` -
      Returns:

    - #### rxClusterSlaves

          public rx.Single<JsonArray> rxClusterSlaves(String nodeId)

      List slave nodes of the specified master node.
      Parameters:
        `nodeId` -
      Returns:

    - #### clusterSlots

          public RedisClient clusterSlots(Handler<AsyncResult<JsonArray>> handler)

      Get array of Cluster slot to node mappings
      Parameters:
        `handler` -
      Returns:

    - #### clusterSlotsObservable

          @Deprecated
          public rx.Observable<JsonArray> clusterSlotsObservable()

      Deprecated. use `rxClusterSlots()` instead
      Get array of Cluster slot to node mappings
      Returns:

    - #### rxClusterSlots

          public rx.Single<JsonArray> rxClusterSlots()

      Get array of Cluster slot to node mappings
      Returns:

    - #### command

          public RedisClient command(Handler<AsyncResult<JsonArray>> handler)

      Get array of Redis command details
      Parameters:
        `handler` -
      Returns:

    - #### commandObservable

          @Deprecated
          public rx.Observable<JsonArray> commandObservable()

      Deprecated. use `rxCommand()` instead
      Get array of Redis command details
      Returns:

    - #### rxCommand

          public rx.Single<JsonArray> rxCommand()

      Get array of Redis command details
      Returns:

    - #### commandCount

          public RedisClient commandCount(Handler<AsyncResult<Long>> handler)

      Get total number of Redis commands
      Parameters:
        `handler` -
      Returns:

    - #### commandCountObservable

          @Deprecated
          public rx.Observable<Long> commandCountObservable()

      Deprecated. use `rxCommandCount()` instead
      Get total number of Redis commands
      Returns:

    - #### rxCommandCount

          public rx.Single<Long> rxCommandCount()

      Get total number of Redis commands
      Returns:

    - #### commandGetkeys

          public RedisClient commandGetkeys(Handler<AsyncResult<JsonArray>> handler)

      Extract keys given a full Redis command
      Parameters:
        `handler` -
      Returns:

    - #### commandGetkeysObservable

          @Deprecated
          public rx.Observable<JsonArray> commandGetkeysObservable()

      Deprecated. use `rxCommandGetkeys()` instead
      Extract keys given a full Redis command
      Returns:

    - #### rxCommandGetkeys

          public rx.Single<JsonArray> rxCommandGetkeys()

      Extract keys given a full Redis command
      Returns:

    - #### commandInfo

          public RedisClient commandInfo(List<String> commands,
                                         Handler<AsyncResult<JsonArray>> handler)

      Get array of specific Redis command details
      Parameters:
        `commands` - List of commands to get info for
        `handler` - Handler for the result of this call.
      Returns:

    - #### commandInfoObservable

          @Deprecated
          public rx.Observable<JsonArray> commandInfoObservable(List<String> commands)

      Deprecated. use `rxCommandInfo(java.util.List<java.lang.String>)` instead
      Get array of specific Redis command details
      Parameters:
        `commands` - List of commands to get info for
      Returns:

    - #### rxCommandInfo

          public rx.Single<JsonArray> rxCommandInfo(List<String> commands)

      Get array of specific Redis command details
      Parameters:
        `commands` - List of commands to get info for
      Returns:

    - #### configGet

          public RedisClient configGet(String parameter,
                                       Handler<AsyncResult<JsonArray>> handler)

      Get the value of a configuration parameter
      Parameters:
        `parameter` - Configuration parameter
        `handler` - Handler for the result of this call.
      Returns:

    - #### configGetObservable

          @Deprecated
          public rx.Observable<JsonArray> configGetObservable(String parameter)

      Deprecated. use `rxConfigGet(java.lang.String)` instead
      Get the value of a configuration parameter
      Parameters:
        `parameter` - Configuration parameter
      Returns:

    - #### rxConfigGet

          public rx.Single<JsonArray> rxConfigGet(String parameter)

      Get the value of a configuration parameter
      Parameters:
        `parameter` - Configuration parameter
      Returns:

    - #### configRewrite

          public RedisClient configRewrite(Handler<AsyncResult<String>> handler)

      Rewrite the configuration file with the in memory configuration
      Parameters:
        `handler` -
      Returns:

    - #### configRewriteObservable

          @Deprecated
          public rx.Observable<String> configRewriteObservable()

      Deprecated. use `rxConfigRewrite()` instead
      Rewrite the configuration file with the in memory configuration
      Returns:

    - #### rxConfigRewrite

          public rx.Single<String> rxConfigRewrite()

      Rewrite the configuration file with the in memory configuration
      Returns:

    - #### configSet

          public RedisClient configSet(String parameter,
                                       String value,
                                       Handler<AsyncResult<String>> handler)

      Set a configuration parameter to the given value
      Parameters:
        `parameter` - Configuration parameter
        `value` - New value
        `handler` - Handler for the result of this call.
      Returns:

    - #### configSetObservable

          @Deprecated
          public rx.Observable<String> configSetObservable(String parameter,
                                                                       String value)

      Deprecated. use `rxConfigSet(java.lang.String, java.lang.String)` instead
      Set a configuration parameter to the given value
      Parameters:
        `parameter` - Configuration parameter
        `value` - New value
      Returns:

    - #### rxConfigSet

          public rx.Single<String> rxConfigSet(String parameter,
                                               String value)

      Set a configuration parameter to the given value
      Parameters:
        `parameter` - Configuration parameter
        `value` - New value
      Returns:

    - #### configResetstat

          public RedisClient configResetstat(Handler<AsyncResult<String>> handler)

      Reset the stats returned by INFO
      Parameters:
        `handler` -
      Returns:

    - #### configResetstatObservable

          @Deprecated
          public rx.Observable<String> configResetstatObservable()

      Deprecated. use `rxConfigResetstat()` instead
      Reset the stats returned by INFO
      Returns:

    - #### rxConfigResetstat

          public rx.Single<String> rxConfigResetstat()

      Reset the stats returned by INFO
      Returns:

    - #### dbsize

          public RedisClient dbsize(Handler<AsyncResult<Long>> handler)

      Return the number of keys in the selected database
      Parameters:
        `handler` -
      Returns:

    - #### dbsizeObservable

          @Deprecated
          public rx.Observable<Long> dbsizeObservable()

      Deprecated. use `rxDbsize()` instead
      Return the number of keys in the selected database
      Returns:

    - #### rxDbsize

          public rx.Single<Long> rxDbsize()

      Return the number of keys in the selected database
      Returns:

    - #### debugObject

          public RedisClient debugObject(String key,
                                         Handler<AsyncResult<String>> handler)

      Get debugging information about a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### debugObjectObservable

          @Deprecated
          public rx.Observable<String> debugObjectObservable(String key)

      Deprecated. use `rxDebugObject(java.lang.String)` instead
      Get debugging information about a key
      Parameters:
        `key` - Key string
      Returns:

    - #### rxDebugObject

          public rx.Single<String> rxDebugObject(String key)

      Get debugging information about a key
      Parameters:
        `key` - Key string
      Returns:

    - #### debugSegfault

          public RedisClient debugSegfault(Handler<AsyncResult<String>> handler)

      Make the server crash
      Parameters:
        `handler` -
      Returns:

    - #### debugSegfaultObservable

          @Deprecated
          public rx.Observable<String> debugSegfaultObservable()

      Deprecated. use `rxDebugSegfault()` instead
      Make the server crash
      Returns:

    - #### rxDebugSegfault

          public rx.Single<String> rxDebugSegfault()

      Make the server crash
      Returns:

    - #### decr

          public RedisClient decr(String key,
                                  Handler<AsyncResult<Long>> handler)

      Decrement the integer value of a key by one
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### decrObservable

          @Deprecated
          public rx.Observable<Long> decrObservable(String key)

      Deprecated. use `rxDecr(java.lang.String)` instead
      Decrement the integer value of a key by one
      Parameters:
        `key` - Key string
      Returns:

    - #### rxDecr

          public rx.Single<Long> rxDecr(String key)

      Decrement the integer value of a key by one
      Parameters:
        `key` - Key string
      Returns:

    - #### decrby

          public RedisClient decrby(String key,
                                    long decrement,
                                    Handler<AsyncResult<Long>> handler)

      Decrement the integer value of a key by the given number
      Parameters:
        `key` - Key string
        `decrement` - Value by which to decrement
        `handler` - Handler for the result of this call.
      Returns:

    - #### decrbyObservable

          @Deprecated
          public rx.Observable<Long> decrbyObservable(String key,
                                                                  long decrement)

      Deprecated. use `rxDecrby(java.lang.String, long)` instead
      Decrement the integer value of a key by the given number
      Parameters:
        `key` - Key string
        `decrement` - Value by which to decrement
      Returns:

    - #### rxDecrby

          public rx.Single<Long> rxDecrby(String key,
                                          long decrement)

      Decrement the integer value of a key by the given number
      Parameters:
        `key` - Key string
        `decrement` - Value by which to decrement
      Returns:

    - #### del

          public RedisClient del(String key,
                                 Handler<AsyncResult<Long>> handler)

      Delete a key
      Parameters:
        `key` - Keys to delete
        `handler` - Handler for the result of this call.
      Returns:

    - #### delObservable

          @Deprecated
          public rx.Observable<Long> delObservable(String key)

      Deprecated. use `rxDel(java.lang.String)` instead
      Delete a key
      Parameters:
        `key` - Keys to delete
      Returns:

    - #### rxDel

          public rx.Single<Long> rxDel(String key)

      Delete a key
      Parameters:
        `key` - Keys to delete
      Returns:

    - #### delMany

          public RedisClient delMany(List<String> keys,
                                     Handler<AsyncResult<Long>> handler)

      Delete many keys
      Parameters:
        `keys` - List of keys to delete
        `handler` - Handler for the result of this call.
      Returns:

    - #### delManyObservable

          @Deprecated
          public rx.Observable<Long> delManyObservable(List<String> keys)

      Deprecated. use `rxDelMany(java.util.List<java.lang.String>)` instead
      Delete many keys
      Parameters:
        `keys` - List of keys to delete
      Returns:

    - #### rxDelMany

          public rx.Single<Long> rxDelMany(List<String> keys)

      Delete many keys
      Parameters:
        `keys` - List of keys to delete
      Returns:

    - #### dump

          public RedisClient dump(String key,
                                  Handler<AsyncResult<String>> handler)

      Return a serialized version of the value stored at the specified key.
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### dumpObservable

          @Deprecated
          public rx.Observable<String> dumpObservable(String key)

      Deprecated. use `rxDump(java.lang.String)` instead
      Return a serialized version of the value stored at the specified key.
      Parameters:
        `key` - Key string
      Returns:

    - #### rxDump

          public rx.Single<String> rxDump(String key)

      Return a serialized version of the value stored at the specified key.
      Parameters:
        `key` - Key string
      Returns:

    - #### echo

          public RedisClient echo(String message,
                                  Handler<AsyncResult<String>> handler)

      Echo the given string
      Parameters:
        `message` - String to echo
        `handler` - Handler for the result of this call.
      Returns:

    - #### echoObservable

          @Deprecated
          public rx.Observable<String> echoObservable(String message)

      Deprecated. use `rxEcho(java.lang.String)` instead
      Echo the given string
      Parameters:
        `message` - String to echo
      Returns:

    - #### rxEcho

          public rx.Single<String> rxEcho(String message)

      Echo the given string
      Parameters:
        `message` - String to echo
      Returns:

    - #### eval

          public RedisClient eval(String script,
                                  List<String> keys,
                                  List<String> args,
                                  Handler<AsyncResult<JsonArray>> handler)

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.
      Parameters:
        `script` - Lua script to evaluate
        `keys` - List of keys
        `args` - List of argument values
        `handler` - Handler for the result of this call.
      Returns:

    - #### evalObservable

          @Deprecated
          public rx.Observable<JsonArray> evalObservable(String script,
                                                                     List<String> keys,
                                                                     List<String> args)

      Deprecated. use `rxEval(java.lang.String, java.util.List<java.lang.String>, java.util.List<java.lang.String>)` instead
      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.
      Parameters:
        `script` - Lua script to evaluate
        `keys` - List of keys
        `args` - List of argument values
      Returns:

    - #### rxEval

          public rx.Single<JsonArray> rxEval(String script,
                                             List<String> keys,
                                             List<String> args)

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.
      Parameters:
        `script` - Lua script to evaluate
        `keys` - List of keys
        `args` - List of argument values
      Returns:

    - #### evalsha

          public RedisClient evalsha(String sha1,
                                     List<String> keys,
                                     List<String> values,
                                     Handler<AsyncResult<JsonArray>> handler)

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.
      Parameters:
        `sha1` - SHA1 digest of the script cached on the server
        `keys` - List of keys
        `values` - List of values
        `handler` - Handler for the result of this call.
      Returns:

    - #### evalshaObservable

          @Deprecated
          public rx.Observable<JsonArray> evalshaObservable(String sha1,
                                                                        List<String> keys,
                                                                        List<String> values)

      Deprecated. use `rxEvalsha(java.lang.String, java.util.List<java.lang.String>, java.util.List<java.lang.String>)` instead
      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.
      Parameters:
        `sha1` - SHA1 digest of the script cached on the server
        `keys` - List of keys
        `values` - List of values
      Returns:

    - #### rxEvalsha

          public rx.Single<JsonArray> rxEvalsha(String sha1,
                                                List<String> keys,
                                                List<String> values)

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray. When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.
      Parameters:
        `sha1` - SHA1 digest of the script cached on the server
        `keys` - List of keys
        `values` - List of values
      Returns:

    - #### exists

          public RedisClient exists(String key,
                                    Handler<AsyncResult<Long>> handler)

      Determine if a key exists
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### existsObservable

          @Deprecated
          public rx.Observable<Long> existsObservable(String key)

      Deprecated. use `rxExists(java.lang.String)` instead
      Determine if a key exists
      Parameters:
        `key` - Key string
      Returns:

    - #### rxExists

          public rx.Single<Long> rxExists(String key)

      Determine if a key exists
      Parameters:
        `key` - Key string
      Returns:

    - #### expire

          public RedisClient expire(String key,
                                    long seconds,
                                    Handler<AsyncResult<Long>> handler)

      Set a key's time to live in seconds
      Parameters:
        `key` - Key string
        `seconds` - Time to live in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### expireObservable

          @Deprecated
          public rx.Observable<Long> expireObservable(String key,
                                                                  long seconds)

      Deprecated. use `rxExpire(java.lang.String, long)` instead
      Set a key's time to live in seconds
      Parameters:
        `key` - Key string
        `seconds` - Time to live in seconds
      Returns:

    - #### rxExpire

          public rx.Single<Long> rxExpire(String key,
                                          long seconds)

      Set a key's time to live in seconds
      Parameters:
        `key` - Key string
        `seconds` - Time to live in seconds
      Returns:

    - #### expireat

          public RedisClient expireat(String key,
                                      long seconds,
                                      Handler<AsyncResult<Long>> handler)

      Set the expiration for a key as a UNIX timestamp
      Parameters:
        `key` - Key string
        `seconds` - Expiry time as Unix timestamp in seconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### expireatObservable

          @Deprecated
          public rx.Observable<Long> expireatObservable(String key,
                                                                    long seconds)

      Deprecated. use `rxExpireat(java.lang.String, long)` instead
      Set the expiration for a key as a UNIX timestamp
      Parameters:
        `key` - Key string
        `seconds` - Expiry time as Unix timestamp in seconds
      Returns:

    - #### rxExpireat

          public rx.Single<Long> rxExpireat(String key,
                                            long seconds)

      Set the expiration for a key as a UNIX timestamp
      Parameters:
        `key` - Key string
        `seconds` - Expiry time as Unix timestamp in seconds
      Returns:

    - #### flushall

          public RedisClient flushall(Handler<AsyncResult<String>> handler)

      Remove all keys from all databases
      Parameters:
        `handler` -
      Returns:

    - #### flushallObservable

          @Deprecated
          public rx.Observable<String> flushallObservable()

      Deprecated. use `rxFlushall()` instead
      Remove all keys from all databases
      Returns:

    - #### rxFlushall

          public rx.Single<String> rxFlushall()

      Remove all keys from all databases
      Returns:

    - #### flushdb

          public RedisClient flushdb(Handler<AsyncResult<String>> handler)

      Remove all keys from the current database
      Parameters:
        `handler` -
      Returns:

    - #### flushdbObservable

          @Deprecated
          public rx.Observable<String> flushdbObservable()

      Deprecated. use `rxFlushdb()` instead
      Remove all keys from the current database
      Returns:

    - #### rxFlushdb

          public rx.Single<String> rxFlushdb()

      Remove all keys from the current database
      Returns:

    - #### get

          public RedisClient get(String key,
                                 Handler<AsyncResult<String>> handler)

      Get the value of a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### getObservable

          @Deprecated
          public rx.Observable<String> getObservable(String key)

      Deprecated. use `rxGet(java.lang.String)` instead
      Get the value of a key
      Parameters:
        `key` - Key string
      Returns:

    - #### rxGet

          public rx.Single<String> rxGet(String key)

      Get the value of a key
      Parameters:
        `key` - Key string
      Returns:

    - #### getBinary

          public RedisClient getBinary(String key,
                                       Handler<AsyncResult<Buffer>> handler)

      Get the value of a key - without decoding as utf-8
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### getBinaryObservable

          @Deprecated
          public rx.Observable<Buffer> getBinaryObservable(String key)

      Deprecated. use `rxGetBinary(java.lang.String)` instead
      Get the value of a key - without decoding as utf-8
      Parameters:
        `key` - Key string
      Returns:

    - #### rxGetBinary

          public rx.Single<Buffer> rxGetBinary(String key)

      Get the value of a key - without decoding as utf-8
      Parameters:
        `key` - Key string
      Returns:

    - #### getbit

          public RedisClient getbit(String key,
                                    long offset,
                                    Handler<AsyncResult<Long>> handler)

      Returns the bit value at offset in the string value stored at key
      Parameters:
        `key` - Key string
        `offset` - Offset in bits
        `handler` - Handler for the result of this call.
      Returns:

    - #### getbitObservable

          @Deprecated
          public rx.Observable<Long> getbitObservable(String key,
                                                                  long offset)

      Deprecated. use `rxGetbit(java.lang.String, long)` instead
      Returns the bit value at offset in the string value stored at key
      Parameters:
        `key` - Key string
        `offset` - Offset in bits
      Returns:

    - #### rxGetbit

          public rx.Single<Long> rxGetbit(String key,
                                          long offset)

      Returns the bit value at offset in the string value stored at key
      Parameters:
        `key` - Key string
        `offset` - Offset in bits
      Returns:

    - #### getrange

          public RedisClient getrange(String key,
                                      long start,
                                      long end,
                                      Handler<AsyncResult<String>> handler)

      Get a substring of the string stored at a key
      Parameters:
        `key` - Key string
        `start` - Start offset
        `end` - End offset - inclusive
        `handler` - Handler for the result of this call.
      Returns:

    - #### getrangeObservable

          @Deprecated
          public rx.Observable<String> getrangeObservable(String key,
                                                                      long start,
                                                                      long end)

      Deprecated. use `rxGetrange(java.lang.String, long, long)` instead
      Get a substring of the string stored at a key
      Parameters:
        `key` - Key string
        `start` - Start offset
        `end` - End offset - inclusive
      Returns:

    - #### rxGetrange

          public rx.Single<String> rxGetrange(String key,
                                              long start,
                                              long end)

      Get a substring of the string stored at a key
      Parameters:
        `key` - Key string
        `start` - Start offset
        `end` - End offset - inclusive
      Returns:

    - #### getset

          public RedisClient getset(String key,
                                    String value,
                                    Handler<AsyncResult<String>> handler)

      Set the string value of a key and return its old value
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `handler` - Handler for the result of this call.
      Returns:

    - #### getsetObservable

          @Deprecated
          public rx.Observable<String> getsetObservable(String key,
                                                                    String value)

      Deprecated. use `rxGetset(java.lang.String, java.lang.String)` instead
      Set the string value of a key and return its old value
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
      Returns:

    - #### rxGetset

          public rx.Single<String> rxGetset(String key,
                                            String value)

      Set the string value of a key and return its old value
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
      Returns:

    - #### hdel

          public RedisClient hdel(String key,
                                  String field,
                                  Handler<AsyncResult<Long>> handler)

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `field` - Field name
        `handler` - Handler for the result of this call.
      Returns:

    - #### hdelObservable

          @Deprecated
          public rx.Observable<Long> hdelObservable(String key,
                                                                String field)

      Deprecated. use `rxHdel(java.lang.String, java.lang.String)` instead
      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `field` - Field name
      Returns:

    - #### rxHdel

          public rx.Single<Long> rxHdel(String key,
                                        String field)

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `field` - Field name
      Returns:

    - #### hdelMany

          public RedisClient hdelMany(String key,
                                      List<String> fields,
                                      Handler<AsyncResult<Long>> handler)

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
        `handler` - Handler for the result of this call.
      Returns:

    - #### hdelManyObservable

          @Deprecated
          public rx.Observable<Long> hdelManyObservable(String key,
                                                                    List<String> fields)

      Deprecated. use `rxHdelMany(java.lang.String, java.util.List<java.lang.String>)` instead
      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
      Returns:

    - #### rxHdelMany

          public rx.Single<Long> rxHdelMany(String key,
                                            List<String> fields)

      Delete one or more hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
      Returns:

    - #### hexists

          public RedisClient hexists(String key,
                                     String field,
                                     Handler<AsyncResult<Long>> handler)

      Determine if a hash field exists
      Parameters:
        `key` - Key string
        `field` - Field name
        `handler` - Handler for the result of this call.
      Returns:

    - #### hexistsObservable

          @Deprecated
          public rx.Observable<Long> hexistsObservable(String key,
                                                                   String field)

      Deprecated. use `rxHexists(java.lang.String, java.lang.String)` instead
      Determine if a hash field exists
      Parameters:
        `key` - Key string
        `field` - Field name
      Returns:

    - #### rxHexists

          public rx.Single<Long> rxHexists(String key,
                                           String field)

      Determine if a hash field exists
      Parameters:
        `key` - Key string
        `field` - Field name
      Returns:

    - #### hget

          public RedisClient hget(String key,
                                  String field,
                                  Handler<AsyncResult<String>> handler)

      Get the value of a hash field
      Parameters:
        `key` - Key string
        `field` - Field name
        `handler` - Handler for the result of this call.
      Returns:

    - #### hgetObservable

          @Deprecated
          public rx.Observable<String> hgetObservable(String key,
                                                                  String field)

      Deprecated. use `rxHget(java.lang.String, java.lang.String)` instead
      Get the value of a hash field
      Parameters:
        `key` - Key string
        `field` - Field name
      Returns:

    - #### rxHget

          public rx.Single<String> rxHget(String key,
                                          String field)

      Get the value of a hash field
      Parameters:
        `key` - Key string
        `field` - Field name
      Returns:

    - #### hgetall

          public RedisClient hgetall(String key,
                                     Handler<AsyncResult<JsonObject>> handler)

      Get all the fields and values in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### hgetallObservable

          @Deprecated
          public rx.Observable<JsonObject> hgetallObservable(String key)

      Deprecated. use `rxHgetall(java.lang.String)` instead
      Get all the fields and values in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### rxHgetall

          public rx.Single<JsonObject> rxHgetall(String key)

      Get all the fields and values in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### hincrby

          public RedisClient hincrby(String key,
                                     String field,
                                     long increment,
                                     Handler<AsyncResult<Long>> handler)

      Increment the integer value of a hash field by the given number
      Parameters:
        `key` - Key string
        `field` - Field name
        `increment` - Value by which to increment
        `handler` - Handler for the result of this call.
      Returns:

    - #### hincrbyObservable

          @Deprecated
          public rx.Observable<Long> hincrbyObservable(String key,
                                                                   String field,
                                                                   long increment)

      Deprecated. use `rxHincrby(java.lang.String, java.lang.String, long)` instead
      Increment the integer value of a hash field by the given number
      Parameters:
        `key` - Key string
        `field` - Field name
        `increment` - Value by which to increment
      Returns:

    - #### rxHincrby

          public rx.Single<Long> rxHincrby(String key,
                                           String field,
                                           long increment)

      Increment the integer value of a hash field by the given number
      Parameters:
        `key` - Key string
        `field` - Field name
        `increment` - Value by which to increment
      Returns:

    - #### hincrbyfloat

          public RedisClient hincrbyfloat(String key,
                                          String field,
                                          double increment,
                                          Handler<AsyncResult<String>> handler)

      Increment the float value of a hash field by the given amount
      Parameters:
        `key` - Key string
        `field` - Field name
        `increment` - Value by which to increment
        `handler` - Handler for the result of this call.
      Returns:

    - #### hincrbyfloatObservable

          @Deprecated
          public rx.Observable<String> hincrbyfloatObservable(String key,
                                                                          String field,
                                                                          double increment)

      Deprecated. use `rxHincrbyfloat(java.lang.String, java.lang.String, double)` instead
      Increment the float value of a hash field by the given amount
      Parameters:
        `key` - Key string
        `field` - Field name
        `increment` - Value by which to increment
      Returns:

    - #### rxHincrbyfloat

          public rx.Single<String> rxHincrbyfloat(String key,
                                                  String field,
                                                  double increment)

      Increment the float value of a hash field by the given amount
      Parameters:
        `key` - Key string
        `field` - Field name
        `increment` - Value by which to increment
      Returns:

    - #### hkeys

          public RedisClient hkeys(String key,
                                   Handler<AsyncResult<JsonArray>> handler)

      Get all the fields in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### hkeysObservable

          @Deprecated
          public rx.Observable<JsonArray> hkeysObservable(String key)

      Deprecated. use `rxHkeys(java.lang.String)` instead
      Get all the fields in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### rxHkeys

          public rx.Single<JsonArray> rxHkeys(String key)

      Get all the fields in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### hlen

          public RedisClient hlen(String key,
                                  Handler<AsyncResult<Long>> handler)

      Get the number of fields in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### hlenObservable

          @Deprecated
          public rx.Observable<Long> hlenObservable(String key)

      Deprecated. use `rxHlen(java.lang.String)` instead
      Get the number of fields in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### rxHlen

          public rx.Single<Long> rxHlen(String key)

      Get the number of fields in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### hmget

          public RedisClient hmget(String key,
                                   List<String> fields,
                                   Handler<AsyncResult<JsonArray>> handler)

      Get the values of all the given hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
        `handler` - Handler for the result of this call.
      Returns:

    - #### hmgetObservable

          @Deprecated
          public rx.Observable<JsonArray> hmgetObservable(String key,
                                                                      List<String> fields)

      Deprecated. use `rxHmget(java.lang.String, java.util.List<java.lang.String>)` instead
      Get the values of all the given hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
      Returns:

    - #### rxHmget

          public rx.Single<JsonArray> rxHmget(String key,
                                              List<String> fields)

      Get the values of all the given hash fields
      Parameters:
        `key` - Key string
        `fields` - Field names
      Returns:

    - #### hmset

          public RedisClient hmset(String key,
                                   JsonObject values,
                                   Handler<AsyncResult<String>> handler)

      Set multiple hash fields to multiple values
      Parameters:
        `key` - Key string
        `values` - Map of field:value pairs
        `handler` - Handler for the result of this call.
      Returns:

    - #### hmsetObservable

          @Deprecated
          public rx.Observable<String> hmsetObservable(String key,
                                                                   JsonObject values)

      Deprecated. use `rxHmset(java.lang.String, io.vertx.core.json.JsonObject)` instead
      Set multiple hash fields to multiple values
      Parameters:
        `key` - Key string
        `values` - Map of field:value pairs
      Returns:

    - #### rxHmset

          public rx.Single<String> rxHmset(String key,
                                           JsonObject values)

      Set multiple hash fields to multiple values
      Parameters:
        `key` - Key string
        `values` - Map of field:value pairs
      Returns:

    - #### hset

          public RedisClient hset(String key,
                                  String field,
                                  String value,
                                  Handler<AsyncResult<Long>> handler)

      Set the string value of a hash field
      Parameters:
        `key` - Key string
        `field` - Field name
        `value` - New value
        `handler` - Handler for the result of this call.
      Returns:

    - #### hsetObservable

          @Deprecated
          public rx.Observable<Long> hsetObservable(String key,
                                                                String field,
                                                                String value)

      Deprecated. use `rxHset(java.lang.String, java.lang.String, java.lang.String)` instead
      Set the string value of a hash field
      Parameters:
        `key` - Key string
        `field` - Field name
        `value` - New value
      Returns:

    - #### rxHset

          public rx.Single<Long> rxHset(String key,
                                        String field,
                                        String value)

      Set the string value of a hash field
      Parameters:
        `key` - Key string
        `field` - Field name
        `value` - New value
      Returns:

    - #### hsetnx

          public RedisClient hsetnx(String key,
                                    String field,
                                    String value,
                                    Handler<AsyncResult<Long>> handler)

      Set the value of a hash field, only if the field does not exist
      Parameters:
        `key` - Key string
        `field` - Field name
        `value` - New value
        `handler` - Handler for the result of this call.
      Returns:

    - #### hsetnxObservable

          @Deprecated
          public rx.Observable<Long> hsetnxObservable(String key,
                                                                  String field,
                                                                  String value)

      Deprecated. use `rxHsetnx(java.lang.String, java.lang.String, java.lang.String)` instead
      Set the value of a hash field, only if the field does not exist
      Parameters:
        `key` - Key string
        `field` - Field name
        `value` - New value
      Returns:

    - #### rxHsetnx

          public rx.Single<Long> rxHsetnx(String key,
                                          String field,
                                          String value)

      Set the value of a hash field, only if the field does not exist
      Parameters:
        `key` - Key string
        `field` - Field name
        `value` - New value
      Returns:

    - #### hvals

          public RedisClient hvals(String key,
                                   Handler<AsyncResult<JsonArray>> handler)

      Get all the values in a hash
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### hvalsObservable

          @Deprecated
          public rx.Observable<JsonArray> hvalsObservable(String key)

      Deprecated. use `rxHvals(java.lang.String)` instead
      Get all the values in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### rxHvals

          public rx.Single<JsonArray> rxHvals(String key)

      Get all the values in a hash
      Parameters:
        `key` - Key string
      Returns:

    - #### incr

          public RedisClient incr(String key,
                                  Handler<AsyncResult<Long>> handler)

      Increment the integer value of a key by one
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### incrObservable

          @Deprecated
          public rx.Observable<Long> incrObservable(String key)

      Deprecated. use `rxIncr(java.lang.String)` instead
      Increment the integer value of a key by one
      Parameters:
        `key` - Key string
      Returns:

    - #### rxIncr

          public rx.Single<Long> rxIncr(String key)

      Increment the integer value of a key by one
      Parameters:
        `key` - Key string
      Returns:

    - #### incrby

          public RedisClient incrby(String key,
                                    long increment,
                                    Handler<AsyncResult<Long>> handler)

      Increment the integer value of a key by the given amount
      Parameters:
        `key` - Key string
        `increment` - Value by which to increment
        `handler` - Handler for the result of this call.
      Returns:

    - #### incrbyObservable

          @Deprecated
          public rx.Observable<Long> incrbyObservable(String key,
                                                                  long increment)

      Deprecated. use `rxIncrby(java.lang.String, long)` instead
      Increment the integer value of a key by the given amount
      Parameters:
        `key` - Key string
        `increment` - Value by which to increment
      Returns:

    - #### rxIncrby

          public rx.Single<Long> rxIncrby(String key,
                                          long increment)

      Increment the integer value of a key by the given amount
      Parameters:
        `key` - Key string
        `increment` - Value by which to increment
      Returns:

    - #### incrbyfloat

          public RedisClient incrbyfloat(String key,
                                         double increment,
                                         Handler<AsyncResult<String>> handler)

      Increment the float value of a key by the given amount
      Parameters:
        `key` - Key string
        `increment` - Value by which to increment
        `handler` - Handler for the result of this call.
      Returns:

    - #### incrbyfloatObservable

          @Deprecated
          public rx.Observable<String> incrbyfloatObservable(String key,
                                                                         double increment)

      Deprecated. use `rxIncrbyfloat(java.lang.String, double)` instead
      Increment the float value of a key by the given amount
      Parameters:
        `key` - Key string
        `increment` - Value by which to increment
      Returns:

    - #### rxIncrbyfloat

          public rx.Single<String> rxIncrbyfloat(String key,
                                                 double increment)

      Increment the float value of a key by the given amount
      Parameters:
        `key` - Key string
        `increment` - Value by which to increment
      Returns:

    - #### info

          public RedisClient info(Handler<AsyncResult<JsonObject>> handler)

      Get information and statistics about the server
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### infoObservable

          @Deprecated
          public rx.Observable<JsonObject> infoObservable()

      Deprecated. use `rxInfo()` instead
      Get information and statistics about the server
      Returns:

    - #### rxInfo

          public rx.Single<JsonObject> rxInfo()

      Get information and statistics about the server
      Returns:

    - #### infoSection

          public RedisClient infoSection(String section,
                                         Handler<AsyncResult<JsonObject>> handler)

      Get information and statistics about the server
      Parameters:
        `section` - Specific section of information to return
        `handler` - Handler for the result of this call.
      Returns:

    - #### infoSectionObservable

          @Deprecated
          public rx.Observable<JsonObject> infoSectionObservable(String section)

      Deprecated. use `rxInfoSection(java.lang.String)` instead
      Get information and statistics about the server
      Parameters:
        `section` - Specific section of information to return
      Returns:

    - #### rxInfoSection

          public rx.Single<JsonObject> rxInfoSection(String section)

      Get information and statistics about the server
      Parameters:
        `section` - Specific section of information to return
      Returns:

    - #### keys

          public RedisClient keys(String pattern,
                                  Handler<AsyncResult<JsonArray>> handler)

      Find all keys matching the given pattern
      Parameters:
        `pattern` - Pattern to limit the keys returned
        `handler` - Handler for the result of this call.
      Returns:

    - #### keysObservable

          @Deprecated
          public rx.Observable<JsonArray> keysObservable(String pattern)

      Deprecated. use `rxKeys(java.lang.String)` instead
      Find all keys matching the given pattern
      Parameters:
        `pattern` - Pattern to limit the keys returned
      Returns:

    - #### rxKeys

          public rx.Single<JsonArray> rxKeys(String pattern)

      Find all keys matching the given pattern
      Parameters:
        `pattern` - Pattern to limit the keys returned
      Returns:

    - #### lastsave

          public RedisClient lastsave(Handler<AsyncResult<Long>> handler)

      Get the UNIX time stamp of the last successful save to disk
      Parameters:
        `handler` -
      Returns:

    - #### lastsaveObservable

          @Deprecated
          public rx.Observable<Long> lastsaveObservable()

      Deprecated. use `rxLastsave()` instead
      Get the UNIX time stamp of the last successful save to disk
      Returns:

    - #### rxLastsave

          public rx.Single<Long> rxLastsave()

      Get the UNIX time stamp of the last successful save to disk
      Returns:

    - #### lindex

          public RedisClient lindex(String key,
                                    int index,
                                    Handler<AsyncResult<String>> handler)

      Get an element from a list by its index
      Parameters:
        `key` - Key string
        `index` - Index of list element to get
        `handler` - Handler for the result of this call.
      Returns:

    - #### lindexObservable

          @Deprecated
          public rx.Observable<String> lindexObservable(String key,
                                                                    int index)

      Deprecated. use `rxLindex(java.lang.String, int)` instead
      Get an element from a list by its index
      Parameters:
        `key` - Key string
        `index` - Index of list element to get
      Returns:

    - #### rxLindex

          public rx.Single<String> rxLindex(String key,
                                            int index)

      Get an element from a list by its index
      Parameters:
        `key` - Key string
        `index` - Index of list element to get
      Returns:

    - #### linsert

          public RedisClient linsert(String key,
                                     InsertOptions option,
                                     String pivot,
                                     String value,
                                     Handler<AsyncResult<Long>> handler)

      Insert an element before or after another element in a list
      Parameters:
        `key` - Key string
        `option` - BEFORE or AFTER
        `pivot` - Key to use as a pivot
        `value` - Value to be inserted before or after the pivot
        `handler` - Handler for the result of this call.
      Returns:

    - #### linsertObservable

          @Deprecated
          public rx.Observable<Long> linsertObservable(String key,
                                                                   InsertOptions option,
                                                                   String pivot,
                                                                   String value)

      Deprecated. use `rxLinsert(java.lang.String, io.vertx.redis.op.InsertOptions, java.lang.String, java.lang.String)` instead
      Insert an element before or after another element in a list
      Parameters:
        `key` - Key string
        `option` - BEFORE or AFTER
        `pivot` - Key to use as a pivot
        `value` - Value to be inserted before or after the pivot
      Returns:

    - #### rxLinsert

          public rx.Single<Long> rxLinsert(String key,
                                           InsertOptions option,
                                           String pivot,
                                           String value)

      Insert an element before or after another element in a list
      Parameters:
        `key` - Key string
        `option` - BEFORE or AFTER
        `pivot` - Key to use as a pivot
        `value` - Value to be inserted before or after the pivot
      Returns:

    - #### llen

          public RedisClient llen(String key,
                                  Handler<AsyncResult<Long>> handler)

      Get the length of a list
      Parameters:
        `key` - String key
        `handler` - Handler for the result of this call.
      Returns:

    - #### llenObservable

          @Deprecated
          public rx.Observable<Long> llenObservable(String key)

      Deprecated. use `rxLlen(java.lang.String)` instead
      Get the length of a list
      Parameters:
        `key` - String key
      Returns:

    - #### rxLlen

          public rx.Single<Long> rxLlen(String key)

      Get the length of a list
      Parameters:
        `key` - String key
      Returns:

    - #### lpop

          public RedisClient lpop(String key,
                                  Handler<AsyncResult<String>> handler)

      Remove and get the first element in a list
      Parameters:
        `key` - String key
        `handler` - Handler for the result of this call.
      Returns:

    - #### lpopObservable

          @Deprecated
          public rx.Observable<String> lpopObservable(String key)

      Deprecated. use `rxLpop(java.lang.String)` instead
      Remove and get the first element in a list
      Parameters:
        `key` - String key
      Returns:

    - #### rxLpop

          public rx.Single<String> rxLpop(String key)

      Remove and get the first element in a list
      Parameters:
        `key` - String key
      Returns:

    - #### lpushMany

          public RedisClient lpushMany(String key,
                                       List<String> values,
                                       Handler<AsyncResult<Long>> handler)

      Prepend one or multiple values to a list
      Parameters:
        `key` - Key string
        `values` - Values to be added at the beginning of the list, one by one
        `handler` - Handler for the result of this call.
      Returns:

    - #### lpushManyObservable

          @Deprecated
          public rx.Observable<Long> lpushManyObservable(String key,
                                                                     List<String> values)

      Deprecated. use `rxLpushMany(java.lang.String, java.util.List<java.lang.String>)` instead
      Prepend one or multiple values to a list
      Parameters:
        `key` - Key string
        `values` - Values to be added at the beginning of the list, one by one
      Returns:

    - #### rxLpushMany

          public rx.Single<Long> rxLpushMany(String key,
                                             List<String> values)

      Prepend one or multiple values to a list
      Parameters:
        `key` - Key string
        `values` - Values to be added at the beginning of the list, one by one
      Returns:

    - #### lpush

          public RedisClient lpush(String key,
                                   String value,
                                   Handler<AsyncResult<Long>> handler)

      Prepend one value to a list
      Parameters:
        `key` - Key string
        `value` - Value to be added at the beginning of the list
        `handler` - Handler for the result of this call.
      Returns:

    - #### lpushObservable

          @Deprecated
          public rx.Observable<Long> lpushObservable(String key,
                                                                 String value)

      Deprecated. use `rxLpush(java.lang.String, java.lang.String)` instead
      Prepend one value to a list
      Parameters:
        `key` - Key string
        `value` - Value to be added at the beginning of the list
      Returns:

    - #### rxLpush

          public rx.Single<Long> rxLpush(String key,
                                         String value)

      Prepend one value to a list
      Parameters:
        `key` - Key string
        `value` - Value to be added at the beginning of the list
      Returns:

    - #### lpushx

          public RedisClient lpushx(String key,
                                    String value,
                                    Handler<AsyncResult<Long>> handler)

      Prepend a value to a list, only if the list exists
      Parameters:
        `key` - Key string
        `value` - Value to add at the beginning of the list
        `handler` - Handler for the result of this call.
      Returns:

    - #### lpushxObservable

          @Deprecated
          public rx.Observable<Long> lpushxObservable(String key,
                                                                  String value)

      Deprecated. use `rxLpushx(java.lang.String, java.lang.String)` instead
      Prepend a value to a list, only if the list exists
      Parameters:
        `key` - Key string
        `value` - Value to add at the beginning of the list
      Returns:

    - #### rxLpushx

          public rx.Single<Long> rxLpushx(String key,
                                          String value)

      Prepend a value to a list, only if the list exists
      Parameters:
        `key` - Key string
        `value` - Value to add at the beginning of the list
      Returns:

    - #### lrange

          public RedisClient lrange(String key,
                                    long from,
                                    long to,
                                    Handler<AsyncResult<JsonArray>> handler)

      Get a range of elements from a list
      Parameters:
        `key` - Key string
        `from` - Start index
        `to` - Stop index
        `handler` - Handler for the result of this call.
      Returns:

    - #### lrangeObservable

          @Deprecated
          public rx.Observable<JsonArray> lrangeObservable(String key,
                                                                       long from,
                                                                       long to)

      Deprecated. use `rxLrange(java.lang.String, long, long)` instead
      Get a range of elements from a list
      Parameters:
        `key` - Key string
        `from` - Start index
        `to` - Stop index
      Returns:

    - #### rxLrange

          public rx.Single<JsonArray> rxLrange(String key,
                                               long from,
                                               long to)

      Get a range of elements from a list
      Parameters:
        `key` - Key string
        `from` - Start index
        `to` - Stop index
      Returns:

    - #### lrem

          public RedisClient lrem(String key,
                                  long count,
                                  String value,
                                  Handler<AsyncResult<Long>> handler)

      Remove elements from a list
      Parameters:
        `key` - Key string
        `count` - Number of first found occurrences equal to $value to remove from the list
        `value` - Value to be removed
        `handler` - Handler for the result of this call.
      Returns:

    - #### lremObservable

          @Deprecated
          public rx.Observable<Long> lremObservable(String key,
                                                                long count,
                                                                String value)

      Deprecated. use `rxLrem(java.lang.String, long, java.lang.String)` instead
      Remove elements from a list
      Parameters:
        `key` - Key string
        `count` - Number of first found occurrences equal to $value to remove from the list
        `value` - Value to be removed
      Returns:

    - #### rxLrem

          public rx.Single<Long> rxLrem(String key,
                                        long count,
                                        String value)

      Remove elements from a list
      Parameters:
        `key` - Key string
        `count` - Number of first found occurrences equal to $value to remove from the list
        `value` - Value to be removed
      Returns:

    - #### lset

          public RedisClient lset(String key,
                                  long index,
                                  String value,
                                  Handler<AsyncResult<String>> handler)

      Set the value of an element in a list by its index
      Parameters:
        `key` - Key string
        `index` - Position within list
        `value` - New value
        `handler` - Handler for the result of this call.
      Returns:

    - #### lsetObservable

          @Deprecated
          public rx.Observable<String> lsetObservable(String key,
                                                                  long index,
                                                                  String value)

      Deprecated. use `rxLset(java.lang.String, long, java.lang.String)` instead
      Set the value of an element in a list by its index
      Parameters:
        `key` - Key string
        `index` - Position within list
        `value` - New value
      Returns:

    - #### rxLset

          public rx.Single<String> rxLset(String key,
                                          long index,
                                          String value)

      Set the value of an element in a list by its index
      Parameters:
        `key` - Key string
        `index` - Position within list
        `value` - New value
      Returns:

    - #### ltrim

          public RedisClient ltrim(String key,
                                   long from,
                                   long to,
                                   Handler<AsyncResult<String>> handler)

      Trim a list to the specified range
      Parameters:
        `key` - Key string
        `from` - Start index
        `to` - Stop index
        `handler` - Handler for the result of this call.
      Returns:

    - #### ltrimObservable

          @Deprecated
          public rx.Observable<String> ltrimObservable(String key,
                                                                   long from,
                                                                   long to)

      Deprecated. use `rxLtrim(java.lang.String, long, long)` instead
      Trim a list to the specified range
      Parameters:
        `key` - Key string
        `from` - Start index
        `to` - Stop index
      Returns:

    - #### rxLtrim

          public rx.Single<String> rxLtrim(String key,
                                           long from,
                                           long to)

      Trim a list to the specified range
      Parameters:
        `key` - Key string
        `from` - Start index
        `to` - Stop index
      Returns:

    - #### mget

          public RedisClient mget(String key,
                                  Handler<AsyncResult<JsonArray>> handler)

      Get the value of the given key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### mgetObservable

          @Deprecated
          public rx.Observable<JsonArray> mgetObservable(String key)

      Deprecated. use `rxMget(java.lang.String)` instead
      Get the value of the given key
      Parameters:
        `key` - Key string
      Returns:

    - #### rxMget

          public rx.Single<JsonArray> rxMget(String key)

      Get the value of the given key
      Parameters:
        `key` - Key string
      Returns:

    - #### mgetMany

          public RedisClient mgetMany(List<String> keys,
                                      Handler<AsyncResult<JsonArray>> handler)

      Get the values of all the given keys
      Parameters:
        `keys` - List of keys to get
        `handler` - Handler for the result of this call.
      Returns:

    - #### mgetManyObservable

          @Deprecated
          public rx.Observable<JsonArray> mgetManyObservable(List<String> keys)

      Deprecated. use `rxMgetMany(java.util.List<java.lang.String>)` instead
      Get the values of all the given keys
      Parameters:
        `keys` - List of keys to get
      Returns:

    - #### rxMgetMany

          public rx.Single<JsonArray> rxMgetMany(List<String> keys)

      Get the values of all the given keys
      Parameters:
        `keys` - List of keys to get
      Returns:

    - #### migrate

          public RedisClient migrate(String host,
                                     int port,
                                     String key,
                                     int destdb,
                                     long timeout,
                                     MigrateOptions options,
                                     Handler<AsyncResult<String>> handler)

      Atomically transfer a key from a Redis instance to another one.
      Parameters:
        `host` - Destination host
        `port` - Destination port
        `key` - Key to migrate
        `destdb` - Destination database index
        `timeout` -
        `options` - Migrate options
        `handler` - Handler for the result of this call.
      Returns:

    - #### migrateObservable

          @Deprecated
          public rx.Observable<String> migrateObservable(String host,
                                                                     int port,
                                                                     String key,
                                                                     int destdb,
                                                                     long timeout,
                                                                     MigrateOptions options)

      Deprecated. use `rxMigrate(java.lang.String, int, java.lang.String, int, long, io.vertx.redis.op.MigrateOptions)` instead
      Atomically transfer a key from a Redis instance to another one.
      Parameters:
        `host` - Destination host
        `port` - Destination port
        `key` - Key to migrate
        `destdb` - Destination database index
        `timeout` -
        `options` - Migrate options
      Returns:

    - #### rxMigrate

          public rx.Single<String> rxMigrate(String host,
                                             int port,
                                             String key,
                                             int destdb,
                                             long timeout,
                                             MigrateOptions options)

      Atomically transfer a key from a Redis instance to another one.
      Parameters:
        `host` - Destination host
        `port` - Destination port
        `key` - Key to migrate
        `destdb` - Destination database index
        `timeout` -
        `options` - Migrate options
      Returns:

    - #### monitor

          public RedisClient monitor(Handler<AsyncResult<Void>> handler)

      Listen for all requests received by the server in real time
      Parameters:
        `handler` -
      Returns:

    - #### monitorObservable

          @Deprecated
          public rx.Observable<Void> monitorObservable()

      Deprecated. use `rxMonitor()` instead
      Listen for all requests received by the server in real time
      Returns:

    - #### rxMonitor

          public rx.Single<Void> rxMonitor()

      Listen for all requests received by the server in real time
      Returns:

    - #### move

          public RedisClient move(String key,
                                  int destdb,
                                  Handler<AsyncResult<Long>> handler)

      Move a key to another database
      Parameters:
        `key` - Key to migrate
        `destdb` - Destination database index
        `handler` - Handler for the result of this call.
      Returns:

    - #### moveObservable

          @Deprecated
          public rx.Observable<Long> moveObservable(String key,
                                                                int destdb)

      Deprecated. use `rxMove(java.lang.String, int)` instead
      Move a key to another database
      Parameters:
        `key` - Key to migrate
        `destdb` - Destination database index
      Returns:

    - #### rxMove

          public rx.Single<Long> rxMove(String key,
                                        int destdb)

      Move a key to another database
      Parameters:
        `key` - Key to migrate
        `destdb` - Destination database index
      Returns:

    - #### mset

          public RedisClient mset(JsonObject keyvals,
                                  Handler<AsyncResult<String>> handler)

      Set multiple keys to multiple values
      Parameters:
        `keyvals` - Key value pairs to set
        `handler` - Handler for the result of this call.
      Returns:

    - #### msetObservable

          @Deprecated
          public rx.Observable<String> msetObservable(JsonObject keyvals)

      Deprecated. use `rxMset(io.vertx.core.json.JsonObject)` instead
      Set multiple keys to multiple values
      Parameters:
        `keyvals` - Key value pairs to set
      Returns:

    - #### rxMset

          public rx.Single<String> rxMset(JsonObject keyvals)

      Set multiple keys to multiple values
      Parameters:
        `keyvals` - Key value pairs to set
      Returns:

    - #### msetnx

          public RedisClient msetnx(JsonObject keyvals,
                                    Handler<AsyncResult<Long>> handler)

      Set multiple keys to multiple values, only if none of the keys exist
      Parameters:
        `keyvals` - Key value pairs to set
        `handler` - Handler for the result of this call.
      Returns:

    - #### msetnxObservable

          @Deprecated
          public rx.Observable<Long> msetnxObservable(JsonObject keyvals)

      Deprecated. use `rxMsetnx(io.vertx.core.json.JsonObject)` instead
      Set multiple keys to multiple values, only if none of the keys exist
      Parameters:
        `keyvals` - Key value pairs to set
      Returns:

    - #### rxMsetnx

          public rx.Single<Long> rxMsetnx(JsonObject keyvals)

      Set multiple keys to multiple values, only if none of the keys exist
      Parameters:
        `keyvals` - Key value pairs to set
      Returns:

    - #### object

          public RedisClient object(String key,
                                    ObjectCmd cmd,
                                    Handler<AsyncResult<Void>> handler)

      Inspect the internals of Redis objects
      Parameters:
        `key` - Key string
        `cmd` - Object sub command
        `handler` - Handler for the result of this call.
      Returns:

    - #### objectObservable

          @Deprecated
          public rx.Observable<Void> objectObservable(String key,
                                                                  ObjectCmd cmd)

      Deprecated. use `rxObject(java.lang.String, io.vertx.redis.op.ObjectCmd)` instead
      Inspect the internals of Redis objects
      Parameters:
        `key` - Key string
        `cmd` - Object sub command
      Returns:

    - #### rxObject

          public rx.Single<Void> rxObject(String key,
                                          ObjectCmd cmd)

      Inspect the internals of Redis objects
      Parameters:
        `key` - Key string
        `cmd` - Object sub command
      Returns:

    - #### persist

          public RedisClient persist(String key,
                                     Handler<AsyncResult<Long>> handler)

      Remove the expiration from a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### persistObservable

          @Deprecated
          public rx.Observable<Long> persistObservable(String key)

      Deprecated. use `rxPersist(java.lang.String)` instead
      Remove the expiration from a key
      Parameters:
        `key` - Key string
      Returns:

    - #### rxPersist

          public rx.Single<Long> rxPersist(String key)

      Remove the expiration from a key
      Parameters:
        `key` - Key string
      Returns:

    - #### pexpire

          public RedisClient pexpire(String key,
                                     long millis,
                                     Handler<AsyncResult<Long>> handler)

      Set a key's time to live in milliseconds
      Parameters:
        `key` - String key
        `millis` - Time to live in milliseconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### pexpireObservable

          @Deprecated
          public rx.Observable<Long> pexpireObservable(String key,
                                                                   long millis)

      Deprecated. use `rxPexpire(java.lang.String, long)` instead
      Set a key's time to live in milliseconds
      Parameters:
        `key` - String key
        `millis` - Time to live in milliseconds
      Returns:

    - #### rxPexpire

          public rx.Single<Long> rxPexpire(String key,
                                           long millis)

      Set a key's time to live in milliseconds
      Parameters:
        `key` - String key
        `millis` - Time to live in milliseconds
      Returns:

    - #### pexpireat

          public RedisClient pexpireat(String key,
                                       long millis,
                                       Handler<AsyncResult<Long>> handler)

      Set the expiration for a key as a UNIX timestamp specified in milliseconds
      Parameters:
        `key` - Key string
        `millis` - Expiry time as Unix timestamp in milliseconds
        `handler` - Handler for the result of this call.
      Returns:

    - #### pexpireatObservable

          @Deprecated
          public rx.Observable<Long> pexpireatObservable(String key,
                                                                     long millis)

      Deprecated. use `rxPexpireat(java.lang.String, long)` instead
      Set the expiration for a key as a UNIX timestamp specified in milliseconds
      Parameters:
        `key` - Key string
        `millis` - Expiry time as Unix timestamp in milliseconds
      Returns:

    - #### rxPexpireat

          public rx.Single<Long> rxPexpireat(String key,
                                             long millis)

      Set the expiration for a key as a UNIX timestamp specified in milliseconds
      Parameters:
        `key` - Key string
        `millis` - Expiry time as Unix timestamp in milliseconds
      Returns:

    - #### pfadd

          public RedisClient pfadd(String key,
                                   String element,
                                   Handler<AsyncResult<Long>> handler)

      Adds the specified element to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `element` - Element to add
        `handler` - Handler for the result of this call.
      Returns:

    - #### pfaddObservable

          @Deprecated
          public rx.Observable<Long> pfaddObservable(String key,
                                                                 String element)

      Deprecated. use `rxPfadd(java.lang.String, java.lang.String)` instead
      Adds the specified element to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `element` - Element to add
      Returns:

    - #### rxPfadd

          public rx.Single<Long> rxPfadd(String key,
                                         String element)

      Adds the specified element to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `element` - Element to add
      Returns:

    - #### pfaddMany

          public RedisClient pfaddMany(String key,
                                       List<String> elements,
                                       Handler<AsyncResult<Long>> handler)

      Adds the specified elements to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `elements` - Elementa to add
        `handler` - Handler for the result of this call.
      Returns:

    - #### pfaddManyObservable

          @Deprecated
          public rx.Observable<Long> pfaddManyObservable(String key,
                                                                     List<String> elements)

      Deprecated. use `rxPfaddMany(java.lang.String, java.util.List<java.lang.String>)` instead
      Adds the specified elements to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `elements` - Elementa to add
      Returns:

    - #### rxPfaddMany

          public rx.Single<Long> rxPfaddMany(String key,
                                             List<String> elements)

      Adds the specified elements to the specified HyperLogLog.
      Parameters:
        `key` - Key string
        `elements` - Elementa to add
      Returns:

    - #### pfcount

          public RedisClient pfcount(String key,
                                     Handler<AsyncResult<Long>> handler)

      Return the approximated cardinality of the set observed by the HyperLogLog at key.
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### pfcountObservable

          @Deprecated
          public rx.Observable<Long> pfcountObservable(String key)

      Deprecated. use `rxPfcount(java.lang.String)` instead
      Return the approximated cardinality of the set observed by the HyperLogLog at key.
      Parameters:
        `key` - Key string
      Returns:

    - #### rxPfcount

          public rx.Single<Long> rxPfcount(String key)

      Return the approximated cardinality of the set observed by the HyperLogLog at key.
      Parameters:
        `key` - Key string
      Returns:

    - #### pfcountMany

          public RedisClient pfcountMany(List<String> keys,
                                         Handler<AsyncResult<Long>> handler)

      Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
      Parameters:
        `keys` - List of keys
        `handler` - Handler for the result of this call.
      Returns:

    - #### pfcountManyObservable

          @Deprecated
          public rx.Observable<Long> pfcountManyObservable(List<String> keys)

      Deprecated. use `rxPfcountMany(java.util.List<java.lang.String>)` instead
      Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
      Parameters:
        `keys` - List of keys
      Returns:

    - #### rxPfcountMany

          public rx.Single<Long> rxPfcountMany(List<String> keys)

      Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
      Parameters:
        `keys` - List of keys
      Returns:

    - #### pfmerge

          public RedisClient pfmerge(String destkey,
                                     List<String> keys,
                                     Handler<AsyncResult<String>> handler)

      Merge N different HyperLogLogs into a single one.
      Parameters:
        `destkey` - Destination key
        `keys` - List of source keys
        `handler` - Handler for the result of this call.
      Returns:

    - #### pfmergeObservable

          @Deprecated
          public rx.Observable<String> pfmergeObservable(String destkey,
                                                                     List<String> keys)

      Deprecated. use `rxPfmerge(java.lang.String, java.util.List<java.lang.String>)` instead
      Merge N different HyperLogLogs into a single one.
      Parameters:
        `destkey` - Destination key
        `keys` - List of source keys
      Returns:

    - #### rxPfmerge

          public rx.Single<String> rxPfmerge(String destkey,
                                             List<String> keys)

      Merge N different HyperLogLogs into a single one.
      Parameters:
        `destkey` - Destination key
        `keys` - List of source keys
      Returns:

    - #### ping

          public RedisClient ping(Handler<AsyncResult<String>> handler)

      Ping the server
      Parameters:
        `handler` -
      Returns:

    - #### pingObservable

          @Deprecated
          public rx.Observable<String> pingObservable()

      Deprecated. use `rxPing()` instead
      Ping the server
      Returns:

    - #### rxPing

          public rx.Single<String> rxPing()

      Ping the server
      Returns:

    - #### psetex

          public RedisClient psetex(String key,
                                    long millis,
                                    String value,
                                    Handler<AsyncResult<Void>> handler)

      Set the value and expiration in milliseconds of a key
      Parameters:
        `key` - Key string
        `millis` - Number of milliseconds until the key expires
        `value` - New value for key
        `handler` - Handler for the result of this call.
      Returns:

    - #### psetexObservable

          @Deprecated
          public rx.Observable<Void> psetexObservable(String key,
                                                                  long millis,
                                                                  String value)

      Deprecated. use `rxPsetex(java.lang.String, long, java.lang.String)` instead
      Set the value and expiration in milliseconds of a key
      Parameters:
        `key` - Key string
        `millis` - Number of milliseconds until the key expires
        `value` - New value for key
      Returns:

    - #### rxPsetex

          public rx.Single<Void> rxPsetex(String key,
                                          long millis,
                                          String value)

      Set the value and expiration in milliseconds of a key
      Parameters:
        `key` - Key string
        `millis` - Number of milliseconds until the key expires
        `value` - New value for key
      Returns:

    - #### psubscribe

          public RedisClient psubscribe(String pattern,
                                        Handler<AsyncResult<JsonArray>> handler)

      Listen for messages published to channels matching the given pattern
      Parameters:
        `pattern` - Pattern string
        `handler` - Handler for the result of this call.
      Returns:

    - #### psubscribeObservable

          @Deprecated
          public rx.Observable<JsonArray> psubscribeObservable(String pattern)

      Deprecated. use `rxPsubscribe(java.lang.String)` instead
      Listen for messages published to channels matching the given pattern
      Parameters:
        `pattern` - Pattern string
      Returns:

    - #### rxPsubscribe

          public rx.Single<JsonArray> rxPsubscribe(String pattern)

      Listen for messages published to channels matching the given pattern
      Parameters:
        `pattern` - Pattern string
      Returns:

    - #### psubscribeMany

          public RedisClient psubscribeMany(List<String> patterns,
                                            Handler<AsyncResult<JsonArray>> handler)

      Listen for messages published to channels matching the given patterns
      Parameters:
        `patterns` - List of patterns
        `handler` - Handler for the result of this call.
      Returns:

    - #### psubscribeManyObservable

          @Deprecated
          public rx.Observable<JsonArray> psubscribeManyObservable(List<String> patterns)

      Deprecated. use `rxPsubscribeMany(java.util.List<java.lang.String>)` instead
      Listen for messages published to channels matching the given patterns
      Parameters:
        `patterns` - List of patterns
      Returns:

    - #### rxPsubscribeMany

          public rx.Single<JsonArray> rxPsubscribeMany(List<String> patterns)

      Listen for messages published to channels matching the given patterns
      Parameters:
        `patterns` - List of patterns
      Returns:

    - #### pubsubChannels

          public RedisClient pubsubChannels(String pattern,
                                            Handler<AsyncResult<JsonArray>> handler)

      Lists the currently active channels - only those matching the pattern
      Parameters:
        `pattern` - A glob-style pattern - an empty string means no pattern
        `handler` - Handler for the result of this call.
      Returns:

    - #### pubsubChannelsObservable

          @Deprecated
          public rx.Observable<JsonArray> pubsubChannelsObservable(String pattern)

      Deprecated. use `rxPubsubChannels(java.lang.String)` instead
      Lists the currently active channels - only those matching the pattern
      Parameters:
        `pattern` - A glob-style pattern - an empty string means no pattern
      Returns:

    - #### rxPubsubChannels

          public rx.Single<JsonArray> rxPubsubChannels(String pattern)

      Lists the currently active channels - only those matching the pattern
      Parameters:
        `pattern` - A glob-style pattern - an empty string means no pattern
      Returns:

    - #### pubsubNumsub

          public RedisClient pubsubNumsub(List<String> channels,
                                          Handler<AsyncResult<JsonArray>> handler)

      Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
      Parameters:
        `channels` - List of channels
        `handler` - Handler for the result of this call.
      Returns:

    - #### pubsubNumsubObservable

          @Deprecated
          public rx.Observable<JsonArray> pubsubNumsubObservable(List<String> channels)

      Deprecated. use `rxPubsubNumsub(java.util.List<java.lang.String>)` instead
      Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
      Parameters:
        `channels` - List of channels
      Returns:

    - #### rxPubsubNumsub

          public rx.Single<JsonArray> rxPubsubNumsub(List<String> channels)

      Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
      Parameters:
        `channels` - List of channels
      Returns:

    - #### pubsubNumpat

          public RedisClient pubsubNumpat(Handler<AsyncResult<Long>> handler)

      Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### pubsubNumpatObservable

          @Deprecated
          public rx.Observable<Long> pubsubNumpatObservable()

      Deprecated. use `rxPubsubNumpat()` instead
      Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
      Returns:

    - #### rxPubsubNumpat

          public rx.Single<Long> rxPubsubNumpat()

      Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
      Returns:

    - #### pttl

          public RedisClient pttl(String key,
                                  Handler<AsyncResult<Long>> handler)

      Get the time to live for a key in milliseconds
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### pttlObservable

          @Deprecated
          public rx.Observable<Long> pttlObservable(String key)

      Deprecated. use `rxPttl(java.lang.String)` instead
      Get the time to live for a key in milliseconds
      Parameters:
        `key` - Key string
      Returns:

    - #### rxPttl

          public rx.Single<Long> rxPttl(String key)

      Get the time to live for a key in milliseconds
      Parameters:
        `key` - Key string
      Returns:

    - #### publish

          public RedisClient publish(String channel,
                                     String message,
                                     Handler<AsyncResult<Long>> handler)

      Post a message to a channel
      Parameters:
        `channel` - Channel key
        `message` - Message to send to channel
        `handler` - Handler for the result of this call.
      Returns:

    - #### publishObservable

          @Deprecated
          public rx.Observable<Long> publishObservable(String channel,
                                                                   String message)

      Deprecated. use `rxPublish(java.lang.String, java.lang.String)` instead
      Post a message to a channel
      Parameters:
        `channel` - Channel key
        `message` - Message to send to channel
      Returns:

    - #### rxPublish

          public rx.Single<Long> rxPublish(String channel,
                                           String message)

      Post a message to a channel
      Parameters:
        `channel` - Channel key
        `message` - Message to send to channel
      Returns:

    - #### punsubscribe

          public RedisClient punsubscribe(List<String> patterns,
                                          Handler<AsyncResult<Void>> handler)

      Stop listening for messages posted to channels matching the given patterns
      Parameters:
        `patterns` - List of patterns to match against
        `handler` - Handler for the result of this call.
      Returns:

    - #### punsubscribeObservable

          @Deprecated
          public rx.Observable<Void> punsubscribeObservable(List<String> patterns)

      Deprecated. use `rxPunsubscribe(java.util.List<java.lang.String>)` instead
      Stop listening for messages posted to channels matching the given patterns
      Parameters:
        `patterns` - List of patterns to match against
      Returns:

    - #### rxPunsubscribe

          public rx.Single<Void> rxPunsubscribe(List<String> patterns)

      Stop listening for messages posted to channels matching the given patterns
      Parameters:
        `patterns` - List of patterns to match against
      Returns:

    - #### randomkey

          public RedisClient randomkey(Handler<AsyncResult<String>> handler)

      Return a random key from the keyspace
      Parameters:
        `handler` -
      Returns:

    - #### randomkeyObservable

          @Deprecated
          public rx.Observable<String> randomkeyObservable()

      Deprecated. use `rxRandomkey()` instead
      Return a random key from the keyspace
      Returns:

    - #### rxRandomkey

          public rx.Single<String> rxRandomkey()

      Return a random key from the keyspace
      Returns:

    - #### rename

          public RedisClient rename(String key,
                                    String newkey,
                                    Handler<AsyncResult<String>> handler)

      Rename a key
      Parameters:
        `key` - Key string to be renamed
        `newkey` - New key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### renameObservable

          @Deprecated
          public rx.Observable<String> renameObservable(String key,
                                                                    String newkey)

      Deprecated. use `rxRename(java.lang.String, java.lang.String)` instead
      Rename a key
      Parameters:
        `key` - Key string to be renamed
        `newkey` - New key string
      Returns:

    - #### rxRename

          public rx.Single<String> rxRename(String key,
                                            String newkey)

      Rename a key
      Parameters:
        `key` - Key string to be renamed
        `newkey` - New key string
      Returns:

    - #### renamenx

          public RedisClient renamenx(String key,
                                      String newkey,
                                      Handler<AsyncResult<Long>> handler)

      Rename a key, only if the new key does not exist
      Parameters:
        `key` - Key string to be renamed
        `newkey` - New key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### renamenxObservable

          @Deprecated
          public rx.Observable<Long> renamenxObservable(String key,
                                                                    String newkey)

      Deprecated. use `rxRenamenx(java.lang.String, java.lang.String)` instead
      Rename a key, only if the new key does not exist
      Parameters:
        `key` - Key string to be renamed
        `newkey` - New key string
      Returns:

    - #### rxRenamenx

          public rx.Single<Long> rxRenamenx(String key,
                                            String newkey)

      Rename a key, only if the new key does not exist
      Parameters:
        `key` - Key string to be renamed
        `newkey` - New key string
      Returns:

    - #### restore

          public RedisClient restore(String key,
                                     long millis,
                                     String serialized,
                                     Handler<AsyncResult<String>> handler)

      Create a key using the provided serialized value, previously obtained using DUMP.
      Parameters:
        `key` - Key string
        `millis` - Expiry time in milliseconds to set on the key
        `serialized` - Serialized form of the key value as obtained using DUMP
        `handler` - Handler for the result of this call.
      Returns:

    - #### restoreObservable

          @Deprecated
          public rx.Observable<String> restoreObservable(String key,
                                                                     long millis,
                                                                     String serialized)

      Deprecated. use `rxRestore(java.lang.String, long, java.lang.String)` instead
      Create a key using the provided serialized value, previously obtained using DUMP.
      Parameters:
        `key` - Key string
        `millis` - Expiry time in milliseconds to set on the key
        `serialized` - Serialized form of the key value as obtained using DUMP
      Returns:

    - #### rxRestore

          public rx.Single<String> rxRestore(String key,
                                             long millis,
                                             String serialized)

      Create a key using the provided serialized value, previously obtained using DUMP.
      Parameters:
        `key` - Key string
        `millis` - Expiry time in milliseconds to set on the key
        `serialized` - Serialized form of the key value as obtained using DUMP
      Returns:

    - #### role

          public RedisClient role(Handler<AsyncResult<JsonArray>> handler)

      Return the role of the instance in the context of replication
      Parameters:
        `handler` -
      Returns:

    - #### roleObservable

          @Deprecated
          public rx.Observable<JsonArray> roleObservable()

      Deprecated. use `rxRole()` instead
      Return the role of the instance in the context of replication
      Returns:

    - #### rxRole

          public rx.Single<JsonArray> rxRole()

      Return the role of the instance in the context of replication
      Returns:

    - #### rpop

          public RedisClient rpop(String key,
                                  Handler<AsyncResult<String>> handler)

      Remove and get the last element in a list
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### rpopObservable

          @Deprecated
          public rx.Observable<String> rpopObservable(String key)

      Deprecated. use `rxRpop(java.lang.String)` instead
      Remove and get the last element in a list
      Parameters:
        `key` - Key string
      Returns:

    - #### rxRpop

          public rx.Single<String> rxRpop(String key)

      Remove and get the last element in a list
      Parameters:
        `key` - Key string
      Returns:

    - #### rpoplpush

          public RedisClient rpoplpush(String key,
                                       String destkey,
                                       Handler<AsyncResult<String>> handler)

      Remove the last element in a list, append it to another list and return it
      Parameters:
        `key` - Key string identifying source list
        `destkey` - Key string identifying destination list
        `handler` - Handler for the result of this call.
      Returns:

    - #### rpoplpushObservable

          @Deprecated
          public rx.Observable<String> rpoplpushObservable(String key,
                                                                       String destkey)

      Deprecated. use `rxRpoplpush(java.lang.String, java.lang.String)` instead
      Remove the last element in a list, append it to another list and return it
      Parameters:
        `key` - Key string identifying source list
        `destkey` - Key string identifying destination list
      Returns:

    - #### rxRpoplpush

          public rx.Single<String> rxRpoplpush(String key,
                                               String destkey)

      Remove the last element in a list, append it to another list and return it
      Parameters:
        `key` - Key string identifying source list
        `destkey` - Key string identifying destination list
      Returns:

    - #### rpushMany

          public RedisClient rpushMany(String key,
                                       List<String> values,
                                       Handler<AsyncResult<Long>> handler)

      Append one or multiple values to a list
      Parameters:
        `key` - Key string
        `values` - List of values to add to the end of the list
        `handler` - Handler for the result of this call.
      Returns:

    - #### rpushManyObservable

          @Deprecated
          public rx.Observable<Long> rpushManyObservable(String key,
                                                                     List<String> values)

      Deprecated. use `rxRpushMany(java.lang.String, java.util.List<java.lang.String>)` instead
      Append one or multiple values to a list
      Parameters:
        `key` - Key string
        `values` - List of values to add to the end of the list
      Returns:

    - #### rxRpushMany

          public rx.Single<Long> rxRpushMany(String key,
                                             List<String> values)

      Append one or multiple values to a list
      Parameters:
        `key` - Key string
        `values` - List of values to add to the end of the list
      Returns:

    - #### rpush

          public RedisClient rpush(String key,
                                   String value,
                                   Handler<AsyncResult<Long>> handler)

      Append one or multiple values to a list
      Parameters:
        `key` - Key string
        `value` - Value to be added to the end of the list
        `handler` - Handler for the result of this call.
      Returns:

    - #### rpushObservable

          @Deprecated
          public rx.Observable<Long> rpushObservable(String key,
                                                                 String value)

      Deprecated. use `rxRpush(java.lang.String, java.lang.String)` instead
      Append one or multiple values to a list
      Parameters:
        `key` - Key string
        `value` - Value to be added to the end of the list
      Returns:

    - #### rxRpush

          public rx.Single<Long> rxRpush(String key,
                                         String value)

      Append one or multiple values to a list
      Parameters:
        `key` - Key string
        `value` - Value to be added to the end of the list
      Returns:

    - #### rpushx

          public RedisClient rpushx(String key,
                                    String value,
                                    Handler<AsyncResult<Long>> handler)

      Append a value to a list, only if the list exists
      Parameters:
        `key` - Key string
        `value` - Value to be added to the end of the list
        `handler` - Handler for the result of this call.
      Returns:

    - #### rpushxObservable

          @Deprecated
          public rx.Observable<Long> rpushxObservable(String key,
                                                                  String value)

      Deprecated. use `rxRpushx(java.lang.String, java.lang.String)` instead
      Append a value to a list, only if the list exists
      Parameters:
        `key` - Key string
        `value` - Value to be added to the end of the list
      Returns:

    - #### rxRpushx

          public rx.Single<Long> rxRpushx(String key,
                                          String value)

      Append a value to a list, only if the list exists
      Parameters:
        `key` - Key string
        `value` - Value to be added to the end of the list
      Returns:

    - #### sadd

          public RedisClient sadd(String key,
                                  String member,
                                  Handler<AsyncResult<Long>> handler)

      Add a member to a set
      Parameters:
        `key` - Key string
        `member` - Value to be added to the set
        `handler` - Handler for the result of this call.
      Returns:

    - #### saddObservable

          @Deprecated
          public rx.Observable<Long> saddObservable(String key,
                                                                String member)

      Deprecated. use `rxSadd(java.lang.String, java.lang.String)` instead
      Add a member to a set
      Parameters:
        `key` - Key string
        `member` - Value to be added to the set
      Returns:

    - #### rxSadd

          public rx.Single<Long> rxSadd(String key,
                                        String member)

      Add a member to a set
      Parameters:
        `key` - Key string
        `member` - Value to be added to the set
      Returns:

    - #### saddMany

          public RedisClient saddMany(String key,
                                      List<String> members,
                                      Handler<AsyncResult<Long>> handler)

      Add one or more members to a set
      Parameters:
        `key` - Key string
        `members` - Values to be added to the set
        `handler` - Handler for the result of this call.
      Returns:

    - #### saddManyObservable

          @Deprecated
          public rx.Observable<Long> saddManyObservable(String key,
                                                                    List<String> members)

      Deprecated. use `rxSaddMany(java.lang.String, java.util.List<java.lang.String>)` instead
      Add one or more members to a set
      Parameters:
        `key` - Key string
        `members` - Values to be added to the set
      Returns:

    - #### rxSaddMany

          public rx.Single<Long> rxSaddMany(String key,
                                            List<String> members)

      Add one or more members to a set
      Parameters:
        `key` - Key string
        `members` - Values to be added to the set
      Returns:

    - #### save

          public RedisClient save(Handler<AsyncResult<String>> handler)

      Synchronously save the dataset to disk
      Parameters:
        `handler` -
      Returns:

    - #### saveObservable

          @Deprecated
          public rx.Observable<String> saveObservable()

      Deprecated. use `rxSave()` instead
      Synchronously save the dataset to disk
      Returns:

    - #### rxSave

          public rx.Single<String> rxSave()

      Synchronously save the dataset to disk
      Returns:

    - #### scard

          public RedisClient scard(String key,
                                   Handler<AsyncResult<Long>> handler)

      Get the number of members in a set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### scardObservable

          @Deprecated
          public rx.Observable<Long> scardObservable(String key)

      Deprecated. use `rxScard(java.lang.String)` instead
      Get the number of members in a set
      Parameters:
        `key` - Key string
      Returns:

    - #### rxScard

          public rx.Single<Long> rxScard(String key)

      Get the number of members in a set
      Parameters:
        `key` - Key string
      Returns:

    - #### scriptExists

          public RedisClient scriptExists(String script,
                                          Handler<AsyncResult<JsonArray>> handler)

      Check existence of script in the script cache.
      Parameters:
        `script` - SHA1 digest identifying a script in the script cache
        `handler` - Handler for the result of this call.
      Returns:

    - #### scriptExistsObservable

          @Deprecated
          public rx.Observable<JsonArray> scriptExistsObservable(String script)

      Deprecated. use `rxScriptExists(java.lang.String)` instead
      Check existence of script in the script cache.
      Parameters:
        `script` - SHA1 digest identifying a script in the script cache
      Returns:

    - #### rxScriptExists

          public rx.Single<JsonArray> rxScriptExists(String script)

      Check existence of script in the script cache.
      Parameters:
        `script` - SHA1 digest identifying a script in the script cache
      Returns:

    - #### scriptExistsMany

          public RedisClient scriptExistsMany(List<String> scripts,
                                              Handler<AsyncResult<JsonArray>> handler)

      Check existence of scripts in the script cache.
      Parameters:
        `scripts` - List of SHA1 digests identifying scripts in the script cache
        `handler` - Handler for the result of this call.
      Returns:

    - #### scriptExistsManyObservable

          @Deprecated
          public rx.Observable<JsonArray> scriptExistsManyObservable(List<String> scripts)

      Deprecated. use `rxScriptExistsMany(java.util.List<java.lang.String>)` instead
      Check existence of scripts in the script cache.
      Parameters:
        `scripts` - List of SHA1 digests identifying scripts in the script cache
      Returns:

    - #### rxScriptExistsMany

          public rx.Single<JsonArray> rxScriptExistsMany(List<String> scripts)

      Check existence of scripts in the script cache.
      Parameters:
        `scripts` - List of SHA1 digests identifying scripts in the script cache
      Returns:

    - #### scriptFlush

          public RedisClient scriptFlush(Handler<AsyncResult<String>> handler)

      Remove all the scripts from the script cache.
      Parameters:
        `handler` -
      Returns:

    - #### scriptFlushObservable

          @Deprecated
          public rx.Observable<String> scriptFlushObservable()

      Deprecated. use `rxScriptFlush()` instead
      Remove all the scripts from the script cache.
      Returns:

    - #### rxScriptFlush

          public rx.Single<String> rxScriptFlush()

      Remove all the scripts from the script cache.
      Returns:

    - #### scriptKill

          public RedisClient scriptKill(Handler<AsyncResult<String>> handler)

      Kill the script currently in execution.
      Parameters:
        `handler` -
      Returns:

    - #### scriptKillObservable

          @Deprecated
          public rx.Observable<String> scriptKillObservable()

      Deprecated. use `rxScriptKill()` instead
      Kill the script currently in execution.
      Returns:

    - #### rxScriptKill

          public rx.Single<String> rxScriptKill()

      Kill the script currently in execution.
      Returns:

    - #### scriptLoad

          public RedisClient scriptLoad(String script,
                                        Handler<AsyncResult<String>> handler)

      Load the specified Lua script into the script cache.
      Parameters:
        `script` - Lua script
        `handler` - Handler for the result of this call.
      Returns:

    - #### scriptLoadObservable

          @Deprecated
          public rx.Observable<String> scriptLoadObservable(String script)

      Deprecated. use `rxScriptLoad(java.lang.String)` instead
      Load the specified Lua script into the script cache.
      Parameters:
        `script` - Lua script
      Returns:

    - #### rxScriptLoad

          public rx.Single<String> rxScriptLoad(String script)

      Load the specified Lua script into the script cache.
      Parameters:
        `script` - Lua script
      Returns:

    - #### sdiff

          public RedisClient sdiff(String key,
                                   List<String> cmpkeys,
                                   Handler<AsyncResult<JsonArray>> handler)

      Subtract multiple sets
      Parameters:
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
        `handler` - Handler for the result of this call.
      Returns:

    - #### sdiffObservable

          @Deprecated
          public rx.Observable<JsonArray> sdiffObservable(String key,
                                                                      List<String> cmpkeys)

      Deprecated. use `rxSdiff(java.lang.String, java.util.List<java.lang.String>)` instead
      Subtract multiple sets
      Parameters:
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
      Returns:

    - #### rxSdiff

          public rx.Single<JsonArray> rxSdiff(String key,
                                              List<String> cmpkeys)

      Subtract multiple sets
      Parameters:
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
      Returns:

    - #### sdiffstore

          public RedisClient sdiffstore(String destkey,
                                        String key,
                                        List<String> cmpkeys,
                                        Handler<AsyncResult<Long>> handler)

      Subtract multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key where the result should be stored
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
        `handler` - Handler for the result of this call.
      Returns:

    - #### sdiffstoreObservable

          @Deprecated
          public rx.Observable<Long> sdiffstoreObservable(String destkey,
                                                                      String key,
                                                                      List<String> cmpkeys)

      Deprecated. use `rxSdiffstore(java.lang.String, java.lang.String, java.util.List<java.lang.String>)` instead
      Subtract multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key where the result should be stored
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
      Returns:

    - #### rxSdiffstore

          public rx.Single<Long> rxSdiffstore(String destkey,
                                              String key,
                                              List<String> cmpkeys)

      Subtract multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key where the result should be stored
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
      Returns:

    - #### select

          public RedisClient select(int dbindex,
                                    Handler<AsyncResult<String>> handler)

      Change the selected database for the current connection
      Parameters:
        `dbindex` - Index identifying the new active database
        `handler` - Handler for the result of this call.
      Returns:

    - #### selectObservable

          @Deprecated
          public rx.Observable<String> selectObservable(int dbindex)

      Deprecated. use `rxSelect(int)` instead
      Change the selected database for the current connection
      Parameters:
        `dbindex` - Index identifying the new active database
      Returns:

    - #### rxSelect

          public rx.Single<String> rxSelect(int dbindex)

      Change the selected database for the current connection
      Parameters:
        `dbindex` - Index identifying the new active database
      Returns:

    - #### set

          public RedisClient set(String key,
                                 String value,
                                 Handler<AsyncResult<Void>> handler)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `handler` - Handler for the result of this call.
      Returns:

    - #### setObservable

          @Deprecated
          public rx.Observable<Void> setObservable(String key,
                                                               String value)

      Deprecated. use `rxSet(java.lang.String, java.lang.String)` instead
      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
      Returns:

    - #### rxSet

          public rx.Single<Void> rxSet(String key,
                                       String value)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
      Returns:

    - #### setWithOptions

          public RedisClient setWithOptions(String key,
                                            String value,
                                            SetOptions options,
                                            Handler<AsyncResult<String>> handler)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `options` - Set options
        `handler` - Handler for the result of this call.
      Returns:

    - #### setWithOptionsObservable

          @Deprecated
          public rx.Observable<String> setWithOptionsObservable(String key,
                                                                            String value,
                                                                            SetOptions options)

      Deprecated. use `rxSetWithOptions(java.lang.String, java.lang.String, io.vertx.redis.op.SetOptions)` instead
      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `options` - Set options
      Returns:

    - #### rxSetWithOptions

          public rx.Single<String> rxSetWithOptions(String key,
                                                    String value,
                                                    SetOptions options)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `options` - Set options
      Returns:

    - #### setBinary

          public RedisClient setBinary(String key,
                                       Buffer value,
                                       Handler<AsyncResult<Void>> handler)

      Set the binary string value of a key - without encoding as utf-8
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `handler` - Handler for the result of this call.
      Returns:

    - #### setBinaryObservable

          @Deprecated
          public rx.Observable<Void> setBinaryObservable(String key,
                                                                     Buffer value)

      Deprecated. use `rxSetBinary(java.lang.String, io.vertx.rxjava.core.buffer.Buffer)` instead
      Set the binary string value of a key - without encoding as utf-8
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
      Returns:

    - #### rxSetBinary

          public rx.Single<Void> rxSetBinary(String key,
                                             Buffer value)

      Set the binary string value of a key - without encoding as utf-8
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
      Returns:

    - #### setBinaryWithOptions

          public RedisClient setBinaryWithOptions(String key,
                                                  Buffer value,
                                                  SetOptions options,
                                                  Handler<AsyncResult<Void>> handler)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `options` - Set options
        `handler` - Handler for the result of this call.
      Returns:

    - #### setBinaryWithOptionsObservable

          @Deprecated
          public rx.Observable<Void> setBinaryWithOptionsObservable(String key,
                                                                                Buffer value,
                                                                                SetOptions options)

      Deprecated. use `rxSetBinaryWithOptions(java.lang.String, io.vertx.rxjava.core.buffer.Buffer, io.vertx.redis.op.SetOptions)` instead
      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `options` - Set options
      Returns:

    - #### rxSetBinaryWithOptions

          public rx.Single<Void> rxSetBinaryWithOptions(String key,
                                                        Buffer value,
                                                        SetOptions options)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `options` - Set options
      Returns:

    - #### setbit

          public RedisClient setbit(String key,
                                    long offset,
                                    int bit,
                                    Handler<AsyncResult<Long>> handler)

      Sets or clears the bit at offset in the string value stored at key
      Parameters:
        `key` - Key string
        `offset` - Bit offset
        `bit` - New value - must be 1 or 0
        `handler` - Handler for the result of this call.
      Returns:

    - #### setbitObservable

          @Deprecated
          public rx.Observable<Long> setbitObservable(String key,
                                                                  long offset,
                                                                  int bit)

      Deprecated. use `rxSetbit(java.lang.String, long, int)` instead
      Sets or clears the bit at offset in the string value stored at key
      Parameters:
        `key` - Key string
        `offset` - Bit offset
        `bit` - New value - must be 1 or 0
      Returns:

    - #### rxSetbit

          public rx.Single<Long> rxSetbit(String key,
                                          long offset,
                                          int bit)

      Sets or clears the bit at offset in the string value stored at key
      Parameters:
        `key` - Key string
        `offset` - Bit offset
        `bit` - New value - must be 1 or 0
      Returns:

    - #### setex

          public RedisClient setex(String key,
                                   long seconds,
                                   String value,
                                   Handler<AsyncResult<String>> handler)

      Set the value and expiration of a key
      Parameters:
        `key` - Key string
        `seconds` - Number of seconds until the key expires
        `value` - New value for key
        `handler` - Handler for the result of this call.
      Returns:

    - #### setexObservable

          @Deprecated
          public rx.Observable<String> setexObservable(String key,
                                                                   long seconds,
                                                                   String value)

      Deprecated. use `rxSetex(java.lang.String, long, java.lang.String)` instead
      Set the value and expiration of a key
      Parameters:
        `key` - Key string
        `seconds` - Number of seconds until the key expires
        `value` - New value for key
      Returns:

    - #### rxSetex

          public rx.Single<String> rxSetex(String key,
                                           long seconds,
                                           String value)

      Set the value and expiration of a key
      Parameters:
        `key` - Key string
        `seconds` - Number of seconds until the key expires
        `value` - New value for key
      Returns:

    - #### setnx

          public RedisClient setnx(String key,
                                   String value,
                                   Handler<AsyncResult<Long>> handler)

      Set the value of a key, only if the key does not exist
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `handler` - Handler for the result of this call.
      Returns:

    - #### setnxObservable

          @Deprecated
          public rx.Observable<Long> setnxObservable(String key,
                                                                 String value)

      Deprecated. use `rxSetnx(java.lang.String, java.lang.String)` instead
      Set the value of a key, only if the key does not exist
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
      Returns:

    - #### rxSetnx

          public rx.Single<Long> rxSetnx(String key,
                                         String value)

      Set the value of a key, only if the key does not exist
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
      Returns:

    - #### setrange

          public RedisClient setrange(String key,
                                      int offset,
                                      String value,
                                      Handler<AsyncResult<Long>> handler)

      Overwrite part of a string at key starting at the specified offset
      Parameters:
        `key` - Key string
        `offset` - Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
        `value` - Value to overwrite with
        `handler` - Handler for the result of this call.
      Returns:

    - #### setrangeObservable

          @Deprecated
          public rx.Observable<Long> setrangeObservable(String key,
                                                                    int offset,
                                                                    String value)

      Deprecated. use `rxSetrange(java.lang.String, int, java.lang.String)` instead
      Overwrite part of a string at key starting at the specified offset
      Parameters:
        `key` - Key string
        `offset` - Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
        `value` - Value to overwrite with
      Returns:

    - #### rxSetrange

          public rx.Single<Long> rxSetrange(String key,
                                            int offset,
                                            String value)

      Overwrite part of a string at key starting at the specified offset
      Parameters:
        `key` - Key string
        `offset` - Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
        `value` - Value to overwrite with
      Returns:

    - #### sinter

          public RedisClient sinter(List<String> keys,
                                    Handler<AsyncResult<JsonArray>> handler)

      Intersect multiple sets
      Parameters:
        `keys` - List of keys to perform intersection on
        `handler` - Handler for the result of this call.
      Returns:

    - #### sinterObservable

          @Deprecated
          public rx.Observable<JsonArray> sinterObservable(List<String> keys)

      Deprecated. use `rxSinter(java.util.List<java.lang.String>)` instead
      Intersect multiple sets
      Parameters:
        `keys` - List of keys to perform intersection on
      Returns:

    - #### rxSinter

          public rx.Single<JsonArray> rxSinter(List<String> keys)

      Intersect multiple sets
      Parameters:
        `keys` - List of keys to perform intersection on
      Returns:

    - #### sinterstore

          public RedisClient sinterstore(String destkey,
                                         List<String> keys,
                                         Handler<AsyncResult<Long>> handler)

      Intersect multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Key where to store the results
        `keys` - List of keys to perform intersection on
        `handler` - Handler for the result of this call.
      Returns:

    - #### sinterstoreObservable

          @Deprecated
          public rx.Observable<Long> sinterstoreObservable(String destkey,
                                                                       List<String> keys)

      Deprecated. use `rxSinterstore(java.lang.String, java.util.List<java.lang.String>)` instead
      Intersect multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Key where to store the results
        `keys` - List of keys to perform intersection on
      Returns:

    - #### rxSinterstore

          public rx.Single<Long> rxSinterstore(String destkey,
                                               List<String> keys)

      Intersect multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Key where to store the results
        `keys` - List of keys to perform intersection on
      Returns:

    - #### sismember

          public RedisClient sismember(String key,
                                       String member,
                                       Handler<AsyncResult<Long>> handler)

      Determine if a given value is a member of a set
      Parameters:
        `key` - Key string
        `member` - Member to look for
        `handler` - Handler for the result of this call.
      Returns:

    - #### sismemberObservable

          @Deprecated
          public rx.Observable<Long> sismemberObservable(String key,
                                                                     String member)

      Deprecated. use `rxSismember(java.lang.String, java.lang.String)` instead
      Determine if a given value is a member of a set
      Parameters:
        `key` - Key string
        `member` - Member to look for
      Returns:

    - #### rxSismember

          public rx.Single<Long> rxSismember(String key,
                                             String member)

      Determine if a given value is a member of a set
      Parameters:
        `key` - Key string
        `member` - Member to look for
      Returns:

    - #### slaveof

          public RedisClient slaveof(String host,
                                     int port,
                                     Handler<AsyncResult<String>> handler)

      Make the server a slave of another instance
      Parameters:
        `host` - Host to become this server's master
        `port` - Port of our new master
        `handler` - Handler for the result of this call.
      Returns:

    - #### slaveofObservable

          @Deprecated
          public rx.Observable<String> slaveofObservable(String host,
                                                                     int port)

      Deprecated. use `rxSlaveof(java.lang.String, int)` instead
      Make the server a slave of another instance
      Parameters:
        `host` - Host to become this server's master
        `port` - Port of our new master
      Returns:

    - #### rxSlaveof

          public rx.Single<String> rxSlaveof(String host,
                                             int port)

      Make the server a slave of another instance
      Parameters:
        `host` - Host to become this server's master
        `port` - Port of our new master
      Returns:

    - #### slaveofNoone

          public RedisClient slaveofNoone(Handler<AsyncResult<String>> handler)

      Make this server a master
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### slaveofNooneObservable

          @Deprecated
          public rx.Observable<String> slaveofNooneObservable()

      Deprecated. use `rxSlaveofNoone()` instead
      Make this server a master
      Returns:

    - #### rxSlaveofNoone

          public rx.Single<String> rxSlaveofNoone()

      Make this server a master
      Returns:

    - #### slowlogGet

          public RedisClient slowlogGet(int limit,
                                        Handler<AsyncResult<JsonArray>> handler)

      Read the Redis slow queries log
      Parameters:
        `limit` - Number of log entries to return. If value is less than zero all entries are returned
        `handler` - Handler for the result of this call.
      Returns:

    - #### slowlogGetObservable

          @Deprecated
          public rx.Observable<JsonArray> slowlogGetObservable(int limit)

      Deprecated. use `rxSlowlogGet(int)` instead
      Read the Redis slow queries log
      Parameters:
        `limit` - Number of log entries to return. If value is less than zero all entries are returned
      Returns:

    - #### rxSlowlogGet

          public rx.Single<JsonArray> rxSlowlogGet(int limit)

      Read the Redis slow queries log
      Parameters:
        `limit` - Number of log entries to return. If value is less than zero all entries are returned
      Returns:

    - #### slowlogLen

          public RedisClient slowlogLen(Handler<AsyncResult<Long>> handler)

      Get the length of the Redis slow queries log
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### slowlogLenObservable

          @Deprecated
          public rx.Observable<Long> slowlogLenObservable()

      Deprecated. use `rxSlowlogLen()` instead
      Get the length of the Redis slow queries log
      Returns:

    - #### rxSlowlogLen

          public rx.Single<Long> rxSlowlogLen()

      Get the length of the Redis slow queries log
      Returns:

    - #### slowlogReset

          public RedisClient slowlogReset(Handler<AsyncResult<Void>> handler)

      Reset the Redis slow queries log
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### slowlogResetObservable

          @Deprecated
          public rx.Observable<Void> slowlogResetObservable()

      Deprecated. use `rxSlowlogReset()` instead
      Reset the Redis slow queries log
      Returns:

    - #### rxSlowlogReset

          public rx.Single<Void> rxSlowlogReset()

      Reset the Redis slow queries log
      Returns:

    - #### smembers

          public RedisClient smembers(String key,
                                      Handler<AsyncResult<JsonArray>> handler)

      Get all the members in a set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### smembersObservable

          @Deprecated
          public rx.Observable<JsonArray> smembersObservable(String key)

      Deprecated. use `rxSmembers(java.lang.String)` instead
      Get all the members in a set
      Parameters:
        `key` - Key string
      Returns:

    - #### rxSmembers

          public rx.Single<JsonArray> rxSmembers(String key)

      Get all the members in a set
      Parameters:
        `key` - Key string
      Returns:

    - #### smove

          public RedisClient smove(String key,
                                   String destkey,
                                   String member,
                                   Handler<AsyncResult<Long>> handler)

      Move a member from one set to another
      Parameters:
        `key` - Key of source set currently containing the member
        `destkey` - Key identifying the destination set
        `member` - Member to move
        `handler` - Handler for the result of this call.
      Returns:

    - #### smoveObservable

          @Deprecated
          public rx.Observable<Long> smoveObservable(String key,
                                                                 String destkey,
                                                                 String member)

      Deprecated. use `rxSmove(java.lang.String, java.lang.String, java.lang.String)` instead
      Move a member from one set to another
      Parameters:
        `key` - Key of source set currently containing the member
        `destkey` - Key identifying the destination set
        `member` - Member to move
      Returns:

    - #### rxSmove

          public rx.Single<Long> rxSmove(String key,
                                         String destkey,
                                         String member)

      Move a member from one set to another
      Parameters:
        `key` - Key of source set currently containing the member
        `destkey` - Key identifying the destination set
        `member` - Member to move
      Returns:

    - #### sort

          public RedisClient sort(String key,
                                  SortOptions options,
                                  Handler<AsyncResult<JsonArray>> handler)

      Sort the elements in a list, set or sorted set
      Parameters:
        `key` - Key string
        `options` - Sort options
        `handler` - Handler for the result of this call.
      Returns:

    - #### sortObservable

          @Deprecated
          public rx.Observable<JsonArray> sortObservable(String key,
                                                                     SortOptions options)

      Deprecated. use `rxSort(java.lang.String, io.vertx.redis.op.SortOptions)` instead
      Sort the elements in a list, set or sorted set
      Parameters:
        `key` - Key string
        `options` - Sort options
      Returns:

    - #### rxSort

          public rx.Single<JsonArray> rxSort(String key,
                                             SortOptions options)

      Sort the elements in a list, set or sorted set
      Parameters:
        `key` - Key string
        `options` - Sort options
      Returns:

    - #### spop

          public RedisClient spop(String key,
                                  Handler<AsyncResult<String>> handler)

      Remove and return a random member from a set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### spopObservable

          @Deprecated
          public rx.Observable<String> spopObservable(String key)

      Deprecated. use `rxSpop(java.lang.String)` instead
      Remove and return a random member from a set
      Parameters:
        `key` - Key string
      Returns:

    - #### rxSpop

          public rx.Single<String> rxSpop(String key)

      Remove and return a random member from a set
      Parameters:
        `key` - Key string
      Returns:

    - #### spopMany

          public RedisClient spopMany(String key,
                                      int count,
                                      Handler<AsyncResult<JsonArray>> handler)

      Remove and return random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to remove
        `handler` - Handler for the result of this call.
      Returns:

    - #### spopManyObservable

          @Deprecated
          public rx.Observable<JsonArray> spopManyObservable(String key,
                                                                         int count)

      Deprecated. use `rxSpopMany(java.lang.String, int)` instead
      Remove and return random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to remove
      Returns:

    - #### rxSpopMany

          public rx.Single<JsonArray> rxSpopMany(String key,
                                                 int count)

      Remove and return random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to remove
      Returns:

    - #### srandmember

          public RedisClient srandmember(String key,
                                         Handler<AsyncResult<String>> handler)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### srandmemberObservable

          @Deprecated
          public rx.Observable<String> srandmemberObservable(String key)

      Deprecated. use `rxSrandmember(java.lang.String)` instead
      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
      Returns:

    - #### rxSrandmember

          public rx.Single<String> rxSrandmember(String key)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
      Returns:

    - #### srandmemberCount

          public RedisClient srandmemberCount(String key,
                                              int count,
                                              Handler<AsyncResult<JsonArray>> handler)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to get
        `handler` - Handler for the result of this call.
      Returns:

    - #### srandmemberCountObservable

          @Deprecated
          public rx.Observable<JsonArray> srandmemberCountObservable(String key,
                                                                                 int count)

      Deprecated. use `rxSrandmemberCount(java.lang.String, int)` instead
      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to get
      Returns:

    - #### rxSrandmemberCount

          public rx.Single<JsonArray> rxSrandmemberCount(String key,
                                                         int count)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to get
      Returns:

    - #### srem

          public RedisClient srem(String key,
                                  String member,
                                  Handler<AsyncResult<Long>> handler)

      Remove one member from a set
      Parameters:
        `key` - Key string
        `member` - Member to remove
        `handler` - Handler for the result of this call.
      Returns:

    - #### sremObservable

          @Deprecated
          public rx.Observable<Long> sremObservable(String key,
                                                                String member)

      Deprecated. use `rxSrem(java.lang.String, java.lang.String)` instead
      Remove one member from a set
      Parameters:
        `key` - Key string
        `member` - Member to remove
      Returns:

    - #### rxSrem

          public rx.Single<Long> rxSrem(String key,
                                        String member)

      Remove one member from a set
      Parameters:
        `key` - Key string
        `member` - Member to remove
      Returns:

    - #### sremMany

          public RedisClient sremMany(String key,
                                      List<String> members,
                                      Handler<AsyncResult<Long>> handler)

      Remove one or more members from a set
      Parameters:
        `key` - Key string
        `members` - Members to remove
        `handler` - Handler for the result of this call.
      Returns:

    - #### sremManyObservable

          @Deprecated
          public rx.Observable<Long> sremManyObservable(String key,
                                                                    List<String> members)

      Deprecated. use `rxSremMany(java.lang.String, java.util.List<java.lang.String>)` instead
      Remove one or more members from a set
      Parameters:
        `key` - Key string
        `members` - Members to remove
      Returns:

    - #### rxSremMany

          public rx.Single<Long> rxSremMany(String key,
                                            List<String> members)

      Remove one or more members from a set
      Parameters:
        `key` - Key string
        `members` - Members to remove
      Returns:

    - #### strlen

          public RedisClient strlen(String key,
                                    Handler<AsyncResult<Long>> handler)

      Get the length of the value stored in a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### strlenObservable

          @Deprecated
          public rx.Observable<Long> strlenObservable(String key)

      Deprecated. use `rxStrlen(java.lang.String)` instead
      Get the length of the value stored in a key
      Parameters:
        `key` - Key string
      Returns:

    - #### rxStrlen

          public rx.Single<Long> rxStrlen(String key)

      Get the length of the value stored in a key
      Parameters:
        `key` - Key string
      Returns:

    - #### subscribe

          public RedisClient subscribe(String channel,
                                       Handler<AsyncResult<JsonArray>> handler)

      Listen for messages published to the given channels
      Parameters:
        `channel` - Channel to subscribe to
        `handler` - Handler for the result of this call.
      Returns:

    - #### subscribeObservable

          @Deprecated
          public rx.Observable<JsonArray> subscribeObservable(String channel)

      Deprecated. use `rxSubscribe(java.lang.String)` instead
      Listen for messages published to the given channels
      Parameters:
        `channel` - Channel to subscribe to
      Returns:

    - #### rxSubscribe

          public rx.Single<JsonArray> rxSubscribe(String channel)

      Listen for messages published to the given channels
      Parameters:
        `channel` - Channel to subscribe to
      Returns:

    - #### subscribeMany

          public RedisClient subscribeMany(List<String> channels,
                                           Handler<AsyncResult<JsonArray>> handler)

      Listen for messages published to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
        `handler` - Handler for the result of this call.
      Returns:

    - #### subscribeManyObservable

          @Deprecated
          public rx.Observable<JsonArray> subscribeManyObservable(List<String> channels)

      Deprecated. use `rxSubscribeMany(java.util.List<java.lang.String>)` instead
      Listen for messages published to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
      Returns:

    - #### rxSubscribeMany

          public rx.Single<JsonArray> rxSubscribeMany(List<String> channels)

      Listen for messages published to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
      Returns:

    - #### sunion

          public RedisClient sunion(List<String> keys,
                                    Handler<AsyncResult<JsonArray>> handler)

      Add multiple sets
      Parameters:
        `keys` - List of keys identifying sets to add up
        `handler` - Handler for the result of this call.
      Returns:

    - #### sunionObservable

          @Deprecated
          public rx.Observable<JsonArray> sunionObservable(List<String> keys)

      Deprecated. use `rxSunion(java.util.List<java.lang.String>)` instead
      Add multiple sets
      Parameters:
        `keys` - List of keys identifying sets to add up
      Returns:

    - #### rxSunion

          public rx.Single<JsonArray> rxSunion(List<String> keys)

      Add multiple sets
      Parameters:
        `keys` - List of keys identifying sets to add up
      Returns:

    - #### sunionstore

          public RedisClient sunionstore(String destkey,
                                         List<String> keys,
                                         Handler<AsyncResult<Long>> handler)

      Add multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key
        `keys` - List of keys identifying sets to add up
        `handler` - Handler for the result of this call.
      Returns:

    - #### sunionstoreObservable

          @Deprecated
          public rx.Observable<Long> sunionstoreObservable(String destkey,
                                                                       List<String> keys)

      Deprecated. use `rxSunionstore(java.lang.String, java.util.List<java.lang.String>)` instead
      Add multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key
        `keys` - List of keys identifying sets to add up
      Returns:

    - #### rxSunionstore

          public rx.Single<Long> rxSunionstore(String destkey,
                                               List<String> keys)

      Add multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key
        `keys` - List of keys identifying sets to add up
      Returns:

    - #### sync

          public RedisClient sync(Handler<AsyncResult<Void>> handler)

      Internal command used for replication
      Parameters:
        `handler` -
      Returns:

    - #### syncObservable

          @Deprecated
          public rx.Observable<Void> syncObservable()

      Deprecated. use `rxSync()` instead
      Internal command used for replication
      Returns:

    - #### rxSync

          public rx.Single<Void> rxSync()

      Internal command used for replication
      Returns:

    - #### time

          public RedisClient time(Handler<AsyncResult<JsonArray>> handler)

      Return the current server time
      Parameters:
        `handler` -
      Returns:

    - #### timeObservable

          @Deprecated
          public rx.Observable<JsonArray> timeObservable()

      Deprecated. use `rxTime()` instead
      Return the current server time
      Returns:

    - #### rxTime

          public rx.Single<JsonArray> rxTime()

      Return the current server time
      Returns:

    - #### transaction

          public RedisTransaction transaction()

      Return a RedisTransaction instance
      Returns:
        transaction instance

    - #### ttl

          public RedisClient ttl(String key,
                                 Handler<AsyncResult<Long>> handler)

      Get the time to live for a key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### ttlObservable

          @Deprecated
          public rx.Observable<Long> ttlObservable(String key)

      Deprecated. use `rxTtl(java.lang.String)` instead
      Get the time to live for a key
      Parameters:
        `key` - Key string
      Returns:

    - #### rxTtl

          public rx.Single<Long> rxTtl(String key)

      Get the time to live for a key
      Parameters:
        `key` - Key string
      Returns:

    - #### type

          public RedisClient type(String key,
                                  Handler<AsyncResult<String>> handler)

      Determine the type stored at key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### typeObservable

          @Deprecated
          public rx.Observable<String> typeObservable(String key)

      Deprecated. use `rxType(java.lang.String)` instead
      Determine the type stored at key
      Parameters:
        `key` - Key string
      Returns:

    - #### rxType

          public rx.Single<String> rxType(String key)

      Determine the type stored at key
      Parameters:
        `key` - Key string
      Returns:

    - #### unsubscribe

          public RedisClient unsubscribe(List<String> channels,
                                         Handler<AsyncResult<Void>> handler)

      Stop listening for messages posted to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
        `handler` - Handler for the result of this call.
      Returns:

    - #### unsubscribeObservable

          @Deprecated
          public rx.Observable<Void> unsubscribeObservable(List<String> channels)

      Deprecated. use `rxUnsubscribe(java.util.List<java.lang.String>)` instead
      Stop listening for messages posted to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
      Returns:

    - #### rxUnsubscribe

          public rx.Single<Void> rxUnsubscribe(List<String> channels)

      Stop listening for messages posted to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
      Returns:

    - #### wait

          public RedisClient wait(long numSlaves,
                                  long timeout,
                                  Handler<AsyncResult<String>> handler)

      Wait for the synchronous replication of all the write commands sent in the context of the current connection.
      Parameters:
        `numSlaves` -
        `timeout` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### waitObservable

          @Deprecated
          public rx.Observable<String> waitObservable(long numSlaves,
                                                                  long timeout)

      Deprecated. use `rxWait(long, long)` instead
      Wait for the synchronous replication of all the write commands sent in the context of the current connection.
      Parameters:
        `numSlaves` -
        `timeout` -
      Returns:

    - #### rxWait

          public rx.Single<String> rxWait(long numSlaves,
                                          long timeout)

      Wait for the synchronous replication of all the write commands sent in the context of the current connection.
      Parameters:
        `numSlaves` -
        `timeout` -
      Returns:

    - #### zadd

          public RedisClient zadd(String key,
                                  double score,
                                  String member,
                                  Handler<AsyncResult<Long>> handler)

      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `score` - Score used for sorting
        `member` - New member key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zaddObservable

          @Deprecated
          public rx.Observable<Long> zaddObservable(String key,
                                                                double score,
                                                                String member)

      Deprecated. use `rxZadd(java.lang.String, double, java.lang.String)` instead
      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `score` - Score used for sorting
        `member` - New member key
      Returns:

    - #### rxZadd

          public rx.Single<Long> rxZadd(String key,
                                        double score,
                                        String member)

      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `score` - Score used for sorting
        `member` - New member key
      Returns:

    - #### zaddMany

          public RedisClient zaddMany(String key,
                                      Map<String,Double> members,
                                      Handler<AsyncResult<Long>> handler)

      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `members` - New member keys and their scores
        `handler` - Handler for the result of this call.
      Returns:

    - #### zaddManyObservable

          @Deprecated
          public rx.Observable<Long> zaddManyObservable(String key,
                                                                    Map<String,Double> members)

      Deprecated. use `rxZaddMany(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>)` instead
      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `members` - New member keys and their scores
      Returns:

    - #### rxZaddMany

          public rx.Single<Long> rxZaddMany(String key,
                                            Map<String,Double> members)

      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `members` - New member keys and their scores
      Returns:

    - #### zcard

          public RedisClient zcard(String key,
                                   Handler<AsyncResult<Long>> handler)

      Get the number of members in a sorted set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### zcardObservable

          @Deprecated
          public rx.Observable<Long> zcardObservable(String key)

      Deprecated. use `rxZcard(java.lang.String)` instead
      Get the number of members in a sorted set
      Parameters:
        `key` - Key string
      Returns:

    - #### rxZcard

          public rx.Single<Long> rxZcard(String key)

      Get the number of members in a sorted set
      Parameters:
        `key` - Key string
      Returns:

    - #### zcount

          public RedisClient zcount(String key,
                                    double min,
                                    double max,
                                    Handler<AsyncResult<Long>> handler)

      Count the members in a sorted set with scores within the given values
      Parameters:
        `key` - Key string
        `min` - Minimum score
        `max` - Maximum score
        `handler` - Handler for the result of this call.
      Returns:

    - #### zcountObservable

          @Deprecated
          public rx.Observable<Long> zcountObservable(String key,
                                                                  double min,
                                                                  double max)

      Deprecated. use `rxZcount(java.lang.String, double, double)` instead
      Count the members in a sorted set with scores within the given values
      Parameters:
        `key` - Key string
        `min` - Minimum score
        `max` - Maximum score
      Returns:

    - #### rxZcount

          public rx.Single<Long> rxZcount(String key,
                                          double min,
                                          double max)

      Count the members in a sorted set with scores within the given values
      Parameters:
        `key` - Key string
        `min` - Minimum score
        `max` - Maximum score
      Returns:

    - #### zincrby

          public RedisClient zincrby(String key,
                                     double increment,
                                     String member,
                                     Handler<AsyncResult<String>> handler)

      Increment the score of a member in a sorted set
      Parameters:
        `key` - Key string
        `increment` - Increment amount
        `member` - Member key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zincrbyObservable

          @Deprecated
          public rx.Observable<String> zincrbyObservable(String key,
                                                                     double increment,
                                                                     String member)

      Deprecated. use `rxZincrby(java.lang.String, double, java.lang.String)` instead
      Increment the score of a member in a sorted set
      Parameters:
        `key` - Key string
        `increment` - Increment amount
        `member` - Member key
      Returns:

    - #### rxZincrby

          public rx.Single<String> rxZincrby(String key,
                                             double increment,
                                             String member)

      Increment the score of a member in a sorted set
      Parameters:
        `key` - Key string
        `increment` - Increment amount
        `member` - Member key
      Returns:

    - #### zinterstore

          public RedisClient zinterstore(String destkey,
                                         List<String> sets,
                                         AggregateOptions options,
                                         Handler<AsyncResult<Long>> handler)

      Intersect multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zinterstoreObservable

          @Deprecated
          public rx.Observable<Long> zinterstoreObservable(String destkey,
                                                                       List<String> sets,
                                                                       AggregateOptions options)

      Deprecated. use `rxZinterstore(java.lang.String, java.util.List<java.lang.String>, io.vertx.redis.op.AggregateOptions)` instead
      Intersect multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
      Returns:

    - #### rxZinterstore

          public rx.Single<Long> rxZinterstore(String destkey,
                                               List<String> sets,
                                               AggregateOptions options)

      Intersect multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
      Returns:

    - #### zinterstoreWeighed

          public RedisClient zinterstoreWeighed(String destkey,
                                                Map<String,Double> sets,
                                                AggregateOptions options,
                                                Handler<AsyncResult<Long>> handler)

      Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zinterstoreWeighedObservable

          @Deprecated
          public rx.Observable<Long> zinterstoreWeighedObservable(String destkey,
                                                                              Map<String,Double> sets,
                                                                              AggregateOptions options)

      Deprecated. use `rxZinterstoreWeighed(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>, io.vertx.redis.op.AggregateOptions)` instead
      Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
      Returns:

    - #### rxZinterstoreWeighed

          public rx.Single<Long> rxZinterstoreWeighed(String destkey,
                                                      Map<String,Double> sets,
                                                      AggregateOptions options)

      Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
      Returns:

    - #### zlexcount

          public RedisClient zlexcount(String key,
                                       String min,
                                       String max,
                                       Handler<AsyncResult<Long>> handler)

      Count the number of members in a sorted set between a given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern to compare against for minimum value
        `max` - Pattern to compare against for maximum value
        `handler` - Handler for the result of this call.
      Returns:

    - #### zlexcountObservable

          @Deprecated
          public rx.Observable<Long> zlexcountObservable(String key,
                                                                     String min,
                                                                     String max)

      Deprecated. use `rxZlexcount(java.lang.String, java.lang.String, java.lang.String)` instead
      Count the number of members in a sorted set between a given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern to compare against for minimum value
        `max` - Pattern to compare against for maximum value
      Returns:

    - #### rxZlexcount

          public rx.Single<Long> rxZlexcount(String key,
                                             String min,
                                             String max)

      Count the number of members in a sorted set between a given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern to compare against for minimum value
        `max` - Pattern to compare against for maximum value
      Returns:

    - #### zrange

          public RedisClient zrange(String key,
                                    long start,
                                    long stop,
                                    Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrangeObservable

          @Deprecated
          public rx.Observable<JsonArray> zrangeObservable(String key,
                                                                       long start,
                                                                       long stop)

      Deprecated. use `rxZrange(java.lang.String, long, long)` instead
      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
      Returns:

    - #### rxZrange

          public rx.Single<JsonArray> rxZrange(String key,
                                               long start,
                                               long stop)

      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
      Returns:

    - #### zrangeWithOptions

          public RedisClient zrangeWithOptions(String key,
                                               long start,
                                               long stop,
                                               RangeOptions options,
                                               Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrangeWithOptionsObservable

          @Deprecated
          public rx.Observable<JsonArray> zrangeWithOptionsObservable(String key,
                                                                                  long start,
                                                                                  long stop,
                                                                                  RangeOptions options)

      Deprecated. use `rxZrangeWithOptions(java.lang.String, long, long, io.vertx.redis.op.RangeOptions)` instead
      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
      Returns:

    - #### rxZrangeWithOptions

          public rx.Single<JsonArray> rxZrangeWithOptions(String key,
                                                          long start,
                                                          long stop,
                                                          RangeOptions options)

      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
      Returns:

    - #### zrangebylex

          public RedisClient zrangebylex(String key,
                                         String min,
                                         String max,
                                         LimitOptions options,
                                         Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern representing a minimum allowed value
        `max` - Pattern representing a maximum allowed value
        `options` - Limit options where limit can be specified
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrangebylexObservable

          @Deprecated
          public rx.Observable<JsonArray> zrangebylexObservable(String key,
                                                                            String min,
                                                                            String max,
                                                                            LimitOptions options)

      Deprecated. use `rxZrangebylex(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.LimitOptions)` instead
      Return a range of members in a sorted set, by lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern representing a minimum allowed value
        `max` - Pattern representing a maximum allowed value
        `options` - Limit options where limit can be specified
      Returns:

    - #### rxZrangebylex

          public rx.Single<JsonArray> rxZrangebylex(String key,
                                                    String min,
                                                    String max,
                                                    LimitOptions options)

      Return a range of members in a sorted set, by lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern representing a minimum allowed value
        `max` - Pattern representing a maximum allowed value
        `options` - Limit options where limit can be specified
      Returns:

    - #### zrangebyscore

          public RedisClient zrangebyscore(String key,
                                           String min,
                                           String max,
                                           RangeLimitOptions options,
                                           Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by score
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `options` - Range and limit options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrangebyscoreObservable

          @Deprecated
          public rx.Observable<JsonArray> zrangebyscoreObservable(String key,
                                                                              String min,
                                                                              String max,
                                                                              RangeLimitOptions options)

      Deprecated. use `rxZrangebyscore(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.RangeLimitOptions)` instead
      Return a range of members in a sorted set, by score
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `options` - Range and limit options
      Returns:

    - #### rxZrangebyscore

          public rx.Single<JsonArray> rxZrangebyscore(String key,
                                                      String min,
                                                      String max,
                                                      RangeLimitOptions options)

      Return a range of members in a sorted set, by score
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `options` - Range and limit options
      Returns:

    - #### zrank

          public RedisClient zrank(String key,
                                   String member,
                                   Handler<AsyncResult<Long>> handler)

      Determine the index of a member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrankObservable

          @Deprecated
          public rx.Observable<Long> zrankObservable(String key,
                                                                 String member)

      Deprecated. use `rxZrank(java.lang.String, java.lang.String)` instead
      Determine the index of a member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### rxZrank

          public rx.Single<Long> rxZrank(String key,
                                         String member)

      Determine the index of a member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### zrem

          public RedisClient zrem(String key,
                                  String member,
                                  Handler<AsyncResult<Long>> handler)

      Remove one member from a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zremObservable

          @Deprecated
          public rx.Observable<Long> zremObservable(String key,
                                                                String member)

      Deprecated. use `rxZrem(java.lang.String, java.lang.String)` instead
      Remove one member from a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### rxZrem

          public rx.Single<Long> rxZrem(String key,
                                        String member)

      Remove one member from a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### zremMany

          public RedisClient zremMany(String key,
                                      List<String> members,
                                      Handler<AsyncResult<Long>> handler)

      Remove one or more members from a sorted set
      Parameters:
        `key` - Key string
        `members` - Members in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zremManyObservable

          @Deprecated
          public rx.Observable<Long> zremManyObservable(String key,
                                                                    List<String> members)

      Deprecated. use `rxZremMany(java.lang.String, java.util.List<java.lang.String>)` instead
      Remove one or more members from a sorted set
      Parameters:
        `key` - Key string
        `members` - Members in the sorted set identified by key
      Returns:

    - #### rxZremMany

          public rx.Single<Long> rxZremMany(String key,
                                            List<String> members)

      Remove one or more members from a sorted set
      Parameters:
        `key` - Key string
        `members` - Members in the sorted set identified by key
      Returns:

    - #### zremrangebylex

          public RedisClient zremrangebylex(String key,
                                            String min,
                                            String max,
                                            Handler<AsyncResult<Long>> handler)

      Remove all members in a sorted set between the given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `handler` - Handler for the result of this call.
      Returns:

    - #### zremrangebylexObservable

          @Deprecated
          public rx.Observable<Long> zremrangebylexObservable(String key,
                                                                          String min,
                                                                          String max)

      Deprecated. use `rxZremrangebylex(java.lang.String, java.lang.String, java.lang.String)` instead
      Remove all members in a sorted set between the given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
      Returns:

    - #### rxZremrangebylex

          public rx.Single<Long> rxZremrangebylex(String key,
                                                  String min,
                                                  String max)

      Remove all members in a sorted set between the given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
      Returns:

    - #### zremrangebyrank

          public RedisClient zremrangebyrank(String key,
                                             long start,
                                             long stop,
                                             Handler<AsyncResult<Long>> handler)

      Remove all members in a sorted set within the given indexes
      Parameters:
        `key` - Key string
        `start` - Start index
        `stop` - Stop index
        `handler` - Handler for the result of this call.
      Returns:

    - #### zremrangebyrankObservable

          @Deprecated
          public rx.Observable<Long> zremrangebyrankObservable(String key,
                                                                           long start,
                                                                           long stop)

      Deprecated. use `rxZremrangebyrank(java.lang.String, long, long)` instead
      Remove all members in a sorted set within the given indexes
      Parameters:
        `key` - Key string
        `start` - Start index
        `stop` - Stop index
      Returns:

    - #### rxZremrangebyrank

          public rx.Single<Long> rxZremrangebyrank(String key,
                                                   long start,
                                                   long stop)

      Remove all members in a sorted set within the given indexes
      Parameters:
        `key` - Key string
        `start` - Start index
        `stop` - Stop index
      Returns:

    - #### zremrangebyscore

          public RedisClient zremrangebyscore(String key,
                                              String min,
                                              String max,
                                              Handler<AsyncResult<Long>> handler)

      Remove all members in a sorted set within the given scores
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `handler` -
      Returns:

    - #### zremrangebyscoreObservable

          @Deprecated
          public rx.Observable<Long> zremrangebyscoreObservable(String key,
                                                                            String min,
                                                                            String max)

      Deprecated. use `rxZremrangebyscore(java.lang.String, java.lang.String, java.lang.String)` instead
      Remove all members in a sorted set within the given scores
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
      Returns:

    - #### rxZremrangebyscore

          public rx.Single<Long> rxZremrangebyscore(String key,
                                                    String min,
                                                    String max)

      Remove all members in a sorted set within the given scores
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
      Returns:

    - #### zrevrange

          public RedisClient zrevrange(String key,
                                       long start,
                                       long stop,
                                       RangeOptions options,
                                       Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by index, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrevrangeObservable

          @Deprecated
          public rx.Observable<JsonArray> zrevrangeObservable(String key,
                                                                          long start,
                                                                          long stop,
                                                                          RangeOptions options)

      Deprecated. use `rxZrevrange(java.lang.String, long, long, io.vertx.redis.op.RangeOptions)` instead
      Return a range of members in a sorted set, by index, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
      Returns:

    - #### rxZrevrange

          public rx.Single<JsonArray> rxZrevrange(String key,
                                                  long start,
                                                  long stop,
                                                  RangeOptions options)

      Return a range of members in a sorted set, by index, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
      Returns:

    - #### zrevrangebylex

          public RedisClient zrevrangebylex(String key,
                                            String max,
                                            String min,
                                            LimitOptions options,
                                            Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Limit options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrevrangebylexObservable

          @Deprecated
          public rx.Observable<JsonArray> zrevrangebylexObservable(String key,
                                                                               String max,
                                                                               String min,
                                                                               LimitOptions options)

      Deprecated. use `rxZrevrangebylex(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.LimitOptions)` instead
      Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Limit options
      Returns:

    - #### rxZrevrangebylex

          public rx.Single<JsonArray> rxZrevrangebylex(String key,
                                                       String max,
                                                       String min,
                                                       LimitOptions options)

      Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Limit options
      Returns:

    - #### zrevrangebyscore

          public RedisClient zrevrangebyscore(String key,
                                              String max,
                                              String min,
                                              RangeLimitOptions options,
                                              Handler<AsyncResult<JsonArray>> handler)

      Return a range of members in a sorted set, by score, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Range and limit options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrevrangebyscoreObservable

          @Deprecated
          public rx.Observable<JsonArray> zrevrangebyscoreObservable(String key,
                                                                                 String max,
                                                                                 String min,
                                                                                 RangeLimitOptions options)

      Deprecated. use `rxZrevrangebyscore(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.RangeLimitOptions)` instead
      Return a range of members in a sorted set, by score, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Range and limit options
      Returns:

    - #### rxZrevrangebyscore

          public rx.Single<JsonArray> rxZrevrangebyscore(String key,
                                                         String max,
                                                         String min,
                                                         RangeLimitOptions options)

      Return a range of members in a sorted set, by score, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Range and limit options
      Returns:

    - #### zrevrank

          public RedisClient zrevrank(String key,
                                      String member,
                                      Handler<AsyncResult<Long>> handler)

      Determine the index of a member in a sorted set, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zrevrankObservable

          @Deprecated
          public rx.Observable<Long> zrevrankObservable(String key,
                                                                    String member)

      Deprecated. use `rxZrevrank(java.lang.String, java.lang.String)` instead
      Determine the index of a member in a sorted set, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### rxZrevrank

          public rx.Single<Long> rxZrevrank(String key,
                                            String member)

      Determine the index of a member in a sorted set, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### zscore

          public RedisClient zscore(String key,
                                    String member,
                                    Handler<AsyncResult<String>> handler)

      Get the score associated with the given member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### zscoreObservable

          @Deprecated
          public rx.Observable<String> zscoreObservable(String key,
                                                                    String member)

      Deprecated. use `rxZscore(java.lang.String, java.lang.String)` instead
      Get the score associated with the given member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### rxZscore

          public rx.Single<String> rxZscore(String key,
                                            String member)

      Get the score associated with the given member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### zunionstore

          public RedisClient zunionstore(String destkey,
                                         List<String> sets,
                                         AggregateOptions options,
                                         Handler<AsyncResult<Long>> handler)

      Add multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zunionstoreObservable

          @Deprecated
          public rx.Observable<Long> zunionstoreObservable(String destkey,
                                                                       List<String> sets,
                                                                       AggregateOptions options)

      Deprecated. use `rxZunionstore(java.lang.String, java.util.List<java.lang.String>, io.vertx.redis.op.AggregateOptions)` instead
      Add multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets
        `options` - Aggregation options
      Returns:

    - #### rxZunionstore

          public rx.Single<Long> rxZunionstore(String destkey,
                                               List<String> sets,
                                               AggregateOptions options)

      Add multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets
        `options` - Aggregation options
      Returns:

    - #### zunionstoreWeighed

          public RedisClient zunionstoreWeighed(String key,
                                                Map<String,Double> sets,
                                                AggregateOptions options,
                                                Handler<AsyncResult<Long>> handler)

      Add multiple sorted sets using weights, and store the resulting sorted set in a new key
      Parameters:
        `key` - Destination key
        `sets` - Map containing set-key:weight pairs
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zunionstoreWeighedObservable

          @Deprecated
          public rx.Observable<Long> zunionstoreWeighedObservable(String key,
                                                                              Map<String,Double> sets,
                                                                              AggregateOptions options)

      Deprecated. use `rxZunionstoreWeighed(java.lang.String, java.util.Map<java.lang.String, java.lang.Double>, io.vertx.redis.op.AggregateOptions)` instead
      Add multiple sorted sets using weights, and store the resulting sorted set in a new key
      Parameters:
        `key` - Destination key
        `sets` - Map containing set-key:weight pairs
        `options` - Aggregation options
      Returns:

    - #### rxZunionstoreWeighed

          public rx.Single<Long> rxZunionstoreWeighed(String key,
                                                      Map<String,Double> sets,
                                                      AggregateOptions options)

      Add multiple sorted sets using weights, and store the resulting sorted set in a new key
      Parameters:
        `key` - Destination key
        `sets` - Map containing set-key:weight pairs
        `options` - Aggregation options
      Returns:

    - #### scan

          public RedisClient scan(String cursor,
                                  ScanOptions options,
                                  Handler<AsyncResult<JsonArray>> handler)

      Incrementally iterate the keys space
      Parameters:
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### scanObservable

          @Deprecated
          public rx.Observable<JsonArray> scanObservable(String cursor,
                                                                     ScanOptions options)

      Deprecated. use `rxScan(java.lang.String, io.vertx.redis.op.ScanOptions)` instead
      Incrementally iterate the keys space
      Parameters:
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### rxScan

          public rx.Single<JsonArray> rxScan(String cursor,
                                             ScanOptions options)

      Incrementally iterate the keys space
      Parameters:
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### sscan

          public RedisClient sscan(String key,
                                   String cursor,
                                   ScanOptions options,
                                   Handler<AsyncResult<JsonArray>> handler)

      Incrementally iterate Set elements
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### sscanObservable

          @Deprecated
          public rx.Observable<JsonArray> sscanObservable(String key,
                                                                      String cursor,
                                                                      ScanOptions options)

      Deprecated. use `rxSscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions)` instead
      Incrementally iterate Set elements
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### rxSscan

          public rx.Single<JsonArray> rxSscan(String key,
                                              String cursor,
                                              ScanOptions options)

      Incrementally iterate Set elements
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### hscan

          public RedisClient hscan(String key,
                                   String cursor,
                                   ScanOptions options,
                                   Handler<AsyncResult<JsonArray>> handler)

      Incrementally iterate hash fields and associated values
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### hscanObservable

          @Deprecated
          public rx.Observable<JsonArray> hscanObservable(String key,
                                                                      String cursor,
                                                                      ScanOptions options)

      Deprecated. use `rxHscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions)` instead
      Incrementally iterate hash fields and associated values
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### rxHscan

          public rx.Single<JsonArray> rxHscan(String key,
                                              String cursor,
                                              ScanOptions options)

      Incrementally iterate hash fields and associated values
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### zscan

          public RedisClient zscan(String key,
                                   String cursor,
                                   ScanOptions options,
                                   Handler<AsyncResult<JsonArray>> handler)

      Incrementally iterate sorted sets elements and associated scores
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### zscanObservable

          @Deprecated
          public rx.Observable<JsonArray> zscanObservable(String key,
                                                                      String cursor,
                                                                      ScanOptions options)

      Deprecated. use `rxZscan(java.lang.String, java.lang.String, io.vertx.redis.op.ScanOptions)` instead
      Incrementally iterate sorted sets elements and associated scores
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### rxZscan

          public rx.Single<JsonArray> rxZscan(String key,
                                              String cursor,
                                              ScanOptions options)

      Incrementally iterate sorted sets elements and associated scores
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### geoadd

          public RedisClient geoadd(String key,
                                    double longitude,
                                    double latitude,
                                    String member,
                                    Handler<AsyncResult<Long>> handler)

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `member` - member
        `handler` - Handler for the result of this call.
      Returns:

    - #### geoaddObservable

          @Deprecated
          public rx.Observable<Long> geoaddObservable(String key,
                                                                  double longitude,
                                                                  double latitude,
                                                                  String member)

      Deprecated. use `rxGeoadd(java.lang.String, double, double, java.lang.String)` instead
      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `member` - member
      Returns:

    - #### rxGeoadd

          public rx.Single<Long> rxGeoadd(String key,
                                          double longitude,
                                          double latitude,
                                          String member)

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `member` - member
      Returns:

    - #### geoaddMany

          public RedisClient geoaddMany(String key,
                                        List<GeoMember> members,
                                        Handler<AsyncResult<Long>> handler)

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `members` - list of <lon, lat, member>
        `handler` - Handler for the result of this call.
      Returns:

    - #### geoaddManyObservable

          @Deprecated
          public rx.Observable<Long> geoaddManyObservable(String key,
                                                                      List<GeoMember> members)

      Deprecated. use `rxGeoaddMany(java.lang.String, java.util.List<io.vertx.redis.op.GeoMember>)` instead
      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `members` - list of <lon, lat, member>
      Returns:

    - #### rxGeoaddMany

          public rx.Single<Long> rxGeoaddMany(String key,
                                              List<GeoMember> members)

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `members` - list of <lon, lat, member>
      Returns:

    - #### geohash

          public RedisClient geohash(String key,
                                     String member,
                                     Handler<AsyncResult<JsonArray>> handler)

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `member` - member
        `handler` - Handler for the result of this call.
      Returns:

    - #### geohashObservable

          @Deprecated
          public rx.Observable<JsonArray> geohashObservable(String key,
                                                                        String member)

      Deprecated. use `rxGeohash(java.lang.String, java.lang.String)` instead
      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `member` - member
      Returns:

    - #### rxGeohash

          public rx.Single<JsonArray> rxGeohash(String key,
                                                String member)

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `member` - member
      Returns:

    - #### geohashMany

          public RedisClient geohashMany(String key,
                                         List<String> members,
                                         Handler<AsyncResult<JsonArray>> handler)

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `members` - list of members
        `handler` - Handler for the result of this call.
      Returns:

    - #### geohashManyObservable

          @Deprecated
          public rx.Observable<JsonArray> geohashManyObservable(String key,
                                                                            List<String> members)

      Deprecated. use `rxGeohashMany(java.lang.String, java.util.List<java.lang.String>)` instead
      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `members` - list of members
      Returns:

    - #### rxGeohashMany

          public rx.Single<JsonArray> rxGeohashMany(String key,
                                                    List<String> members)

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `members` - list of members
      Returns:

    - #### geopos

          public RedisClient geopos(String key,
                                    String member,
                                    Handler<AsyncResult<JsonArray>> handler)

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `member` - member
        `handler` - Handler for the result of this call.
      Returns:

    - #### geoposObservable

          @Deprecated
          public rx.Observable<JsonArray> geoposObservable(String key,
                                                                       String member)

      Deprecated. use `rxGeopos(java.lang.String, java.lang.String)` instead
      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `member` - member
      Returns:

    - #### rxGeopos

          public rx.Single<JsonArray> rxGeopos(String key,
                                               String member)

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `member` - member
      Returns:

    - #### geoposMany

          public RedisClient geoposMany(String key,
                                        List<String> members,
                                        Handler<AsyncResult<JsonArray>> handler)

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `members` - list of members
        `handler` - Handler for the result of this call.
      Returns:

    - #### geoposManyObservable

          @Deprecated
          public rx.Observable<JsonArray> geoposManyObservable(String key,
                                                                           List<String> members)

      Deprecated. use `rxGeoposMany(java.lang.String, java.util.List<java.lang.String>)` instead
      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `members` - list of members
      Returns:

    - #### rxGeoposMany

          public rx.Single<JsonArray> rxGeoposMany(String key,
                                                   List<String> members)

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `members` - list of members
      Returns:

    - #### geodist

          public RedisClient geodist(String key,
                                     String member1,
                                     String member2,
                                     Handler<AsyncResult<String>> handler)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
        `handler` - Handler for the result of this call.
      Returns:

    - #### geodistObservable

          @Deprecated
          public rx.Observable<String> geodistObservable(String key,
                                                                     String member1,
                                                                     String member2)

      Deprecated. use `rxGeodist(java.lang.String, java.lang.String, java.lang.String)` instead
      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
      Returns:

    - #### rxGeodist

          public rx.Single<String> rxGeodist(String key,
                                             String member1,
                                             String member2)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
      Returns:

    - #### geodistWithUnit

          public RedisClient geodistWithUnit(String key,
                                             String member1,
                                             String member2,
                                             GeoUnit unit,
                                             Handler<AsyncResult<String>> handler)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
        `unit` - geo unit
        `handler` - Handler for the result of this call.
      Returns:

    - #### geodistWithUnitObservable

          @Deprecated
          public rx.Observable<String> geodistWithUnitObservable(String key,
                                                                             String member1,
                                                                             String member2,
                                                                             GeoUnit unit)

      Deprecated. use `rxGeodistWithUnit(java.lang.String, java.lang.String, java.lang.String, io.vertx.redis.op.GeoUnit)` instead
      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
        `unit` - geo unit
      Returns:

    - #### rxGeodistWithUnit

          public rx.Single<String> rxGeodistWithUnit(String key,
                                                     String member1,
                                                     String member2,
                                                     GeoUnit unit)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
        `unit` - geo unit
      Returns:

    - #### georadius

          public RedisClient georadius(String key,
                                       double longitude,
                                       double latitude,
                                       double radius,
                                       GeoUnit unit,
                                       Handler<AsyncResult<JsonArray>> handler)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
        `handler` - Handler for the result of this call.
      Returns:

    - #### georadiusObservable

          @Deprecated
          public rx.Observable<JsonArray> georadiusObservable(String key,
                                                                          double longitude,
                                                                          double latitude,
                                                                          double radius,
                                                                          GeoUnit unit)

      Deprecated. use `rxGeoradius(java.lang.String, double, double, double, io.vertx.redis.op.GeoUnit)` instead
      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
      Returns:

    - #### rxGeoradius

          public rx.Single<JsonArray> rxGeoradius(String key,
                                                  double longitude,
                                                  double latitude,
                                                  double radius,
                                                  GeoUnit unit)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
      Returns:

    - #### georadiusWithOptions

          public RedisClient georadiusWithOptions(String key,
                                                  double longitude,
                                                  double latitude,
                                                  double radius,
                                                  GeoUnit unit,
                                                  GeoRadiusOptions options,
                                                  Handler<AsyncResult<JsonArray>> handler)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
        `handler` - Handler for the result of this call.
      Returns:

    - #### georadiusWithOptionsObservable

          @Deprecated
          public rx.Observable<JsonArray> georadiusWithOptionsObservable(String key,
                                                                                     double longitude,
                                                                                     double latitude,
                                                                                     double radius,
                                                                                     GeoUnit unit,
                                                                                     GeoRadiusOptions options)

      Deprecated. use `rxGeoradiusWithOptions(java.lang.String, double, double, double, io.vertx.redis.op.GeoUnit, io.vertx.redis.op.GeoRadiusOptions)` instead
      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
      Returns:

    - #### rxGeoradiusWithOptions

          public rx.Single<JsonArray> rxGeoradiusWithOptions(String key,
                                                             double longitude,
                                                             double latitude,
                                                             double radius,
                                                             GeoUnit unit,
                                                             GeoRadiusOptions options)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
      Returns:

    - #### georadiusbymember

          public RedisClient georadiusbymember(String key,
                                               String member,
                                               double radius,
                                               GeoUnit unit,
                                               Handler<AsyncResult<JsonArray>> handler)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
        `handler` - Handler for the result of this call.
      Returns:

    - #### georadiusbymemberObservable

          @Deprecated
          public rx.Observable<JsonArray> georadiusbymemberObservable(String key,
                                                                                  String member,
                                                                                  double radius,
                                                                                  GeoUnit unit)

      Deprecated. use `rxGeoradiusbymember(java.lang.String, java.lang.String, double, io.vertx.redis.op.GeoUnit)` instead
      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
      Returns:

    - #### rxGeoradiusbymember

          public rx.Single<JsonArray> rxGeoradiusbymember(String key,
                                                          String member,
                                                          double radius,
                                                          GeoUnit unit)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
      Returns:

    - #### georadiusbymemberWithOptions

          public RedisClient georadiusbymemberWithOptions(String key,
                                                          String member,
                                                          double radius,
                                                          GeoUnit unit,
                                                          GeoRadiusOptions options,
                                                          Handler<AsyncResult<JsonArray>> handler)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
        `handler` - Handler for the result of this call.
      Returns:

    - #### georadiusbymemberWithOptionsObservable

          @Deprecated
          public rx.Observable<JsonArray> georadiusbymemberWithOptionsObservable(String key,
                                                                                             String member,
                                                                                             double radius,
                                                                                             GeoUnit unit,
                                                                                             GeoRadiusOptions options)

      Deprecated. use `rxGeoradiusbymemberWithOptions(java.lang.String, java.lang.String, double, io.vertx.redis.op.GeoUnit, io.vertx.redis.op.GeoRadiusOptions)` instead
      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
      Returns:

    - #### rxGeoradiusbymemberWithOptions

          public rx.Single<JsonArray> rxGeoradiusbymemberWithOptions(String key,
                                                                     String member,
                                                                     double radius,
                                                                     GeoUnit unit,
                                                                     GeoRadiusOptions options)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
      Returns:

    - #### clientReply

          public RedisClient clientReply(ClientReplyOptions options,
                                         Handler<AsyncResult<String>> handler)

      Instruct the server whether to reply to commands.
      Parameters:
        `options` -
        `handler` -
      Returns:

    - #### clientReplyObservable

          @Deprecated
          public rx.Observable<String> clientReplyObservable(ClientReplyOptions options)

      Deprecated. use `rxClientReply(io.vertx.redis.op.ClientReplyOptions)` instead
      Instruct the server whether to reply to commands.
      Parameters:
        `options` -
      Returns:

    - #### rxClientReply

          public rx.Single<String> rxClientReply(ClientReplyOptions options)

      Instruct the server whether to reply to commands.
      Parameters:
        `options` -
      Returns:

    - #### hstrlen

          public RedisClient hstrlen(String key,
                                     String field,
                                     Handler<AsyncResult<Long>> handler)

      Get the length of the value of a hash field.
      Parameters:
        `key` - Key String
        `field` - field
        `handler` -
      Returns:

    - #### hstrlenObservable

          @Deprecated
          public rx.Observable<Long> hstrlenObservable(String key,
                                                                   String field)

      Deprecated. use `rxHstrlen(java.lang.String, java.lang.String)` instead
      Get the length of the value of a hash field.
      Parameters:
        `key` - Key String
        `field` - field
      Returns:

    - #### rxHstrlen

          public rx.Single<Long> rxHstrlen(String key,
                                           String field)

      Get the length of the value of a hash field.
      Parameters:
        `key` - Key String
        `field` - field
      Returns:

    - #### touch

          public RedisClient touch(String key,
                                   Handler<AsyncResult<Long>> handler)

      Alters the last access time of a key(s). Returns the number of existing keys specified.
      Parameters:
        `key` - Key String
        `handler` -
      Returns:

    - #### touchObservable

          @Deprecated
          public rx.Observable<Long> touchObservable(String key)

      Deprecated. use `rxTouch(java.lang.String)` instead
      Alters the last access time of a key(s). Returns the number of existing keys specified.
      Parameters:
        `key` - Key String
      Returns:

    - #### rxTouch

          public rx.Single<Long> rxTouch(String key)

      Alters the last access time of a key(s). Returns the number of existing keys specified.
      Parameters:
        `key` - Key String
      Returns:

    - #### touchMany

          public RedisClient touchMany(List<String> keys,
                                       Handler<AsyncResult<Long>> handler)

      Alters the last access time of a key(s). Returns the number of existing keys specified.
      Parameters:
        `keys` - list of keys
        `handler` -
      Returns:

    - #### touchManyObservable

          @Deprecated
          public rx.Observable<Long> touchManyObservable(List<String> keys)

      Deprecated. use `rxTouchMany(java.util.List<java.lang.String>)` instead
      Alters the last access time of a key(s). Returns the number of existing keys specified.
      Parameters:
        `keys` - list of keys
      Returns:

    - #### rxTouchMany

          public rx.Single<Long> rxTouchMany(List<String> keys)

      Alters the last access time of a key(s). Returns the number of existing keys specified.
      Parameters:
        `keys` - list of keys
      Returns:

    - #### scriptDebug

          public RedisClient scriptDebug(ScriptDebugOptions scriptDebugOptions,
                                         Handler<AsyncResult<String>> handler)

      Set the debug mode for executed scripts.
      Parameters:
        `scriptDebugOptions` - the option
        `handler` -
      Returns:

    - #### scriptDebugObservable

          @Deprecated
          public rx.Observable<String> scriptDebugObservable(ScriptDebugOptions scriptDebugOptions)

      Deprecated. use `rxScriptDebug(io.vertx.redis.op.ScriptDebugOptions)` instead
      Set the debug mode for executed scripts.
      Parameters:
        `scriptDebugOptions` - the option
      Returns:

    - #### rxScriptDebug

          public rx.Single<String> rxScriptDebug(ScriptDebugOptions scriptDebugOptions)

      Set the debug mode for executed scripts.
      Parameters:
        `scriptDebugOptions` - the option
      Returns:

    - #### bitfield

          public RedisClient bitfield(String key,
                                      BitFieldOptions bitFieldOptions,
                                      Handler<AsyncResult<JsonArray>> handler)

      Perform arbitrary bitfield integer operations on strings.
      Parameters:
        `key` - Key string
        `bitFieldOptions` -
        `handler` -
      Returns:

    - #### bitfieldObservable

          @Deprecated
          public rx.Observable<JsonArray> bitfieldObservable(String key,
                                                                         BitFieldOptions bitFieldOptions)

      Deprecated. use `rxBitfield(java.lang.String, io.vertx.redis.op.BitFieldOptions)` instead
      Perform arbitrary bitfield integer operations on strings.
      Parameters:
        `key` - Key string
        `bitFieldOptions` -
      Returns:

    - #### rxBitfield

          public rx.Single<JsonArray> rxBitfield(String key,
                                                 BitFieldOptions bitFieldOptions)

      Perform arbitrary bitfield integer operations on strings.
      Parameters:
        `key` - Key string
        `bitFieldOptions` -
      Returns:

    - #### bitfieldWithOverflow

          public RedisClient bitfieldWithOverflow(String key,
                                                  BitFieldOptions commands,
                                                  BitFieldOverflowOptions overflow,
                                                  Handler<AsyncResult<JsonArray>> handler)

      Perform arbitrary bitfield integer operations on strings.
      Parameters:
        `key` - Key string
        `commands` -
        `overflow` -
        `handler` -
      Returns:

    - #### bitfieldWithOverflowObservable

          @Deprecated
          public rx.Observable<JsonArray> bitfieldWithOverflowObservable(String key,
                                                                                     BitFieldOptions commands,
                                                                                     BitFieldOverflowOptions overflow)

      Deprecated. use `rxBitfieldWithOverflow(java.lang.String, io.vertx.redis.op.BitFieldOptions, io.vertx.redis.op.BitFieldOverflowOptions)` instead
      Perform arbitrary bitfield integer operations on strings.
      Parameters:
        `key` - Key string
        `commands` -
        `overflow` -
      Returns:

    - #### rxBitfieldWithOverflow

          public rx.Single<JsonArray> rxBitfieldWithOverflow(String key,
                                                             BitFieldOptions commands,
                                                             BitFieldOverflowOptions overflow)

      Perform arbitrary bitfield integer operations on strings.
      Parameters:
        `key` - Key string
        `commands` -
        `overflow` -
      Returns:

    - #### newInstance

          public static RedisClient newInstance(RedisClient arg)

Copyright © 2017. All rights reserved.