io.vertx.redis

## Interface RedisClient

-     public interface RedisClient

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default 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
    `RedisClient` | `auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `RedisClient` | `bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `RedisClient` | `bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `RedisClient` | `bitcount(String key, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisClient` | `bitcountRange(String key, long start, long end, Handler<AsyncResult<Long>> handler)` Count set bits in a string
    `RedisClient` | `bitfield(String key, BitFieldOptions bitFieldOptions, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | `bitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow, Handler<AsyncResult<JsonArray>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisClient` | `bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Perform bitwise operations between strings
    `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.
    `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
    `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
    `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
    `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
    `RedisClient` | `clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `RedisClient` | `clientKill(KillFilter filter, Handler<AsyncResult<Long>> handler)` Kill the connection of a client
    `RedisClient` | `clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `RedisClient` | `clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `RedisClient` | `clientReply(ClientReplyOptions options, Handler<AsyncResult<String>> handler)` Instruct the server whether to reply to commands.
    `RedisClient` | `clientSetname(String name, Handler<AsyncResult<String>> handler)` Set the current connection name
    `void` | `close(Handler<AsyncResult<Void>> handler)` Close the client - when it is fully closed the handler will be called.
    `RedisClient` | `clusterAddslots(List<Long> slots, Handler<AsyncResult<Void>> handler)` Assign new hash slots to receiving node.
    `RedisClient` | `clusterCountFailureReports(String nodeId, Handler<AsyncResult<Long>> handler)` Return the number of failure reports active for a given node.
    `RedisClient` | `clusterCountkeysinslot(long slot, Handler<AsyncResult<Long>> handler)` Return the number of local keys in the specified hash slot.
    `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.
    `RedisClient` | `clusterFailover(Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisClient` | `clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<Void>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisClient` | `clusterForget(String nodeId, Handler<AsyncResult<Void>> handler)` Remove a node from the nodes table.
    `RedisClient` | `clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler)` Return local key names in the specified hash slot.
    `RedisClient` | `clusterInfo(Handler<AsyncResult<JsonArray>> handler)` Provides info about Redis Cluster node state.
    `RedisClient` | `clusterKeyslot(String key, Handler<AsyncResult<Long>> handler)` Returns the hash slot of the specified key.
    `RedisClient` | `clusterMeet(String ip, long port, Handler<AsyncResult<Void>> handler)` Force a node cluster to handshake with another node.
    `RedisClient` | `clusterNodes(Handler<AsyncResult<JsonArray>> handler)` Get Cluster config for the node.
    `RedisClient` | `clusterReplicate(String nodeId, Handler<AsyncResult<Void>> handler)` Reconfigure a node as a slave of the specified master node.
    `RedisClient` | `clusterReset(Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `RedisClient` | `clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<Void>> handler)` Reset a Redis Cluster node.
    `RedisClient` | `clusterSaveconfig(Handler<AsyncResult<Void>> handler)` Forces the node to save cluster state on disk.
    `RedisClient` | `clusterSetConfigEpoch(long epoch, Handler<AsyncResult<Void>> handler)` Set the configuration epoch in a new node.
    `RedisClient` | `clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | `clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<Void>> handler)` Bind an hash slot to a specific node.
    `RedisClient` | `clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler)` List slave nodes of the specified master node.
    `RedisClient` | `clusterSlots(Handler<AsyncResult<JsonArray>> handler)` Get array of Cluster slot to node mappings
    `RedisClient` | `command(Handler<AsyncResult<JsonArray>> handler)` Get array of Redis command details
    `RedisClient` | `commandCount(Handler<AsyncResult<Long>> handler)` Get total number of Redis commands
    `RedisClient` | `commandGetkeys(Handler<AsyncResult<JsonArray>> handler)` Extract keys given a full Redis command
    `RedisClient` | `commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler)` Get array of specific Redis command details
    `RedisClient` | `configGet(String parameter, Handler<AsyncResult<JsonArray>> handler)` Get the value of a configuration parameter
    `RedisClient` | `configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `RedisClient` | `configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `RedisClient` | `configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
    `static RedisClient` | `create(Vertx vertx)`
    `static RedisClient` | `create(Vertx vertx, JsonObject config)` Deprecated. For type safety please use `create(Vertx, RedisOptions)`.
    `static RedisClient` | `create(Vertx vertx, RedisOptions config)`
    `RedisClient` | `dbsize(Handler<AsyncResult<Long>> handler)` Return the number of keys in the selected database
    `RedisClient` | `debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `RedisClient` | `debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `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
    `RedisClient` | `del(String key, Handler<AsyncResult<Long>> handler)` Delete a key
    `RedisClient` | `delMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete many keys
    `RedisClient` | `dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisClient` | `echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `RedisClient` | `eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | `evalScript(Script script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | `evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler)` Execute a Lua script server side.
    `RedisClient` | `exists(String key, Handler<AsyncResult<Long>> handler)` Determine if a key exists
    `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
    `RedisClient` | `flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `RedisClient` | `flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `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.
    `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.
    `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.
    `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).
    `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.
    `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.
    `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.
    `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).
    `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
    `RedisClient` | `getbit(String key, long offset, Handler<AsyncResult<Long>> handler)` Returns the bit value at offset in the string value stored at key
    `RedisClient` | `getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `RedisClient` | `getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
    `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
    `RedisClient` | `hexists(String key, String field, Handler<AsyncResult<Long>> handler)` Determine if a hash field exists
    `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
    `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
    `RedisClient` | `hkeys(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the fields in a hash
    `RedisClient` | `hlen(String key, Handler<AsyncResult<Long>> handler)` Get the number of fields in a hash
    `RedisClient` | `hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler)` Get the values of all the given hash fields
    `RedisClient` | `hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `RedisClient` | `hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate hash fields and associated values
    `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
    `RedisClient` | `hstrlen(String key, String field, Handler<AsyncResult<Long>> handler)` Get the length of the value of a hash field.
    `RedisClient` | `hvals(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the values in a hash
    `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
    `RedisClient` | `info(Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisClient` | `infoSection(String section, Handler<AsyncResult<JsonObject>> handler)` Get information and statistics about the server
    `RedisClient` | `keys(String pattern, Handler<AsyncResult<JsonArray>> handler)` Find all keys matching the given pattern
    `RedisClient` | `lastsave(Handler<AsyncResult<Long>> handler)` Get the UNIX time stamp of the last successful save to disk
    `RedisClient` | `lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
    `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
    `RedisClient` | `llen(String key, Handler<AsyncResult<Long>> handler)` Get the length of a list
    `RedisClient` | `lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `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
    `RedisClient` | `lpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Prepend a value to a list, only if the list exists
    `RedisClient` | `lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler)` Get a range of elements from a list
    `RedisClient` | `lrem(String key, long count, String value, Handler<AsyncResult<Long>> handler)` Remove elements from a list
    `RedisClient` | `lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
    `RedisClient` | `ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
    `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
    `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.
    `RedisClient` | `monitor(Handler<AsyncResult<Void>> handler)` Listen for all requests received by the server in real time
    `RedisClient` | `move(String key, int destdb, Handler<AsyncResult<Long>> handler)` Move a key to another database
    `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
    `RedisClient` | `object(String key, ObjectCmd cmd, Handler<AsyncResult<Void>> handler)` Inspect the internals of Redis objects
    `RedisClient` | `persist(String key, Handler<AsyncResult<Long>> handler)` Remove the expiration from a key
    `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
    `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.
    `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).
    `RedisClient` | `pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisClient` | `ping(Handler<AsyncResult<String>> handler)` Ping the server
    `RedisClient` | `psetex(String key, long millis, String value, Handler<AsyncResult<Void>> handler)` Set the value and expiration in milliseconds of a key
    `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
    `RedisClient` | `pttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key in milliseconds
    `RedisClient` | `publish(String channel, String message, Handler<AsyncResult<Long>> handler)` Post a message to a channel
    `RedisClient` | `pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisClient` | `pubsubNumpat(Handler<AsyncResult<Long>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisClient` | `pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisClient` | `punsubscribe(List<String> patterns, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to channels matching the given patterns
    `RedisClient` | `randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `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
    `RedisClient` | `restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisClient` | `role(Handler<AsyncResult<JsonArray>> handler)` Return the role of the instance in the context of replication
    `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
    `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
    `RedisClient` | `rpushx(String key, String value, Handler<AsyncResult<Long>> handler)` Append a value to a list, only if the list exists
    `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
    `RedisClient` | `save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `RedisClient` | `scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate the keys space
    `RedisClient` | `scard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a set
    `RedisClient` | `scriptDebug(ScriptDebugOptions scriptDebugOptions, Handler<AsyncResult<String>> handler)` Set the debug mode for executed scripts.
    `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.
    `RedisClient` | `scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `RedisClient` | `scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `RedisClient` | `scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `RedisClient` | `sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler)` Subtract multiple sets
    `RedisClient` | `sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<Long>> handler)` Subtract multiple sets and store the resulting set in a key
    `RedisClient` | `select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
    `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
    `RedisClient` | `setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<Void>> handler)` Set the string value of a key
    `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
    `RedisClient` | `setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
    `RedisClient` | `setnx(String key, String value, Handler<AsyncResult<Long>> handler)` Set the value of a key, only if the key does not exist
    `RedisClient` | `setrange(String key, int offset, String value, Handler<AsyncResult<Long>> handler)` Overwrite part of a string at key starting at the specified offset
    `RedisClient` | `setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisClient` | `sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Intersect multiple sets
    `RedisClient` | `sinterstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Intersect multiple sets and store the resulting set in a key
    `RedisClient` | `sismember(String key, String member, Handler<AsyncResult<Long>> handler)` Determine if a given value is a member of a set
    `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
    `RedisClient` | `slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler)` Read the Redis slow queries log
    `RedisClient` | `slowlogLen(Handler<AsyncResult<Long>> handler)` Get the length of the Redis slow queries log
    `RedisClient` | `slowlogReset(Handler<AsyncResult<Void>> handler)` Reset the Redis slow queries log
    `RedisClient` | `smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisClient` | `smove(String key, String destkey, String member, Handler<AsyncResult<Long>> handler)` Move a member from one set to another
    `RedisClient` | `sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler)` Sort the elements in a list, set or sorted set
    `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
    `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
    `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
    `RedisClient` | `sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate Set elements
    `RedisClient` | `strlen(String key, Handler<AsyncResult<Long>> handler)` Get the length of the value stored in a key
    `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
    `RedisClient` | `sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler)` Add multiple sets
    `RedisClient` | `sunionstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler)` Add multiple sets and store the resulting set in a key
    `RedisClient` | `swapdb(int index1, int index2, Handler<AsyncResult<String>> handler)` Swaps two Redis databases
    `RedisClient` | `sync(Handler<AsyncResult<Void>> handler)` Internal command used for replication
    `RedisClient` | `time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `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).
    `RedisTransaction` | `transaction()` Return a RedisTransaction instance
    `RedisClient` | `ttl(String key, Handler<AsyncResult<Long>> handler)` Get the time to live for a key
    `RedisClient` | `type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `RedisClient` | `unlink(String key, Handler<AsyncResult<Long>> handler)` Delete a key asynchronously in another thread.
    `RedisClient` | `unlinkMany(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete multiple keys asynchronously in another thread.
    `RedisClient` | `unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to the given channels
    `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.
    `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
    `RedisClient` | `zcard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a sorted set
    `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
    `RedisClient` | `zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
    `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
    `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
    `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
    `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
    `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
    `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
    `RedisClient` | `zrank(String key, String member, Handler<AsyncResult<Long>> handler)` Determine the index of a member in a sorted set
    `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
    `RedisClient` | `zremrangebylex(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set between the given lexicographical range
    `RedisClient` | `zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given indexes
    `RedisClient` | `zremrangebyscore(String key, String min, String max, Handler<AsyncResult<Long>> handler)` Remove all members in a sorted set within the given scores
    `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
    `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
    `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
    `RedisClient` | `zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler)` Incrementally iterate sorted sets elements and associated scores
    `RedisClient` | `zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
    `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
    `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

