io.vertx.redis

## Interface RedisClient

-     public interface RedisClient

- - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default 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` | `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<Void>> 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` | `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` | `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, JsonObject 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(List<String> keys, Handler<AsyncResult<Long>> handler)` Delete a key
    `RedisClient` | `discard(Handler<AsyncResult<String>> handler)` Discard all commands issued after MULTI
    `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<Void>> handler)` Execute a Lua script server side
    `RedisClient` | `evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<Void>> handler)` Execute a Lua script server side
    `RedisClient` | `exec(Handler<AsyncResult<Void>> handler)` Execute all commands issued after MULTI
    `RedisClient` | `exists(String key, Handler<AsyncResult<Long>> handler)` Determine if a key exists
    `RedisClient` | `expire(String key, int 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` | `get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisClient` | `getBinary(String key, Handler<AsyncResult<String>> 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, Map<String,String> 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` | `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(Map<String,String> keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisClient` | `msetnx(Map<String,String> keyvals, Handler<AsyncResult<Long>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `RedisClient` | `multi(Handler<AsyncResult<String>> handler)` Mark the start of a transaction block
    `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<Void>> handler)` Listen for messages published to channels matching the given pattern
    `RedisClient` | `psubscribeMany(List<String> patterns, Handler<AsyncResult<Void>> 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<Void>> handler)` Incrementally iterate the keys space
    `RedisClient` | `scard(String key, Handler<AsyncResult<Long>> handler)` Get the number of members in a set
    `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, String value, Handler<AsyncResult<Void>> handler)` Set the binary string value of a key - without encoding as utf-8
    `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<Void>> 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<String>> handler)` Remove and return random members from a set
    `RedisClient` | `srandmember(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<Void>> 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(List<String> channels, Handler<AsyncResult<Void>> 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` | `sync(Handler<AsyncResult<Void>> handler)` Internal command used for replication
    `RedisClient` | `time(Handler<AsyncResult<JsonArray>> handler)` Return the current server time
    `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` | `unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler)` Stop listening for messages posted to the given channels
    `RedisClient` | `unwatch(Handler<AsyncResult<String>> handler)` Forget about all watched keys
    `RedisClient` | `watch(List<String> keys, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `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<Void>> 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,
                                    JsonObject 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:
        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:
        1.0.0 group: connection

    - #### bgrewriteaof

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

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

    - #### bgsave

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

      Asynchronously save the dataset to disk
      Since:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        2.0.0 group: list

    - #### brpoplpush

          RedisClient brpoplpush(String key,
                                 String destkey,
                                 int seconds,
                                 Handler<AsyncResult<Void>> 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:
        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:
        2.4.0 group: server

    - #### clientList

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

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

    - #### clientGetname

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

      Get the current connection name
      Since:
        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:
        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:
        2.6.9 group: server

    - #### clusterSlots

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

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

    - #### command

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

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

    - #### commandCount

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

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

    - #### commandGetkeys

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

      Extract keys given a full Redis command
      Since:
        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:
        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:
        2.0.0 group: server

    - #### configRewrite

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

      Rewrite the configuration file with the in memory configuration
      Since:
        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:
        2.0.0 group: server

    - #### configResetstat

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

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

    - #### dbsize

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

      Return the number of keys in the selected database
      Since:
        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:
        1.0.0 group: server

    - #### debugSegfault

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

      Make the server crash
      Since:
        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:
        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:
        1.0.0 group: string

    - #### del

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

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

    - #### discard

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

      Discard all commands issued after MULTI
      Since:
        2.0.0 group: transactions

    - #### 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:
        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:
        1.0.0 group: connection

    - #### eval

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

      Execute a Lua script server side
      Parameters:
        `script` - Lua script to evaluate
        `keys` - List of keys
        `args` - List of argument values
        `handler` - Handler for the result of this call.
      Since:
        2.6.0 group: scripting

    - #### evalsha

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

      Execute a Lua script server side
      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:
        2.6.0 group: scripting

    - #### exec

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

      Execute all commands issued after MULTI
      Since:
        1.2.0 group: transactions

    - #### 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:
        1.0.0 group: generic

    - #### expire

          RedisClient expire(String key,
                             int 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:
        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:
        1.2.0 group: generic

    - #### flushall

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

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

    - #### flushdb

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

      Remove all keys from the current database
      Since:
        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:
        1.0.0 group: string

    - #### getBinary

          RedisClient getBinary(String key,
                                Handler<AsyncResult<String>> 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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        2.0.0 group: hash

    - #### hmset

          RedisClient hmset(String key,
                            Map<String,String> 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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        2.6.0 group: generic

    - #### monitor

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

      Listen for all requests received by the server in real time
      Since:
        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:
        1.0.0 group: generic

    - #### mset

          RedisClient mset(Map<String,String> 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:
        1.0.1 group: string

    - #### msetnx

          RedisClient msetnx(Map<String,String> 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:
        1.0.1 group: string

    - #### multi

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

      Mark the start of a transaction block
      Since:
        1.2.0 group: transactions

    - #### 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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        2.8.9 group: hyperloglog

    - #### ping

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

      Ping the server
      Since:
        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:
        2.6.0 group: string

    - #### psubscribe

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

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

    - #### psubscribeMany

          RedisClient psubscribeMany(List<String> patterns,
                                     Handler<AsyncResult<Void>> 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:
        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:
        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:
        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:
        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:
        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:
        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:
        2.0.0 group: pubsub

    - #### randomkey

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

      Return a random key from the keyspace
      Since:
        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:
        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:
        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:
        2.6.0 group: generic

    - #### role

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

      Return the role of the instance in the context of replication
      Since:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        1.0.0 group: set

    - #### save

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

      Synchronously save the dataset to disk
      Since:
        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:
        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:
        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:
        2.6.0 group: scripting

    - #### scriptFlush

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

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

    - #### scriptKill

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

      Kill the script currently in execution.
      Since:
        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:
        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:
        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:
        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:
        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:
        1.0.0 group: string

    - #### setWithOptions

          RedisClient setWithOptions(String key,
                                     String 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:
        1.0.0 group: string

    - #### setBinary

          RedisClient setBinary(String key,
                                String 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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        1.0.0 group: set

    - #### spopMany

          RedisClient spopMany(String key,
                               int count,
                               Handler<AsyncResult<String>> 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:
        1.0.0 group: set

    - #### srandmember

          RedisClient srandmember(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:
        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:
        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:
        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:
        2.2.0 group: string

    - #### subscribe

          RedisClient subscribe(List<String> channels,
                                Handler<AsyncResult<Void>> 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:
        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:
        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:
        1.0.0 group: set

    - #### sync

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

      Internal command used for replication
      Since:
        1.0.0 group: server

    - #### time

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

      Return the current server time
      Since:
        2.6.0 group: server

    - #### 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:
        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:
        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:
        2.0.0 group: pubsub

    - #### unwatch

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

      Forget about all watched keys
      Since:
        2.2.0 group: transactions

    - #### watch

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

      Watch the given keys to determine execution of the MULTI/EXEC block
      Parameters:
        `keys` - List of keys to watch
        `handler` - Handler for the result of this call.
      Since:
        2.2.0 group: transactions

    - #### 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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        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:
        2.0.0 group: sorted_set

    - #### scan

          RedisClient scan(String cursor,
                           ScanOptions options,
                           Handler<AsyncResult<Void>> handler)

      Incrementally iterate the keys space
      Parameters:
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Since:
        2.8.0 group: generic

    - #### sscan

          RedisClient sscan(String key,
                            String cursor,
                            ScanOptions options,
                            Handler<AsyncResult<Void>> handler)

      Incrementally iterate Set elements
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Since:
        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:
        2.8.0 group: hash

    - #### zscan

          RedisClient zscan(String key,
                            String cursor,
                            ScanOptions options,
                            Handler<AsyncResult<Void>> 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:
        2.8.0 group: sorted_set

Copyright © 2015. All Rights Reserved.