- - ### Method Detail

    - #### create

          static RedisClient create(Vertx vertx)

    - #### create

          @Deprecated
          static RedisClient create(Vertx vertx,
                                                JsonObject config)

      Deprecated. For type safety please use `create(Vertx, RedisOptions)`.

    - #### create

          static RedisClient create(Vertx vertx,
                                    RedisOptions config)

    - #### close

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

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

    - #### append

          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.
      Since:
        Redis 2.0.0 group: string

    - #### auth

          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.
      Since:
        Redis 1.0.0 group: connection

    - #### bgrewriteaof

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

      Asynchronously rewrite the append-only file
      Since:
        Redis 1.0.0 group: server

    - #### bgsave

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

      Asynchronously save the dataset to disk
      Since:
        Redis 1.0.0 group: server

    - #### bitcount

          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.
      Since:
        Redis 2.6.0 group: string

    - #### bitcountRange

          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.
      Since:
        Redis 2.6.0 group: string

    - #### bitop

          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.
      Since:
        Redis 2.6.0 group: string

    - #### bitpos

          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.
      Since:
        Redis 2.8.7 group: string

    - #### bitposFrom

          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.
      Since:
        Redis 2.8.7 group: string

    - #### bitposRange

          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.
      Since:
        Redis 2.8.7 group: string

    - #### blpop

          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.
      Since:
        Redis 2.0.0 group: list

    - #### blpopMany

          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.
      Since:
        Redis 2.0.0 group: list

    - #### brpop

          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.
      Since:
        Redis 2.0.0 group: list

    - #### brpopMany

          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.
      Since:
        Redis 2.0.0 group: list

    - #### brpoplpush

          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.
      Since:
        Redis 2.2.0 group: list

    - #### clientKill

          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.
      Since:
        Redis 2.4.0 group: server

    - #### clientList

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

      Get the list of client connections
      Since:
        Redis 2.4.0 group: server

    - #### clientGetname

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

      Get the current connection name
      Since:
        Redis 2.6.9 group: server

    - #### clientPause

          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.
      Since:
        Redis 2.9.50 group: server

    - #### clientSetname

          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.
      Since:
        Redis 2.6.9 group: server

    - #### clusterAddslots

          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.
      Since:
        Redis 3.0.0 group: server

    - #### clusterCountFailureReports

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterCountkeysinslot

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterDelslots

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterDelslotsMany

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterFailover

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterFailOverWithOptions

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterForget

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterGetkeysinslot

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterInfo

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

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

    - #### clusterKeyslot

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterMeet

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterNodes

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

      Get Cluster config for the node.
      Parameters:
        `handler` - Handler for the result of this call.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterReplicate

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterReset

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

      Reset a Redis Cluster node.
      Parameters:
        `handler` - Handler for the result of this call.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterResetWithOptions

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

      Reset a Redis Cluster node.
      Parameters:
        `options` -
        `handler` - Handler for the result of this call.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterSaveconfig

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

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

    - #### clusterSetConfigEpoch

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterSetslot

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterSetslotWithNode

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterSlaves

          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.
      Since:
        Redis 3.0.0 group: cluster

    - #### clusterSlots

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

      Get array of Cluster slot to node mappings
      Since:
        Redis 3.0.0 group: server

    - #### command

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

      Get array of Redis command details
      Since:
        Redis 2.8.13 group: server

    - #### commandCount

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

      Get total number of Redis commands
      Since:
        Redis 2.8.13 group: server

    - #### commandGetkeys

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

      Extract keys given a full Redis command
      Since:
        Redis 2.8.13 group: server

    - #### commandInfo

          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.
      Since:
        Redis 2.8.13 group: server

    - #### configGet

          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.
      Since:
        Redis 2.0.0 group: server

    - #### configRewrite

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

      Rewrite the configuration file with the in memory configuration
      Since:
        Redis 2.8.0 group: server

    - #### configSet

          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.
      Since:
        Redis 2.0.0 group: server

    - #### configResetstat

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

      Reset the stats returned by INFO
      Since:
        Redis 2.0.0 group: server

    - #### dbsize

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

      Return the number of keys in the selected database
      Since:
        Redis 1.0.0 group: server

    - #### debugObject

          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.
      Since:
        Redis 1.0.0 group: server

    - #### debugSegfault

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

      Make the server crash
      Since:
        Redis 1.0.0 group: server

    - #### decr

          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.
      Since:
        Redis 1.0.0 group: string

    - #### decrby

          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.
      Since:
        Redis 1.0.0 group: string

    - #### del

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

      Delete a key
      Parameters:
        `key` - Keys to delete
        `handler` - Handler for the result of this call.
      Since:
        Redis 1.0.0 group: generic

    - #### delMany

          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.
      Since:
        Redis 1.0.0 group: generic

    - #### dump

          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.
      Since:
        Redis 2.6.0 group: generic

    - #### echo

          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.
      Since:
        Redis 1.0.0 group: connection

    - #### eval

          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.
      Since:
        Redis 2.6.0 group: scripting

    - #### evalsha

          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.
      Since:
        Redis 2.6.0 group: scripting

    - #### evalScript

          RedisClient evalScript(Script script,
                                 List<String> keys,
                                 List<String> args,
                                 Handler<AsyncResult<JsonArray>> handler)

      Execute a Lua script server side. This method is a high level wrapper around EVAL and EVALSHA using the latter if possible, falling back to EVAL if the script is not cached by the server yet. According to Redis documentation, executed scripts are guaranteed to be in the script cache of a given execution of a Redis instance forever, which means typically the overhead incurred by optimistically sending EVALSHA is minimal, while improving performance and saving bandwidth compared to using EVAL every time.
      Parameters:
        `script` - Lua script and its SHA1 digest
        `keys` - List of keys
        `args` - List of argument values
        `handler` - Handler for the result of this call. group: scripting
      See Also:
        Redis - Script cache semantics

    - #### exists

          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.
      Since:
        Redis 1.0.0 group: generic

    - #### expire

          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.
      Since:
        Redis 1.0.0 group: generic

    - #### expireat

          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.
      Since:
        Redis 1.2.0 group: generic

    - #### flushall

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

      Remove all keys from all databases
      Since:
        Redis 1.0.0 group: server

    - #### flushdb

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

      Remove all keys from the current database
      Since:
        Redis 1.0.0 group: server

    - #### get

          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.
      Since:
        Redis 1.0.0 group: string

    - #### getBinary

          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.
      Since:
        Redis 1.0.0 group: string

    - #### getbit

          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.
      Since:
        Redis 2.2.0 group: string

    - #### getrange

          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.
      Since:
        Redis 2.4.0 group: string

    - #### getset

          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.
      Since:
        Redis 1.0.0 group: string

    - #### hdel

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hdelMany

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hexists

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hget

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hgetall

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hincrby

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hincrbyfloat

          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.
      Since:
        Redis 2.6.0 group: hash

    - #### hkeys

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hlen

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hmget

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hmset

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hset

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hsetnx

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### hvals

          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.
      Since:
        Redis 2.0.0 group: hash

    - #### incr

          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.
      Since:
        Redis 1.0.0 group: string

    - #### incrby

          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.
      Since:
        Redis 1.0.0 group: string

    - #### incrbyfloat

          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.
      Since:
        Redis 2.6.0 group: string

    - #### info

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

      Get information and statistics about the server
      Parameters:
        `handler` - Handler for the result of this call.
      Since:
        Redis 1.0.0 group: server

    - #### infoSection

          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.
      Since:
        Redis 1.0.0 group: server

    - #### keys

          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.
      Since:
        Redis 1.0.0 group: generic

    - #### lastsave

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

      Get the UNIX time stamp of the last successful save to disk
      Since:
        Redis 1.0.0 group: server

    - #### lindex

          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.
      Since:
        Redis 1.0.0 group: list

    - #### linsert

          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.
      Since:
        Redis 2.2.0 group: list

    - #### llen

          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.
      Since:
        Redis 1.0.0 group: list

    - #### lpop

          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.
      Since:
        Redis 1.0.0 group: list

    - #### lpushMany

          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.
      Since:
        Redis 1.0.0 group: list

    - #### lpush

          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.
      Since:
        Redis 1.0.0 group: list

    - #### lpushx

          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.
      Since:
        Redis 2.2.0 group: list

    - #### lrange

          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.
      Since:
        Redis 1.0.0 group: list

    - #### lrem

          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.
      Since:
        Redis 1.0.0 group: list

    - #### lset

          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.
      Since:
        Redis 1.0.0 group: list

    - #### ltrim

          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.
      Since:
        Redis 1.0.0 group: list

    - #### mget

          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.
      Since:
        Redis 1.0.0 group: string

    - #### mgetMany

          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.
      Since:
        Redis 1.0.0 group: string

    - #### migrate

          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
        `options` - Migrate options
        `handler` - Handler for the result of this call.
      Since:
        Redis 2.6.0 group: generic

    - #### monitor

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

      Listen for all requests received by the server in real time
      Since:
        Redis 1.0.0 group: server

    - #### move

          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.
      Since:
        Redis 1.0.0 group: generic

    - #### mset

          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.
      Since:
        Redis 1.0.1 group: string

    - #### msetnx

          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.
      Since:
        Redis 1.0.1 group: string

    - #### object

          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.
      Since:
        Redis 2.2.3 group: generic

    - #### persist

          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.
      Since:
        Redis 2.2.0 group: generic

    - #### pexpire

          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.
      Since:
        Redis 2.6.0 group: generic

    - #### pexpireat

          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.
      Since:
        Redis 2.6.0 group: generic

    - #### pfadd

          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.
      Since:
        Redis 2.8.9 group: hyperloglog

    - #### pfaddMany

          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.
      Since:
        Redis 2.8.9 group: hyperloglog

    - #### pfcount

          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.
      Since:
        Redis 2.8.9 group: hyperloglog

    - #### pfcountMany

          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.
      Since:
        Redis 2.8.9 group: hyperloglog

    - #### pfmerge

          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.
      Since:
        Redis 2.8.9 group: hyperloglog

    - #### ping

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

      Ping the server
      Since:
        Redis 1.0.0 group: connection

    - #### psetex

          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.
      Since:
        Redis 2.6.0 group: string

    - #### psubscribe

          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.
      Since:
        Redis 2.0.0 group: pubsub

    - #### psubscribeMany

          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.
      Since:
        Redis 2.0.0 group: pubsub

    - #### pubsubChannels

          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.
      Since:
        Redis 2.8.0 group: pubsub

    - #### pubsubNumsub

          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.
      Since:
        Redis 2.8.0 group: pubsub

    - #### pubsubNumpat

          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.
      Since:
        Redis 2.8.0 group: pubsub

    - #### pttl

          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.
      Since:
        Redis 2.6.0 group: generic

    - #### publish

          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.
      Since:
        Redis 2.0.0 group: pubsub

    - #### punsubscribe

          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.
      Since:
        Redis 2.0.0 group: pubsub

    - #### randomkey

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

      Return a random key from the keyspace
      Since:
        Redis 1.0.0 group: generic

    - #### rename

          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.
      Since:
        Redis 1.0.0 group: generic

    - #### renamenx

          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.
      Since:
        Redis 1.0.0 group: generic

    - #### restore

          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.
      Since:
        Redis 2.6.0 group: generic

    - #### role

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

      Return the role of the instance in the context of replication
      Since:
        Redis 2.8.12 group: server

    - #### rpop

          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.
      Since:
        Redis 1.0.0 group: list

    - #### rpoplpush

          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.
      Since:
        Redis 1.2.0 group: list

    - #### rpushMany

          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.
      Since:
        Redis 1.0.0 group: list

    - #### rpush

          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.
      Since:
        Redis 1.0.0 group: list

    - #### rpushx

          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.
      Since:
        Redis 2.2.0 group: list

    - #### sadd

          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.
      Since:
        Redis 1.0.0 group: set

    - #### saddMany

          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.
      Since:
        Redis 1.0.0 group: set

    - #### save

          RedisClient save(Handler<AsyncResult<String>> handler)

      Synchronously save the dataset to disk
      Since:
        Redis 1.0.0 group: server

    - #### scard

          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.
      Since:
        Redis 1.0.0 group: set

    - #### scriptExists

          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.
      Since:
        Redis 2.6.0 group: scripting

    - #### scriptExistsMany

          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.
      Since:
        Redis 2.6.0 group: scripting

    - #### scriptFlush

          RedisClient scriptFlush(Handler<AsyncResult<String>> handler)

      Remove all the scripts from the script cache.
      Since:
        Redis 2.6.0 group: scripting

    - #### scriptKill

          RedisClient scriptKill(Handler<AsyncResult<String>> handler)

      Kill the script currently in execution.
      Since:
        Redis 2.6.0 group: scripting

    - #### scriptLoad

          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.
      Since:
        Redis 2.6.0 group: scripting

    - #### sdiff

          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.
      Since:
        Redis 1.0.0 group: set

    - #### sdiffstore

          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.
      Since:
        Redis 1.0.0 group: set

    - #### select

          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.
      Since:
        Redis 1.0.0 group: connection

    - #### set

          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.
      Since:
        Redis 1.0.0 group: string

    - #### setWithOptions

          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.
      Since:
        Redis 1.0.0 group: string

    - #### setBinary

          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.
      Since:
        Redis 1.0.0 group: string

    - #### setBinaryWithOptions

          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.
      Since:
        Redis 1.0.0 group: string

    - #### setbit

          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.
      Since:
        Redis 2.2.0 group: string

    - #### setex

          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.
      Since:
        Redis 2.0.0 group: string

    - #### setnx

          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.
      Since:
        Redis 1.0.0 group: string

    - #### setrange

          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.
      Since:
        Redis 2.2.0 group: string

    - #### sinter

          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.
      Since:
        Redis 1.0.0 group: set

    - #### sinterstore

          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.
      Since:
        Redis 1.0.0 group: set

    - #### sismember

          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.
      Since:
        Redis 1.0.0 group: set

    - #### slaveof

          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.
      Since:
        Redis 1.0.0 group: server

    - #### slaveofNoone

          RedisClient slaveofNoone(Handler<AsyncResult<String>> handler)

      Make this server a master
      Parameters:
        `handler` - Handler for the result of this call.
      Since:
        Redis 1.0.0 group: server

    - #### slowlogGet

          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.
      Since:
        Redis 2.2.12 group: server

    - #### slowlogLen

          RedisClient slowlogLen(Handler<AsyncResult<Long>> handler)

      Get the length of the Redis slow queries log
      Parameters:
        `handler` - Handler for the result of this call.
      Since:
        Redis 2.2.12 group: server

    - #### slowlogReset

          RedisClient slowlogReset(Handler<AsyncResult<Void>> handler)

      Reset the Redis slow queries log
      Parameters:
        `handler` - Handler for the result of this call.
      Since:
        Redis 2.2.12 group: server

    - #### smembers

          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.
      Since:
        Redis 1.0.0 group: set

    - #### smove

          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.
      Since:
        Redis 1.0.0 group: set

    - #### sort

          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.
      Since:
        Redis 1.0.0 group: generic

    - #### spop

          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.
      Since:
        Redis 1.0.0 group: set

    - #### spopMany

          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.
      Since:
        Redis 1.0.0 group: set

    - #### srandmember

          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.
      Since:
        Redis 1.0.0 group: set

    - #### srandmemberCount

          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.
      Since:
        Redis 1.0.0 group: set

    - #### srem

          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.
      Since:
        Redis 1.0.0 group: set

    - #### sremMany

          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.
      Since:
        Redis 1.0.0 group: set

    - #### strlen

          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.
      Since:
        Redis 2.2.0 group: string

    - #### subscribe

          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.
      Since:
        Redis 2.0.0 group: pubsub

    - #### subscribeMany

          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.
      Since:
        Redis 2.0.0 group: pubsub

    - #### sunion

          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.
      Since:
        Redis 1.0.0 group: set

    - #### sunionstore

          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.
      Since:
        Redis 1.0.0 group: set

    - #### sync

          RedisClient sync(Handler<AsyncResult<Void>> handler)

      Internal command used for replication
      Since:
        Redis 1.0.0 group: server

    - #### time

          RedisClient time(Handler<AsyncResult<JsonArray>> handler)

      Return the current server time
      Since:
        Redis 2.6.0 group: server

    - #### transaction

          RedisTransaction transaction()

      Return a RedisTransaction instance
      Returns:
        transaction instance

    - #### ttl

          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.
      Since:
        Redis 1.0.0 group: generic

    - #### type

          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.
      Since:
        Redis 1.0.0 group: generic

    - #### unsubscribe

          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.
      Since:
        Redis 2.0.0 group: pubsub

    - #### wait

          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.
      Since:
        Redis 3.0.0 group: generic

    - #### zadd

          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.
      Since:
        Redis 1.2.0 group: sorted_set

    - #### zaddMany

          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.
      Since:
        Redis 1.2.0 group: sorted_set

    - #### zcard

          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.
      Since:
        Redis 1.2.0 group: sorted_set

    - #### zcount

          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.
      Since:
        Redis 2.0.0 group: sorted_set

    - #### zincrby

          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.
      Since:
        Redis 1.2.0 group: sorted_set

    - #### zinterstore

          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.
      Since:
        Redis 2.0.0 group: sorted_set

    - #### zinterstoreWeighed

          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.
      Since:
        Redis 2.0.0 group: sorted_set

    - #### zlexcount

          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.
      Since:
        Redis 2.8.9 group: sorted_set

    - #### zrange

          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.
      Since:
        Redis 1.2.0 group: sorted_set

    - #### zrangeWithOptions

          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.
      Since:
        Redis 1.2.0 group: sorted_set

    - #### zrangebylex

          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.
      Since:
        Redis 2.8.9 group: sorted_set

    - #### zrangebyscore

          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.
      Since:
        Redis 1.0.5 group: sorted_set

    - #### zrank

          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.
      Since:
        Redis 2.0.0 group: sorted_set

    - #### zrem

          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.
      Since:
        Redis 1.2.0 group: sorted_set

    - #### zremMany

          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.
      Since:
        Redis 1.2.0 group: sorted_set

    - #### zremrangebylex

          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.
      Since:
        Redis 2.8.9 group: sorted_set

    - #### zremrangebyrank

          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.
      Since:
        Redis 2.0.0 group: sorted_set

    - #### zremrangebyscore

          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
      Since:
        Redis 1.2.0 group: sorted_set

    - #### zrevrange

          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.
      Since:
        Redis 1.2.0 group: sorted_set

    - #### zrevrangebylex

          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.
      Since:
        Redis 2.8.9 group: sorted_set

    - #### zrevrangebyscore

          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.
      Since:
        Redis 2.2.0 group: sorted_set

    - #### zrevrank

          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.
      Since:
        Redis 2.0.0 group: sorted_set

    - #### zscore

          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.
      Since:
        Redis 1.2.0 group: sorted_set

    - #### zunionstore

          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.
      Since:
        Redis 2.0.0 group: sorted_set

    - #### zunionstoreWeighed

          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.
      Since:
        Redis 2.0.0 group: sorted_set

    - #### scan

          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.
      Since:
        Redis 2.8.0 group: generic

    - #### sscan

          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.
      Since:
        Redis 2.8.0 group: set

    - #### hscan

          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.
      Since:
        Redis 2.8.0 group: hash

    - #### zscan

          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.
      Since:
        Redis 2.8.0 group: sorted_set

    - #### geoadd

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### geoaddMany

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### geohash

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### geohashMany

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### geopos

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### geoposMany

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### geodist

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### geodistWithUnit

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### georadius

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### georadiusWithOptions

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### georadiusbymember

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### georadiusbymemberWithOptions

          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.
      Since:
        Redis 3.2.0 group: geo

    - #### clientReply

          RedisClient clientReply(ClientReplyOptions options,
                                  Handler<AsyncResult<String>> handler)

      Instruct the server whether to reply to commands.
      Since:
        Redis 3.2.0 group: server

    - #### hstrlen

          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
      Since:
        Redis 3.2.0 group: hash

    - #### touch

          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
      Since:
        Redis 3.2.1 group: generic

    - #### touchMany

          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
      Since:
        Redis 3.2.1 group: generic

    - #### scriptDebug

          RedisClient scriptDebug(ScriptDebugOptions scriptDebugOptions,
                                  Handler<AsyncResult<String>> handler)

      Set the debug mode for executed scripts.
      Parameters:
        `scriptDebugOptions` - the option
      Since:
        Redis 3.2.0 group: generic

    - #### bitfield

          RedisClient bitfield(String key,
                               BitFieldOptions bitFieldOptions,
                               Handler<AsyncResult<JsonArray>> handler)

      Perform arbitrary bitfield integer operations on strings.
      Parameters:
        `key` - Key string
      Since:
        Redis 3.2.0 group: string

    - #### bitfieldWithOverflow

          RedisClient bitfieldWithOverflow(String key,
                                           BitFieldOptions commands,
                                           BitFieldOverflowOptions overflow,
                                           Handler<AsyncResult<JsonArray>> handler)

      Perform arbitrary bitfield integer operations on strings.
      Parameters:
        `key` - Key string
      Since:
        Redis 3.2.0 group: string

    - #### unlink

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

      Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
      Parameters:
        `key` - Key to delete
        `handler` - Handler for the result of this call.
      Since:
        Redis 4.0.0 group: generic

    - #### unlinkMany

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

      Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
      Parameters:
        `keys` - List of keys to delete
        `handler` - Handler for the result of this call.
      Since:
        Redis 4.0.0 group: generic

    - #### swapdb

          RedisClient swapdb(int index1,
                             int index2,
                             Handler<AsyncResult<String>> handler)

      Swaps two Redis databases
      Parameters:
        `index1` - index of first database to swap
        `index2` - index of second database to swap
        `handler` - Handler for the result of this call.
      Since:
        Redis 4.0.0 group: connection

Copyright © 2017. All rights reserved.