io.vertx.reactivex.redis

## Class RedisTransaction

- java.lang.Object
- - io.vertx.reactivex.redis.RedisTransaction

-     public class RedisTransaction
      extends Object

  This factory is deprecated use `Redis` instead, or for a typed API `RedisAPI`.

  NOTE: This class has been automatically generated from the `original` non RX-ified interface using Vert.x codegen.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static io.vertx.lang.rx.TypeArg<RedisTransaction>` | `__TYPE_ARG`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `RedisTransaction(Object delegate)`
    `RedisTransaction(RedisTransaction delegate)`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `RedisTransaction` | `append(String key, String value, Handler<AsyncResult<String>> handler)` Append a value to a key
    `RedisTransaction` | `auth(String password, Handler<AsyncResult<String>> handler)` Authenticate to the server
    `RedisTransaction` | `bgrewriteaof(Handler<AsyncResult<String>> handler)` Asynchronously rewrite the append-only file
    `RedisTransaction` | `bgsave(Handler<AsyncResult<String>> handler)` Asynchronously save the dataset to disk
    `RedisTransaction` | `bitcount(String key, Handler<AsyncResult<String>> handler)` Count set bits in a string
    `RedisTransaction` | `bitcountRange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Count set bits in a string
    `RedisTransaction` | `bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Perform bitwise operations between strings
    `RedisTransaction` | `bitpos(String key, int bit, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `RedisTransaction` | `bitposFrom(String key, int bit, int start, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `RedisTransaction` | `bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<String>> handler)` Find first bit set or clear in a string
    `RedisTransaction` | `blpop(String key, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list, or block until one is available
    `RedisTransaction` | `blpopMany(List<String> keys, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the first element in any of the lists, or block until one is available
    `RedisTransaction` | `brpop(String key, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list, or block until one is available
    `RedisTransaction` | `brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler)` Pop a value from a list, push it to another list and return it; or block until one is available
    `RedisTransaction` | `brpopMany(List<String> keys, int seconds, Handler<AsyncResult<String>> handler)` Remove and get the last element in any of the lists, or block until one is available
    `RedisTransaction` | `clientGetname(Handler<AsyncResult<String>> handler)` Get the current connection name
    `RedisTransaction` | `clientKill(KillFilter filter, Handler<AsyncResult<String>> handler)` Kill the connection of a client
    `RedisTransaction` | `clientList(Handler<AsyncResult<String>> handler)` Get the list of client connections
    `RedisTransaction` | `clientPause(long millis, Handler<AsyncResult<String>> handler)` Stop processing commands from clients for some time
    `RedisTransaction` | `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.
    `RedisTransaction` | `clusterAddslots(List<String> slots, Handler<AsyncResult<String>> handler)` Assign new hash slots to receiving node.
    `RedisTransaction` | `clusterCountFailureReports(String nodeId, Handler<AsyncResult<String>> handler)` Return the number of failure reports active for a given node.
    `RedisTransaction` | `clusterCountkeysinslot(long slot, Handler<AsyncResult<String>> handler)` Return the number of local keys in the specified hash slot.
    `RedisTransaction` | `clusterDelslots(long slot, Handler<AsyncResult<String>> handler)` Set hash slots as unbound in receiving node.
    `RedisTransaction` | `clusterDelslotsMany(List<String> slots, Handler<AsyncResult<String>> handler)` Set hash slots as unbound in receiving node.
    `RedisTransaction` | `clusterFailover(Handler<AsyncResult<String>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisTransaction` | `clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<String>> handler)` Forces a slave to perform a manual failover of its master.
    `RedisTransaction` | `clusterForget(String nodeId, Handler<AsyncResult<String>> handler)` Remove a node from the nodes table.
    `RedisTransaction` | `clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<String>> handler)` Return local key names in the specified hash slot.
    `RedisTransaction` | `clusterInfo(Handler<AsyncResult<String>> handler)` Provides info about Redis Cluster node state.
    `RedisTransaction` | `clusterKeyslot(String key, Handler<AsyncResult<String>> handler)` Returns the hash slot of the specified key.
    `RedisTransaction` | `clusterMeet(String ip, long port, Handler<AsyncResult<String>> handler)` Force a node cluster to handshake with another node.
    `RedisTransaction` | `clusterNodes(Handler<AsyncResult<String>> handler)` Get Cluster config for the node.
    `RedisTransaction` | `clusterReplicate(String nodeId, Handler<AsyncResult<String>> handler)` Reconfigure a node as a slave of the specified master node.
    `RedisTransaction` | `clusterReset(Handler<AsyncResult<String>> handler)` Reset a Redis Cluster node.
    `RedisTransaction` | `clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<String>> handler)` Reset a Redis Cluster node.
    `RedisTransaction` | `clusterSaveconfig(Handler<AsyncResult<String>> handler)` Forces the node to save cluster state on disk.
    `RedisTransaction` | `clusterSetConfigEpoch(long epoch, Handler<AsyncResult<String>> handler)` Set the configuration epoch in a new node.
    `RedisTransaction` | `clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<String>> handler)` Bind an hash slot to a specific node.
    `RedisTransaction` | `clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<String>> handler)` Bind an hash slot to a specific node.
    `RedisTransaction` | `clusterSlaves(String nodeId, Handler<AsyncResult<String>> handler)` List slave nodes of the specified master node.
    `RedisTransaction` | `clusterSlots(Handler<AsyncResult<String>> handler)` Get array of Cluster slot to node mappings
    `RedisTransaction` | `command(Handler<AsyncResult<String>> handler)` Get array of Redis command details
    `RedisTransaction` | `commandCount(Handler<AsyncResult<String>> handler)` Get total number of Redis commands
    `RedisTransaction` | `commandGetkeys(Handler<AsyncResult<String>> handler)` Extract keys given a full Redis command
    `RedisTransaction` | `commandInfo(List<String> commands, Handler<AsyncResult<String>> handler)` Get array of specific Redis command details
    `RedisTransaction` | `configGet(String parameter, Handler<AsyncResult<String>> handler)` Get the value of a configuration parameter
    `RedisTransaction` | `configResetstat(Handler<AsyncResult<String>> handler)` Reset the stats returned by INFO
    `RedisTransaction` | `configRewrite(Handler<AsyncResult<String>> handler)` Rewrite the configuration file with the in memory configuration
    `RedisTransaction` | `configSet(String parameter, String value, Handler<AsyncResult<String>> handler)` Set a configuration parameter to the given value
    `RedisTransaction` | `dbsize(Handler<AsyncResult<String>> handler)` Return the number of keys in the selected database
    `RedisTransaction` | `debugObject(String key, Handler<AsyncResult<String>> handler)` Get debugging information about a key
    `RedisTransaction` | `debugSegfault(Handler<AsyncResult<String>> handler)` Make the server crash
    `RedisTransaction` | `decr(String key, Handler<AsyncResult<String>> handler)` Decrement the integer value of a key by one
    `RedisTransaction` | `decrby(String key, long decrement, Handler<AsyncResult<String>> handler)` Decrement the integer value of a key by the given number
    `RedisTransaction` | `del(String key, Handler<AsyncResult<String>> handler)` Delete a key
    `RedisTransaction` | `delMany(List<String> keys, Handler<AsyncResult<String>> handler)` Delete many keys
    `RedisTransaction` | `discard(Handler<AsyncResult<String>> handler)` Discard all commands issued after MULTI
    `RedisTransaction` | `dump(String key, Handler<AsyncResult<String>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisTransaction` | `echo(String message, Handler<AsyncResult<String>> handler)` Echo the given string
    `boolean` | `equals(Object o)`
    `RedisTransaction` | `eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<String>> handler)` Execute a Lua script server side.
    `RedisTransaction` | `evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<String>> handler)` Execute a Lua script server side.
    `RedisTransaction` | `exec(Handler<AsyncResult<JsonArray>> handler)` Execute all commands issued after MULTI
    `RedisTransaction` | `exists(String key, Handler<AsyncResult<String>> handler)` Determine if a key exists
    `RedisTransaction` | `existsMany(List<String> keys, Handler<AsyncResult<String>> handler)` Determine if one or many keys exist
    `RedisTransaction` | `expire(String key, int seconds, Handler<AsyncResult<String>> handler)` Set a key's time to live in seconds
    `RedisTransaction` | `expireat(String key, long seconds, Handler<AsyncResult<String>> handler)` Set the expiration for a key as a UNIX timestamp
    `RedisTransaction` | `flushall(Handler<AsyncResult<String>> handler)` Remove all keys from all databases
    `RedisTransaction` | `flushdb(Handler<AsyncResult<String>> handler)` Remove all keys from the current database
    `RedisTransaction` | `geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<String>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | `geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<String>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisTransaction` | `geodist(String key, String member1, String member2, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisTransaction` | `geodistWithUnit(String key, String member1, String member2, GeoUnit unit, Handler<AsyncResult<String>> handler)` Return the distance between two members in the geospatial index represented by the sorted set.
    `RedisTransaction` | `geohash(String key, String member, Handler<AsyncResult<String>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisTransaction` | `geohashMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `RedisTransaction` | `geopos(String key, String member, Handler<AsyncResult<String>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisTransaction` | `geoposMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `RedisTransaction` | `georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<String>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisTransaction` | `georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<String>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisTransaction` | `georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<String>> handler)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `RedisTransaction` | `georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<String>> handler)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `RedisTransaction` | `get(String key, Handler<AsyncResult<String>> handler)` Get the value of a key
    `RedisTransaction` | `getBinary(String key, Handler<AsyncResult<Buffer>> handler)` Get the value of a key - without decoding as utf-8
    `RedisTransaction` | `getbit(String key, long offset, Handler<AsyncResult<String>> handler)` Returns the bit value at offset in the string value stored at key
    `RedisTransaction` | `getDelegate()`
    `RedisTransaction` | `getrange(String key, long start, long end, Handler<AsyncResult<String>> handler)` Get a substring of the string stored at a key
    `RedisTransaction` | `getset(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key and return its old value
    `int` | `hashCode()`
    `RedisTransaction` | `hdel(String key, String field, Handler<AsyncResult<String>> handler)` Delete one or more hash fields
    `RedisTransaction` | `hdelMany(String key, List<String> fields, Handler<AsyncResult<String>> handler)` Delete one or more hash fields
    `RedisTransaction` | `hexists(String key, String field, Handler<AsyncResult<String>> handler)` Determine if a hash field exists
    `RedisTransaction` | `hget(String key, String field, Handler<AsyncResult<String>> handler)` Get the value of a hash field
    `RedisTransaction` | `hgetall(String key, Handler<AsyncResult<String>> handler)` Get all the fields and values in a hash
    `RedisTransaction` | `hincrby(String key, String field, long increment, Handler<AsyncResult<String>> handler)` Increment the integer value of a hash field by the given number
    `RedisTransaction` | `hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a hash field by the given amount
    `RedisTransaction` | `hkeys(String key, Handler<AsyncResult<String>> handler)` Get all the fields in a hash
    `RedisTransaction` | `hlen(String key, Handler<AsyncResult<String>> handler)` Get the number of fields in a hash
    `RedisTransaction` | `hmget(String key, List<String> fields, Handler<AsyncResult<String>> handler)` Get the values of all the given hash fields
    `RedisTransaction` | `hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler)` Set multiple hash fields to multiple values
    `RedisTransaction` | `hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate hash fields and associated values
    `RedisTransaction` | `hset(String key, String field, String value, Handler<AsyncResult<String>> handler)` Set the string value of a hash field
    `RedisTransaction` | `hsetnx(String key, String field, String value, Handler<AsyncResult<String>> handler)` Set the value of a hash field, only if the field does not exist
    `RedisTransaction` | `hvals(String key, Handler<AsyncResult<String>> handler)` Get all the values in a hash
    `RedisTransaction` | `incr(String key, Handler<AsyncResult<String>> handler)` Increment the integer value of a key by one
    `RedisTransaction` | `incrby(String key, long increment, Handler<AsyncResult<String>> handler)` Increment the integer value of a key by the given amount
    `RedisTransaction` | `incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler)` Increment the float value of a key by the given amount
    `RedisTransaction` | `info(Handler<AsyncResult<String>> handler)` Get information and statistics about the server
    `RedisTransaction` | `infoSection(String section, Handler<AsyncResult<String>> handler)` Get information and statistics about the server
    `RedisTransaction` | `keys(String pattern, Handler<AsyncResult<String>> handler)` Find all keys matching the given pattern
    `RedisTransaction` | `lastsave(Handler<AsyncResult<String>> handler)` Get the UNIX time stamp of the last successful save to disk
    `RedisTransaction` | `lindex(String key, int index, Handler<AsyncResult<String>> handler)` Get an element from a list by its index
    `RedisTransaction` | `linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<String>> handler)` Insert an element before or after another element in a list
    `RedisTransaction` | `llen(String key, Handler<AsyncResult<String>> handler)` Get the length of a list
    `RedisTransaction` | `lpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the first element in a list
    `RedisTransaction` | `lpush(String key, String value, Handler<AsyncResult<String>> handler)` Prepend one value to a list
    `RedisTransaction` | `lpushMany(String key, List<String> values, Handler<AsyncResult<String>> handler)` Prepend one or multiple values to a list
    `RedisTransaction` | `lpushx(String key, String value, Handler<AsyncResult<String>> handler)` Prepend a value to a list, only if the list exists
    `RedisTransaction` | `lrange(String key, long from, long to, Handler<AsyncResult<String>> handler)` Get a range of elements from a list
    `RedisTransaction` | `lrem(String key, long count, String value, Handler<AsyncResult<String>> handler)` Remove elements from a list
    `RedisTransaction` | `lset(String key, long index, String value, Handler<AsyncResult<String>> handler)` Set the value of an element in a list by its index
    `RedisTransaction` | `ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler)` Trim a list to the specified range
    `RedisTransaction` | `mget(String key, Handler<AsyncResult<String>> handler)` Get the value of the given key
    `RedisTransaction` | `mgetMany(List<String> keys, Handler<AsyncResult<String>> handler)` Get the values of all the given keys
    `RedisTransaction` | `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.
    `RedisTransaction` | `monitor(Handler<AsyncResult<String>> handler)` Listen for all requests received by the server in real time
    `RedisTransaction` | `move(String key, int destdb, Handler<AsyncResult<String>> handler)` Move a key to another database
    `RedisTransaction` | `mset(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values
    `RedisTransaction` | `msetnx(JsonObject keyvals, Handler<AsyncResult<String>> handler)` Set multiple keys to multiple values, only if none of the keys exist
    `RedisTransaction` | `multi(Handler<AsyncResult<String>> handler)` Mark the start of a RedisTransaction block
    `static RedisTransaction` | `newInstance(RedisTransaction arg)`
    `RedisTransaction` | `object(String key, ObjectCmd cmd, Handler<AsyncResult<String>> handler)` Inspect the internals of Redis objects
    `RedisTransaction` | `persist(String key, Handler<AsyncResult<String>> handler)` Remove the expiration from a key
    `RedisTransaction` | `pexpire(String key, long millis, Handler<AsyncResult<String>> handler)` Set a key's time to live in milliseconds
    `RedisTransaction` | `pexpireat(String key, long millis, Handler<AsyncResult<String>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `RedisTransaction` | `pfadd(String key, String element, Handler<AsyncResult<String>> handler)` Adds the specified element to the specified HyperLogLog.
    `RedisTransaction` | `pfaddMany(String key, List<String> elements, Handler<AsyncResult<String>> handler)` Adds the specified elements to the specified HyperLogLog.
    `RedisTransaction` | `pfcount(String key, Handler<AsyncResult<String>> handler)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `RedisTransaction` | `pfcountMany(List<String> keys, Handler<AsyncResult<String>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisTransaction` | `pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisTransaction` | `ping(Handler<AsyncResult<String>> handler)` Ping the server
    `RedisTransaction` | `psetex(String key, long millis, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration in milliseconds of a key
    `RedisTransaction` | `psubscribe(String pattern, Handler<AsyncResult<String>> handler)` Listen for messages published to channels matching the given pattern
    `RedisTransaction` | `psubscribeMany(List<String> patterns, Handler<AsyncResult<String>> handler)` Listen for messages published to channels matching the given patterns
    `RedisTransaction` | `pttl(String key, Handler<AsyncResult<String>> handler)` Get the time to live for a key in milliseconds
    `RedisTransaction` | `publish(String channel, String message, Handler<AsyncResult<String>> handler)` Post a message to a channel
    `RedisTransaction` | `pubsubChannels(String pattern, Handler<AsyncResult<String>> handler)` Lists the currently active channels - only those matching the pattern
    `RedisTransaction` | `pubsubNumpat(Handler<AsyncResult<String>> handler)` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `RedisTransaction` | `pubsubNumsub(List<String> channels, Handler<AsyncResult<String>> handler)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `RedisTransaction` | `punsubscribe(List<String> patterns, Handler<AsyncResult<String>> handler)` Stop listening for messages posted to channels matching the given patterns
    `RedisTransaction` | `randomkey(Handler<AsyncResult<String>> handler)` Return a random key from the keyspace
    `RedisTransaction` | `rename(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key
    `RedisTransaction` | `renamenx(String key, String newkey, Handler<AsyncResult<String>> handler)` Rename a key, only if the new key does not exist
    `RedisTransaction` | `restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisTransaction` | `role(Handler<AsyncResult<String>> handler)` Return the role of the instance in the context of replication
    `RedisTransaction` | `rpop(String key, Handler<AsyncResult<String>> handler)` Remove and get the last element in a list
    `RedisTransaction` | `rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler)` Remove the last element in a list, append it to another list and return it
    `RedisTransaction` | `rpush(String key, String value, Handler<AsyncResult<String>> handler)` Append one or multiple values to a list
    `RedisTransaction` | `rpushMany(String key, List<String> values, Handler<AsyncResult<String>> handler)` Append one or multiple values to a list
    `RedisTransaction` | `rpushx(String key, String value, Handler<AsyncResult<String>> handler)` Append a value to a list, only if the list exists
    `Single<String>` | `rxAppend(String key, String value)` Append a value to a key
    `Single<String>` | `rxAuth(String password)` Authenticate to the server
    `Single<String>` | `rxBgrewriteaof()` Asynchronously rewrite the append-only file
    `Single<String>` | `rxBgsave()` Asynchronously save the dataset to disk
    `Single<String>` | `rxBitcount(String key)` Count set bits in a string
    `Single<String>` | `rxBitcountRange(String key, long start, long end)` Count set bits in a string
    `Single<String>` | `rxBitop(BitOperation operation, String destkey, List<String> keys)` Perform bitwise operations between strings
    `Single<String>` | `rxBitpos(String key, int bit)` Find first bit set or clear in a string
    `Single<String>` | `rxBitposFrom(String key, int bit, int start)` Find first bit set or clear in a string
    `Single<String>` | `rxBitposRange(String key, int bit, int start, int stop)` Find first bit set or clear in a string
    `Single<String>` | `rxBlpop(String key, int seconds)` Remove and get the first element in a list, or block until one is available
    `Single<String>` | `rxBlpopMany(List<String> keys, int seconds)` Remove and get the first element in any of the lists, or block until one is available
    `Single<String>` | `rxBrpop(String key, int seconds)` Remove and get the last element in a list, or block until one is available
    `Single<String>` | `rxBrpoplpush(String key, String destkey, int seconds)` Pop a value from a list, push it to another list and return it; or block until one is available
    `Single<String>` | `rxBrpopMany(List<String> keys, int seconds)` Remove and get the last element in any of the lists, or block until one is available
    `Single<String>` | `rxClientGetname()` Get the current connection name
    `Single<String>` | `rxClientKill(KillFilter filter)` Kill the connection of a client
    `Single<String>` | `rxClientList()` Get the list of client connections
    `Single<String>` | `rxClientPause(long millis)` Stop processing commands from clients for some time
    `Single<String>` | `rxClientSetname(String name)` Set the current connection name
    `Completable` | `rxClose()` Close the client - when it is fully closed the handler will be called.
    `Single<String>` | `rxClusterAddslots(List<String> slots)` Assign new hash slots to receiving node.
    `Single<String>` | `rxClusterCountFailureReports(String nodeId)` Return the number of failure reports active for a given node.
    `Single<String>` | `rxClusterCountkeysinslot(long slot)` Return the number of local keys in the specified hash slot.
    `Single<String>` | `rxClusterDelslots(long slot)` Set hash slots as unbound in receiving node.
    `Single<String>` | `rxClusterDelslotsMany(List<String> slots)` Set hash slots as unbound in receiving node.
    `Single<String>` | `rxClusterFailover()` Forces a slave to perform a manual failover of its master.
    `Single<String>` | `rxClusterFailOverWithOptions(FailoverOptions options)` Forces a slave to perform a manual failover of its master.
    `Single<String>` | `rxClusterForget(String nodeId)` Remove a node from the nodes table.
    `Single<String>` | `rxClusterGetkeysinslot(long slot, long count)` Return local key names in the specified hash slot.
    `Single<String>` | `rxClusterInfo()` Provides info about Redis Cluster node state.
    `Single<String>` | `rxClusterKeyslot(String key)` Returns the hash slot of the specified key.
    `Single<String>` | `rxClusterMeet(String ip, long port)` Force a node cluster to handshake with another node.
    `Single<String>` | `rxClusterNodes()` Get Cluster config for the node.
    `Single<String>` | `rxClusterReplicate(String nodeId)` Reconfigure a node as a slave of the specified master node.
    `Single<String>` | `rxClusterReset()` Reset a Redis Cluster node.
    `Single<String>` | `rxClusterResetWithOptions(ResetOptions options)` Reset a Redis Cluster node.
    `Single<String>` | `rxClusterSaveconfig()` Forces the node to save cluster state on disk.
    `Single<String>` | `rxClusterSetConfigEpoch(long epoch)` Set the configuration epoch in a new node.
    `Single<String>` | `rxClusterSetslot(long slot, SlotCmd subcommand)` Bind an hash slot to a specific node.
    `Single<String>` | `rxClusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId)` Bind an hash slot to a specific node.
    `Single<String>` | `rxClusterSlaves(String nodeId)` List slave nodes of the specified master node.
    `Single<String>` | `rxClusterSlots()` Get array of Cluster slot to node mappings
    `Single<String>` | `rxCommand()` Get array of Redis command details
    `Single<String>` | `rxCommandCount()` Get total number of Redis commands
    `Single<String>` | `rxCommandGetkeys()` Extract keys given a full Redis command
    `Single<String>` | `rxCommandInfo(List<String> commands)` Get array of specific Redis command details
    `Single<String>` | `rxConfigGet(String parameter)` Get the value of a configuration parameter
    `Single<String>` | `rxConfigResetstat()` Reset the stats returned by INFO
    `Single<String>` | `rxConfigRewrite()` Rewrite the configuration file with the in memory configuration
    `Single<String>` | `rxConfigSet(String parameter, String value)` Set a configuration parameter to the given value
    `Single<String>` | `rxDbsize()` Return the number of keys in the selected database
    `Single<String>` | `rxDebugObject(String key)` Get debugging information about a key
    `Single<String>` | `rxDebugSegfault()` Make the server crash
    `Single<String>` | `rxDecr(String key)` Decrement the integer value of a key by one
    `Single<String>` | `rxDecrby(String key, long decrement)` Decrement the integer value of a key by the given number
    `Single<String>` | `rxDel(String key)` Delete a key
    `Single<String>` | `rxDelMany(List<String> keys)` Delete many keys
    `Single<String>` | `rxDiscard()` Discard all commands issued after MULTI
    `Single<String>` | `rxDump(String key)` Return a serialized version of the value stored at the specified key.
    `Single<String>` | `rxEcho(String message)` Echo the given string
    `Single<String>` | `rxEval(String script, List<String> keys, List<String> args)` Execute a Lua script server side.
    `Single<String>` | `rxEvalsha(String sha1, List<String> keys, List<String> values)` Execute a Lua script server side.
    `Single<JsonArray>` | `rxExec()` Execute all commands issued after MULTI
    `Single<String>` | `rxExists(String key)` Determine if a key exists
    `Single<String>` | `rxExistsMany(List<String> keys)` Determine if one or many keys exist
    `Single<String>` | `rxExpire(String key, int seconds)` Set a key's time to live in seconds
    `Single<String>` | `rxExpireat(String key, long seconds)` Set the expiration for a key as a UNIX timestamp
    `Single<String>` | `rxFlushall()` Remove all keys from all databases
    `Single<String>` | `rxFlushdb()` Remove all keys from the current database
    `Single<String>` | `rxGeoadd(String key, double longitude, double latitude, String member)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `Single<String>` | `rxGeoaddMany(String key, List<GeoMember> members)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `Single<String>` | `rxGeodist(String key, String member1, String member2)` Return the distance between two members in the geospatial index represented by the sorted set.
    `Single<String>` | `rxGeodistWithUnit(String key, String member1, String member2, GeoUnit unit)` Return the distance between two members in the geospatial index represented by the sorted set.
    `Single<String>` | `rxGeohash(String key, String member)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `Single<String>` | `rxGeohashMany(String key, List<String> members)` Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
    `Single<String>` | `rxGeopos(String key, String member)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `Single<String>` | `rxGeoposMany(String key, List<String> members)` Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
    `Single<String>` | `rxGeoradius(String key, double longitude, double latitude, double radius, GeoUnit unit)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `Single<String>` | `rxGeoradiusbymember(String key, String member, double radius, GeoUnit unit)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `Single<String>` | `rxGeoradiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options)` This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
    `Single<String>` | `rxGeoradiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options)` Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
    `Single<String>` | `rxGet(String key)` Get the value of a key
    `Single<Buffer>` | `rxGetBinary(String key)` Get the value of a key - without decoding as utf-8
    `Single<String>` | `rxGetbit(String key, long offset)` Returns the bit value at offset in the string value stored at key
    `Single<String>` | `rxGetrange(String key, long start, long end)` Get a substring of the string stored at a key
    `Single<String>` | `rxGetset(String key, String value)` Set the string value of a key and return its old value
    `Single<String>` | `rxHdel(String key, String field)` Delete one or more hash fields
    `Single<String>` | `rxHdelMany(String key, List<String> fields)` Delete one or more hash fields
    `Single<String>` | `rxHexists(String key, String field)` Determine if a hash field exists
    `Single<String>` | `rxHget(String key, String field)` Get the value of a hash field
    `Single<String>` | `rxHgetall(String key)` Get all the fields and values in a hash
    `Single<String>` | `rxHincrby(String key, String field, long increment)` Increment the integer value of a hash field by the given number
    `Single<String>` | `rxHincrbyfloat(String key, String field, double increment)` Increment the float value of a hash field by the given amount
    `Single<String>` | `rxHkeys(String key)` Get all the fields in a hash
    `Single<String>` | `rxHlen(String key)` Get the number of fields in a hash
    `Single<String>` | `rxHmget(String key, List<String> fields)` Get the values of all the given hash fields
    `Single<String>` | `rxHmset(String key, JsonObject values)` Set multiple hash fields to multiple values
    `Single<String>` | `rxHscan(String key, String cursor, ScanOptions options)` Incrementally iterate hash fields and associated values
    `Single<String>` | `rxHset(String key, String field, String value)` Set the string value of a hash field
    `Single<String>` | `rxHsetnx(String key, String field, String value)` Set the value of a hash field, only if the field does not exist
    `Single<String>` | `rxHvals(String key)` Get all the values in a hash
    `Single<String>` | `rxIncr(String key)` Increment the integer value of a key by one
    `Single<String>` | `rxIncrby(String key, long increment)` Increment the integer value of a key by the given amount
    `Single<String>` | `rxIncrbyfloat(String key, double increment)` Increment the float value of a key by the given amount
    `Single<String>` | `rxInfo()` Get information and statistics about the server
    `Single<String>` | `rxInfoSection(String section)` Get information and statistics about the server
    `Single<String>` | `rxKeys(String pattern)` Find all keys matching the given pattern
    `Single<String>` | `rxLastsave()` Get the UNIX time stamp of the last successful save to disk
    `Single<String>` | `rxLindex(String key, int index)` Get an element from a list by its index
    `Single<String>` | `rxLinsert(String key, InsertOptions option, String pivot, String value)` Insert an element before or after another element in a list
    `Single<String>` | `rxLlen(String key)` Get the length of a list
    `Single<String>` | `rxLpop(String key)` Remove and get the first element in a list
    `Single<String>` | `rxLpush(String key, String value)` Prepend one value to a list
    `Single<String>` | `rxLpushMany(String key, List<String> values)` Prepend one or multiple values to a list
    `Single<String>` | `rxLpushx(String key, String value)` Prepend a value to a list, only if the list exists
    `Single<String>` | `rxLrange(String key, long from, long to)` Get a range of elements from a list
    `Single<String>` | `rxLrem(String key, long count, String value)` Remove elements from a list
    `Single<String>` | `rxLset(String key, long index, String value)` Set the value of an element in a list by its index
    `Single<String>` | `rxLtrim(String key, long from, long to)` Trim a list to the specified range
    `Single<String>` | `rxMget(String key)` Get the value of the given key
    `Single<String>` | `rxMgetMany(List<String> keys)` Get the values of all the given keys
    `Single<String>` | `rxMigrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options)` Atomically transfer a key from a Redis instance to another one.
    `Single<String>` | `rxMonitor()` Listen for all requests received by the server in real time
    `Single<String>` | `rxMove(String key, int destdb)` Move a key to another database
    `Single<String>` | `rxMset(JsonObject keyvals)` Set multiple keys to multiple values
    `Single<String>` | `rxMsetnx(JsonObject keyvals)` Set multiple keys to multiple values, only if none of the keys exist
    `Single<String>` | `rxMulti()` Mark the start of a RedisTransaction block
    `Single<String>` | `rxObject(String key, ObjectCmd cmd)` Inspect the internals of Redis objects
    `Single<String>` | `rxPersist(String key)` Remove the expiration from a key
    `Single<String>` | `rxPexpire(String key, long millis)` Set a key's time to live in milliseconds
    `Single<String>` | `rxPexpireat(String key, long millis)` Set the expiration for a key as a UNIX timestamp specified in milliseconds
    `Single<String>` | `rxPfadd(String key, String element)` Adds the specified element to the specified HyperLogLog.
    `Single<String>` | `rxPfaddMany(String key, List<String> elements)` Adds the specified elements to the specified HyperLogLog.
    `Single<String>` | `rxPfcount(String key)` Return the approximated cardinality of the set observed by the HyperLogLog at key.
    `Single<String>` | `rxPfcountMany(List<String> keys)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `Single<String>` | `rxPfmerge(String destkey, List<String> keys)` Merge N different HyperLogLogs into a single one.
    `Single<String>` | `rxPing()` Ping the server
    `Single<String>` | `rxPsetex(String key, long millis, String value)` Set the value and expiration in milliseconds of a key
    `Single<String>` | `rxPsubscribe(String pattern)` Listen for messages published to channels matching the given pattern
    `Single<String>` | `rxPsubscribeMany(List<String> patterns)` Listen for messages published to channels matching the given patterns
    `Single<String>` | `rxPttl(String key)` Get the time to live for a key in milliseconds
    `Single<String>` | `rxPublish(String channel, String message)` Post a message to a channel
    `Single<String>` | `rxPubsubChannels(String pattern)` Lists the currently active channels - only those matching the pattern
    `Single<String>` | `rxPubsubNumpat()` Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
    `Single<String>` | `rxPubsubNumsub(List<String> channels)` Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
    `Single<String>` | `rxPunsubscribe(List<String> patterns)` Stop listening for messages posted to channels matching the given patterns
    `Single<String>` | `rxRandomkey()` Return a random key from the keyspace
    `Single<String>` | `rxRename(String key, String newkey)` Rename a key
    `Single<String>` | `rxRenamenx(String key, String newkey)` Rename a key, only if the new key does not exist
    `Single<String>` | `rxRestore(String key, long millis, String serialized)` Create a key using the provided serialized value, previously obtained using DUMP.
    `Single<String>` | `rxRole()` Return the role of the instance in the context of replication
    `Single<String>` | `rxRpop(String key)` Remove and get the last element in a list
    `Single<String>` | `rxRpoplpush(String key, String destkey)` Remove the last element in a list, append it to another list and return it
    `Single<String>` | `rxRpush(String key, String value)` Append one or multiple values to a list
    `Single<String>` | `rxRpushMany(String key, List<String> values)` Append one or multiple values to a list
    `Single<String>` | `rxRpushx(String key, String value)` Append a value to a list, only if the list exists
    `Single<String>` | `rxSadd(String key, String member)` Add a member to a set
    `Single<String>` | `rxSaddMany(String key, List<String> members)` Add one or more members to a set
    `Single<String>` | `rxSave()` Synchronously save the dataset to disk
    `Single<String>` | `rxScan(String cursor, ScanOptions options)` Incrementally iterate the keys space
    `Single<String>` | `rxScard(String key)` Get the number of members in a set
    `Single<String>` | `rxScriptExists(String script)` Check existence of script in the script cache.
    `Single<String>` | `rxScriptExistsMany(List<String> scripts)` Check existence of scripts in the script cache.
    `Single<String>` | `rxScriptFlush()` Remove all the scripts from the script cache.
    `Single<String>` | `rxScriptKill()` Kill the script currently in execution.
    `Single<String>` | `rxScriptLoad(String script)` Load the specified Lua script into the script cache.
    `Single<String>` | `rxSdiff(String key, List<String> cmpkeys)` Subtract multiple sets
    `Single<String>` | `rxSdiffstore(String destkey, String key, List<String> cmpkeys)` Subtract multiple sets and store the resulting set in a key
    `Single<String>` | `rxSelect(int dbindex)` Change the selected database for the current connection
    `Single<String>` | `rxSet(String key, String value)` Set the string value of a key
    `Single<String>` | `rxSetBinary(String key, Buffer value)` Set the binary string value of a key - without encoding as utf-8
    `Single<String>` | `rxSetBinaryWithOptions(String key, Buffer value, SetOptions options)` Set the string value of a key
    `Single<String>` | `rxSetbit(String key, long offset, int bit)` Sets or clears the bit at offset in the string value stored at key
    `Single<String>` | `rxSetex(String key, long seconds, String value)` Set the value and expiration of a key
    `Single<String>` | `rxSetnx(String key, String value)` Set the value of a key, only if the key does not exist
    `Single<String>` | `rxSetrange(String key, int offset, String value)` Overwrite part of a string at key starting at the specified offset
    `Single<String>` | `rxSetWithOptions(String key, String value, SetOptions options)` Set the string value of a key
    `Single<String>` | `rxSinter(List<String> keys)` Intersect multiple sets
    `Single<String>` | `rxSinterstore(String destkey, List<String> keys)` Intersect multiple sets and store the resulting set in a key
    `Single<String>` | `rxSismember(String key, String member)` Determine if a given value is a member of a set
    `Single<String>` | `rxSlaveof(String host, int port)` Make the server a slave of another instance
    `Single<String>` | `rxSlaveofNoone()` Make this server a master
    `Single<String>` | `rxSlowlogGet(int limit)` Read the Redis slow queries log
    `Single<String>` | `rxSlowlogLen()` Get the length of the Redis slow queries log
    `Single<String>` | `rxSlowlogReset()` Reset the Redis slow queries log
    `Single<JsonArray>` | `rxSmembers(String key)` Get all the members in a set
    `Single<String>` | `rxSmove(String key, String destkey, String member)` Move a member from one set to another
    `Single<String>` | `rxSort(String key, SortOptions options)` Sort the elements in a list, set or sorted set
    `Single<String>` | `rxSpop(String key)` Remove and return a random member from a set
    `Single<String>` | `rxSpopMany(String key, int count)` Remove and return random members from a set
    `Single<String>` | `rxSrandmember(String key)` Get one or multiple random members from a set
    `Single<String>` | `rxSrandmemberCount(String key, int count)` Get one or multiple random members from a set
    `Single<String>` | `rxSrem(String key, String member)` Remove one member from a set
    `Single<String>` | `rxSremMany(String key, List<String> members)` Remove one or more members from a set
    `Single<String>` | `rxSscan(String key, String cursor, ScanOptions options)` Incrementally iterate Set elements
    `Single<String>` | `rxStrlen(String key)` Get the length of the value stored in a key
    `Single<String>` | `rxSubscribe(String channel)` Listen for messages published to the given channels
    `Single<String>` | `rxSubscribeMany(List<String> channels)` Listen for messages published to the given channels
    `Single<String>` | `rxSunion(List<String> keys)` Add multiple sets
    `Single<String>` | `rxSunionstore(String destkey, List<String> keys)` Add multiple sets and store the resulting set in a key
    `Single<String>` | `rxSwapdb(int index1, int index2)` Swaps two Redis databases
    `Single<String>` | `rxSync()` Internal command used for replication
    `Single<String>` | `rxTime()` Return the current server time
    `Single<String>` | `rxTtl(String key)` Get the time to live for a key
    `Single<String>` | `rxType(String key)` Determine the type stored at key
    `Single<String>` | `rxUnlink(String key)` Delete a key asynchronously in another thread.
    `Single<String>` | `rxUnlinkMany(List<String> keys)` Delete multiple keys asynchronously in another thread.
    `Single<String>` | `rxUnsubscribe(List<String> channels)` Stop listening for messages posted to the given channels
    `Single<String>` | `rxUnwatch()` Forget about all watched keys
    `Single<String>` | `rxWait(long numSlaves, long timeout)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `Single<String>` | `rxWatch(String key)` Watch the given keys to determine execution of the MULTI/EXEC block
    `Single<String>` | `rxWatchMany(List<String> keys)` Watch the given keys to determine execution of the MULTI/EXEC block
    `Single<String>` | `rxZadd(String key, double score, String member)` Add one or more members to a sorted set, or update its score if it already exists
    `Single<String>` | `rxZaddMany(String key, Map<String,Double> members)` Add one or more members to a sorted set, or update its score if it already exists
    `Single<String>` | `rxZcard(String key)` Get the number of members in a sorted set
    `Single<String>` | `rxZcount(String key, double min, double max)` Count the members in a sorted set with scores within the given values
    `Single<String>` | `rxZincrby(String key, double increment, String member)` Increment the score of a member in a sorted set
    `Single<String>` | `rxZinterstore(String destkey, List<String> sets, AggregateOptions options)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `Single<String>` | `rxZinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `Single<String>` | `rxZlexcount(String key, String min, String max)` Count the number of members in a sorted set between a given lexicographical range
    `Single<String>` | `rxZrange(String key, long start, long stop)` Return a range of members in a sorted set, by index
    `Single<String>` | `rxZrangebylex(String key, String min, String max, LimitOptions options)` Return a range of members in a sorted set, by lexicographical range
    `Single<String>` | `rxZrangebyscore(String key, String min, String max, RangeLimitOptions options)` Return a range of members in a sorted set, by score
    `Single<String>` | `rxZrangeWithOptions(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index
    `Single<String>` | `rxZrank(String key, String member)` Determine the index of a member in a sorted set
    `Single<String>` | `rxZrem(String key, String member)` Remove one member from a sorted set
    `Single<String>` | `rxZremMany(String key, List<String> members)` Remove one or more members from a sorted set
    `Single<String>` | `rxZremrangebylex(String key, String min, String max)` Remove all members in a sorted set between the given lexicographical range
    `Single<String>` | `rxZremrangebyrank(String key, long start, long stop)` Remove all members in a sorted set within the given indexes
    `Single<String>` | `rxZremrangebyscore(String key, String min, String max)` Remove all members in a sorted set within the given scores
    `Single<String>` | `rxZrevrange(String key, long start, long stop, RangeOptions options)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `Single<String>` | `rxZrevrangebylex(String key, String max, String min, LimitOptions options)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `Single<String>` | `rxZrevrangebyscore(String key, String max, String min, RangeLimitOptions options)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `Single<String>` | `rxZrevrank(String key, String member)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `Single<String>` | `rxZscan(String key, String cursor, ScanOptions options)` Incrementally iterate sorted sets elements and associated scores
    `Single<String>` | `rxZscore(String key, String member)` Get the score associated with the given member in a sorted set
    `Single<String>` | `rxZunionstore(String destkey, List<String> sets, AggregateOptions options)` Add multiple sorted sets and store the resulting sorted set in a new key
    `Single<String>` | `rxZunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key
    `RedisTransaction` | `sadd(String key, String member, Handler<AsyncResult<String>> handler)` Add a member to a set
    `RedisTransaction` | `saddMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Add one or more members to a set
    `RedisTransaction` | `save(Handler<AsyncResult<String>> handler)` Synchronously save the dataset to disk
    `RedisTransaction` | `scan(String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate the keys space
    `RedisTransaction` | `scard(String key, Handler<AsyncResult<String>> handler)` Get the number of members in a set
    `RedisTransaction` | `scriptExists(String script, Handler<AsyncResult<String>> handler)` Check existence of script in the script cache.
    `RedisTransaction` | `scriptExistsMany(List<String> scripts, Handler<AsyncResult<String>> handler)` Check existence of scripts in the script cache.
    `RedisTransaction` | `scriptFlush(Handler<AsyncResult<String>> handler)` Remove all the scripts from the script cache.
    `RedisTransaction` | `scriptKill(Handler<AsyncResult<String>> handler)` Kill the script currently in execution.
    `RedisTransaction` | `scriptLoad(String script, Handler<AsyncResult<String>> handler)` Load the specified Lua script into the script cache.
    `RedisTransaction` | `sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<String>> handler)` Subtract multiple sets
    `RedisTransaction` | `sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<String>> handler)` Subtract multiple sets and store the resulting set in a key
    `RedisTransaction` | `select(int dbindex, Handler<AsyncResult<String>> handler)` Change the selected database for the current connection
    `RedisTransaction` | `set(String key, String value, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisTransaction` | `setBinary(String key, Buffer value, Handler<AsyncResult<String>> handler)` Set the binary string value of a key - without encoding as utf-8
    `RedisTransaction` | `setBinaryWithOptions(String key, Buffer value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisTransaction` | `setbit(String key, long offset, int bit, Handler<AsyncResult<String>> handler)` Sets or clears the bit at offset in the string value stored at key
    `RedisTransaction` | `setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler)` Set the value and expiration of a key
    `RedisTransaction` | `setnx(String key, String value, Handler<AsyncResult<String>> handler)` Set the value of a key, only if the key does not exist
    `RedisTransaction` | `setrange(String key, int offset, String value, Handler<AsyncResult<String>> handler)` Overwrite part of a string at key starting at the specified offset
    `RedisTransaction` | `setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler)` Set the string value of a key
    `RedisTransaction` | `sinter(List<String> keys, Handler<AsyncResult<String>> handler)` Intersect multiple sets
    `RedisTransaction` | `sinterstore(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Intersect multiple sets and store the resulting set in a key
    `RedisTransaction` | `sismember(String key, String member, Handler<AsyncResult<String>> handler)` Determine if a given value is a member of a set
    `RedisTransaction` | `slaveof(String host, int port, Handler<AsyncResult<String>> handler)` Make the server a slave of another instance
    `RedisTransaction` | `slaveofNoone(Handler<AsyncResult<String>> handler)` Make this server a master
    `RedisTransaction` | `slowlogGet(int limit, Handler<AsyncResult<String>> handler)` Read the Redis slow queries log
    `RedisTransaction` | `slowlogLen(Handler<AsyncResult<String>> handler)` Get the length of the Redis slow queries log
    `RedisTransaction` | `slowlogReset(Handler<AsyncResult<String>> handler)` Reset the Redis slow queries log
    `RedisTransaction` | `smembers(String key, Handler<AsyncResult<JsonArray>> handler)` Get all the members in a set
    `RedisTransaction` | `smove(String key, String destkey, String member, Handler<AsyncResult<String>> handler)` Move a member from one set to another
    `RedisTransaction` | `sort(String key, SortOptions options, Handler<AsyncResult<String>> handler)` Sort the elements in a list, set or sorted set
    `RedisTransaction` | `spop(String key, Handler<AsyncResult<String>> handler)` Remove and return a random member from a set
    `RedisTransaction` | `spopMany(String key, int count, Handler<AsyncResult<String>> handler)` Remove and return random members from a set
    `RedisTransaction` | `srandmember(String key, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisTransaction` | `srandmemberCount(String key, int count, Handler<AsyncResult<String>> handler)` Get one or multiple random members from a set
    `RedisTransaction` | `srem(String key, String member, Handler<AsyncResult<String>> handler)` Remove one member from a set
    `RedisTransaction` | `sremMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Remove one or more members from a set
    `RedisTransaction` | `sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate Set elements
    `RedisTransaction` | `strlen(String key, Handler<AsyncResult<String>> handler)` Get the length of the value stored in a key
    `RedisTransaction` | `subscribe(String channel, Handler<AsyncResult<String>> handler)` Listen for messages published to the given channels
    `RedisTransaction` | `subscribeMany(List<String> channels, Handler<AsyncResult<String>> handler)` Listen for messages published to the given channels
    `RedisTransaction` | `sunion(List<String> keys, Handler<AsyncResult<String>> handler)` Add multiple sets
    `RedisTransaction` | `sunionstore(String destkey, List<String> keys, Handler<AsyncResult<String>> handler)` Add multiple sets and store the resulting set in a key
    `RedisTransaction` | `swapdb(int index1, int index2, Handler<AsyncResult<String>> handler)` Swaps two Redis databases
    `RedisTransaction` | `sync(Handler<AsyncResult<String>> handler)` Internal command used for replication
    `RedisTransaction` | `time(Handler<AsyncResult<String>> handler)` Return the current server time
    `String` | `toString()`
    `RedisTransaction` | `ttl(String key, Handler<AsyncResult<String>> handler)` Get the time to live for a key
    `RedisTransaction` | `type(String key, Handler<AsyncResult<String>> handler)` Determine the type stored at key
    `RedisTransaction` | `unlink(String key, Handler<AsyncResult<String>> handler)` Delete a key asynchronously in another thread.
    `RedisTransaction` | `unlinkMany(List<String> keys, Handler<AsyncResult<String>> handler)` Delete multiple keys asynchronously in another thread.
    `RedisTransaction` | `unsubscribe(List<String> channels, Handler<AsyncResult<String>> handler)` Stop listening for messages posted to the given channels
    `RedisTransaction` | `unwatch(Handler<AsyncResult<String>> handler)` Forget about all watched keys
    `RedisTransaction` | `wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisTransaction` | `watch(String key, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisTransaction` | `watchMany(List<String> keys, Handler<AsyncResult<String>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block
    `RedisTransaction` | `zadd(String key, double score, String member, Handler<AsyncResult<String>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisTransaction` | `zaddMany(String key, Map<String,Double> members, Handler<AsyncResult<String>> handler)` Add one or more members to a sorted set, or update its score if it already exists
    `RedisTransaction` | `zcard(String key, Handler<AsyncResult<String>> handler)` Get the number of members in a sorted set
    `RedisTransaction` | `zcount(String key, double min, double max, Handler<AsyncResult<String>> handler)` Count the members in a sorted set with scores within the given values
    `RedisTransaction` | `zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler)` Increment the score of a member in a sorted set
    `RedisTransaction` | `zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key
    `RedisTransaction` | `zinterstoreWeighed(String destkey, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
    `RedisTransaction` | `zlexcount(String key, String min, String max, Handler<AsyncResult<String>> handler)` Count the number of members in a sorted set between a given lexicographical range
    `RedisTransaction` | `zrange(String key, long start, long stop, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index
    `RedisTransaction` | `zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by lexicographical range
    `RedisTransaction` | `zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score
    `RedisTransaction` | `zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index
    `RedisTransaction` | `zrank(String key, String member, Handler<AsyncResult<String>> handler)` Determine the index of a member in a sorted set
    `RedisTransaction` | `zrem(String key, String member, Handler<AsyncResult<String>> handler)` Remove one member from a sorted set
    `RedisTransaction` | `zremMany(String key, List<String> members, Handler<AsyncResult<String>> handler)` Remove one or more members from a sorted set
    `RedisTransaction` | `zremrangebylex(String key, String min, String max, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set between the given lexicographical range
    `RedisTransaction` | `zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set within the given indexes
    `RedisTransaction` | `zremrangebyscore(String key, String min, String max, Handler<AsyncResult<String>> handler)` Remove all members in a sorted set within the given scores
    `RedisTransaction` | `zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low
    `RedisTransaction` | `zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
    `RedisTransaction` | `zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<String>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low
    `RedisTransaction` | `zrevrank(String key, String member, Handler<AsyncResult<String>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low
    `RedisTransaction` | `zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<String>> handler)` Incrementally iterate sorted sets elements and associated scores
    `RedisTransaction` | `zscore(String key, String member, Handler<AsyncResult<String>> handler)` Get the score associated with the given member in a sorted set
    `RedisTransaction` | `zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Add multiple sorted sets and store the resulting sorted set in a new key
    `RedisTransaction` | `zunionstoreWeighed(String key, Map<String,Double> sets, AggregateOptions options, Handler<AsyncResult<String>> handler)` Add multiple sorted sets using weights, and store the resulting sorted set in a new key

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

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### __TYPE_ARG

          public static final io.vertx.lang.rx.TypeArg<RedisTransaction> __TYPE_ARG

  - ### Constructor Detail

    - #### RedisTransaction

          public RedisTransaction(RedisTransaction delegate)

    - #### RedisTransaction

          public RedisTransaction(Object delegate)

  - ### Method Detail

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### getDelegate

          public RedisTransaction getDelegate()

    - #### close

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

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

    - #### rxClose

          public Completable rxClose()

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

    - #### append

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

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

    - #### rxAppend

          public Single<String> rxAppend(String key,
                                         String value)

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

    - #### auth

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

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

    - #### rxAuth

          public Single<String> rxAuth(String password)

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

    - #### bgrewriteaof

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

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

    - #### rxBgrewriteaof

          public Single<String> rxBgrewriteaof()

      Asynchronously rewrite the append-only file
      Returns:

    - #### bgsave

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

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

    - #### rxBgsave

          public Single<String> rxBgsave()

      Asynchronously save the dataset to disk
      Returns:

    - #### bitcount

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

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

    - #### rxBitcount

          public Single<String> rxBitcount(String key)

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

    - #### bitcountRange

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

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

    - #### rxBitcountRange

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

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

    - #### bitop

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

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

    - #### rxBitop

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

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

    - #### bitpos

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

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

    - #### rxBitpos

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

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

    - #### bitposFrom

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

      Find first bit set or clear in a string

      See also bitposRange() method, which takes start, and stop offset.

      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxBitposFrom

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

      Find first bit set or clear in a string

      See also bitposRange() method, which takes start, and stop offset.

      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
      Returns:

    - #### bitposRange

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

      Find first bit set or clear in a string

      Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified

      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
        `stop` - End offset - inclusive
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxBitposRange

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

      Find first bit set or clear in a string

      Note: when both start, and stop offsets are specified, behaviour is slightly different than if only start is specified

      Parameters:
        `key` - Key string
        `bit` - What bit value to look for - must be 1, or 0
        `start` - Start offset
        `stop` - End offset - inclusive
      Returns:

    - #### blpop

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

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

    - #### rxBlpop

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

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

    - #### blpopMany

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

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

    - #### rxBlpopMany

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

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

    - #### brpop

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

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

    - #### rxBrpop

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

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

    - #### brpopMany

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

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

    - #### rxBrpopMany

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

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

    - #### brpoplpush

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

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

    - #### rxBrpoplpush

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

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

    - #### clientKill

          public RedisTransaction clientKill(KillFilter filter,
                                             Handler<AsyncResult<String>> handler)

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

    - #### rxClientKill

          public Single<String> rxClientKill(KillFilter filter)

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

    - #### clientList

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

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

    - #### rxClientList

          public Single<String> rxClientList()

      Get the list of client connections
      Returns:

    - #### clientGetname

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

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

    - #### rxClientGetname

          public Single<String> rxClientGetname()

      Get the current connection name
      Returns:

    - #### clientPause

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

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

    - #### rxClientPause

          public Single<String> rxClientPause(long millis)

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

    - #### clientSetname

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

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

    - #### rxClientSetname

          public Single<String> rxClientSetname(String name)

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

    - #### clusterAddslots

          public RedisTransaction clusterAddslots(List<String> slots,
                                                  Handler<AsyncResult<String>> handler)

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

    - #### rxClusterAddslots

          public Single<String> rxClusterAddslots(List<String> slots)

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

    - #### clusterCountFailureReports

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

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

    - #### rxClusterCountFailureReports

          public Single<String> rxClusterCountFailureReports(String nodeId)

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

    - #### clusterCountkeysinslot

          public RedisTransaction clusterCountkeysinslot(long slot,
                                                         Handler<AsyncResult<String>> handler)

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

    - #### rxClusterCountkeysinslot

          public Single<String> rxClusterCountkeysinslot(long slot)

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

    - #### clusterDelslots

          public RedisTransaction clusterDelslots(long slot,
                                                  Handler<AsyncResult<String>> handler)

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

    - #### rxClusterDelslots

          public Single<String> rxClusterDelslots(long slot)

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

    - #### clusterDelslotsMany

          public RedisTransaction clusterDelslotsMany(List<String> slots,
                                                      Handler<AsyncResult<String>> handler)

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

    - #### rxClusterDelslotsMany

          public Single<String> rxClusterDelslotsMany(List<String> slots)

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

    - #### clusterFailover

          public RedisTransaction clusterFailover(Handler<AsyncResult<String>> handler)

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

    - #### rxClusterFailover

          public Single<String> rxClusterFailover()

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

    - #### clusterFailOverWithOptions

          public RedisTransaction clusterFailOverWithOptions(FailoverOptions options,
                                                             Handler<AsyncResult<String>> handler)

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

    - #### rxClusterFailOverWithOptions

          public Single<String> rxClusterFailOverWithOptions(FailoverOptions options)

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

    - #### clusterForget

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

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

    - #### rxClusterForget

          public Single<String> rxClusterForget(String nodeId)

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

    - #### clusterGetkeysinslot

          public RedisTransaction clusterGetkeysinslot(long slot,
                                                       long count,
                                                       Handler<AsyncResult<String>> handler)

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

    - #### rxClusterGetkeysinslot

          public Single<String> rxClusterGetkeysinslot(long slot,
                                                       long count)

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

    - #### clusterInfo

          public RedisTransaction clusterInfo(Handler<AsyncResult<String>> handler)

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

    - #### rxClusterInfo

          public Single<String> rxClusterInfo()

      Provides info about Redis Cluster node state.
      Returns:

    - #### clusterKeyslot

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

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

    - #### rxClusterKeyslot

          public Single<String> rxClusterKeyslot(String key)

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

    - #### clusterMeet

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

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

    - #### rxClusterMeet

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

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

    - #### clusterNodes

          public RedisTransaction clusterNodes(Handler<AsyncResult<String>> handler)

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

    - #### rxClusterNodes

          public Single<String> rxClusterNodes()

      Get Cluster config for the node.
      Returns:

    - #### clusterReplicate

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

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

    - #### rxClusterReplicate

          public Single<String> rxClusterReplicate(String nodeId)

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

    - #### clusterReset

          public RedisTransaction clusterReset(Handler<AsyncResult<String>> handler)

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

    - #### rxClusterReset

          public Single<String> rxClusterReset()

      Reset a Redis Cluster node.
      Returns:

    - #### clusterResetWithOptions

          public RedisTransaction clusterResetWithOptions(ResetOptions options,
                                                          Handler<AsyncResult<String>> handler)

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

    - #### rxClusterResetWithOptions

          public Single<String> rxClusterResetWithOptions(ResetOptions options)

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

    - #### clusterSaveconfig

          public RedisTransaction clusterSaveconfig(Handler<AsyncResult<String>> handler)

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

    - #### rxClusterSaveconfig

          public Single<String> rxClusterSaveconfig()

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

    - #### clusterSetConfigEpoch

          public RedisTransaction clusterSetConfigEpoch(long epoch,
                                                        Handler<AsyncResult<String>> handler)

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

    - #### rxClusterSetConfigEpoch

          public Single<String> rxClusterSetConfigEpoch(long epoch)

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

    - #### clusterSetslot

          public RedisTransaction clusterSetslot(long slot,
                                                 SlotCmd subcommand,
                                                 Handler<AsyncResult<String>> handler)

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

    - #### rxClusterSetslot

          public Single<String> rxClusterSetslot(long slot,
                                                 SlotCmd subcommand)

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

    - #### clusterSetslotWithNode

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

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

    - #### rxClusterSetslotWithNode

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

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

    - #### clusterSlaves

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

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

    - #### rxClusterSlaves

          public Single<String> rxClusterSlaves(String nodeId)

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

    - #### clusterSlots

          public RedisTransaction clusterSlots(Handler<AsyncResult<String>> handler)

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

    - #### rxClusterSlots

          public Single<String> rxClusterSlots()

      Get array of Cluster slot to node mappings
      Returns:

    - #### command

          public RedisTransaction command(Handler<AsyncResult<String>> handler)

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

    - #### rxCommand

          public Single<String> rxCommand()

      Get array of Redis command details
      Returns:

    - #### commandCount

          public RedisTransaction commandCount(Handler<AsyncResult<String>> handler)

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

    - #### rxCommandCount

          public Single<String> rxCommandCount()

      Get total number of Redis commands
      Returns:

    - #### commandGetkeys

          public RedisTransaction commandGetkeys(Handler<AsyncResult<String>> handler)

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

    - #### rxCommandGetkeys

          public Single<String> rxCommandGetkeys()

      Extract keys given a full Redis command
      Returns:

    - #### commandInfo

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

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

    - #### rxCommandInfo

          public Single<String> rxCommandInfo(List<String> commands)

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

    - #### configGet

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

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

    - #### rxConfigGet

          public Single<String> rxConfigGet(String parameter)

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

    - #### configRewrite

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

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

    - #### rxConfigRewrite

          public Single<String> rxConfigRewrite()

      Rewrite the configuration file with the in memory configuration
      Returns:

    - #### configSet

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

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

    - #### rxConfigSet

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

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

    - #### configResetstat

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

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

    - #### rxConfigResetstat

          public Single<String> rxConfigResetstat()

      Reset the stats returned by INFO
      Returns:

    - #### dbsize

          public RedisTransaction dbsize(Handler<AsyncResult<String>> handler)

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

    - #### rxDbsize

          public Single<String> rxDbsize()

      Return the number of keys in the selected database
      Returns:

    - #### debugObject

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

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

    - #### rxDebugObject

          public Single<String> rxDebugObject(String key)

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

    - #### debugSegfault

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

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

    - #### rxDebugSegfault

          public Single<String> rxDebugSegfault()

      Make the server crash
      Returns:

    - #### decr

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

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

    - #### rxDecr

          public Single<String> rxDecr(String key)

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

    - #### decrby

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

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

    - #### rxDecrby

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

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

    - #### del

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

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

    - #### rxDel

          public Single<String> rxDel(String key)

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

    - #### delMany

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

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

    - #### rxDelMany

          public Single<String> rxDelMany(List<String> keys)

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

    - #### discard

          public RedisTransaction discard(Handler<AsyncResult<String>> handler)

      Discard all commands issued after MULTI
      Parameters:
        `handler` -
      Returns:

    - #### rxDiscard

          public Single<String> rxDiscard()

      Discard all commands issued after MULTI
      Returns:

    - #### dump

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

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

    - #### rxDump

          public Single<String> rxDump(String key)

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

    - #### echo

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

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

    - #### rxEcho

          public Single<String> rxEcho(String message)

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

    - #### eval

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

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.

      When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

      Parameters:
        `script` - Lua script to evaluate
        `keys` - List of keys
        `args` - List of argument values
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxEval

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

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.

      When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

      Parameters:
        `script` - Lua script to evaluate
        `keys` - List of keys
        `args` - List of argument values
      Returns:

    - #### evalsha

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

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.

      When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

      Parameters:
        `sha1` - SHA1 digest of the script cached on the server
        `keys` - List of keys
        `values` - List of values
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxEvalsha

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

      Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.

      When a reply if for example a String the handler will be called with a JsonArray with a single element containing the String.

      Parameters:
        `sha1` - SHA1 digest of the script cached on the server
        `keys` - List of keys
        `values` - List of values
      Returns:

    - #### exec

          public RedisTransaction exec(Handler<AsyncResult<JsonArray>> handler)

      Execute all commands issued after MULTI
      Parameters:
        `handler` -
      Returns:

    - #### rxExec

          public Single<JsonArray> rxExec()

      Execute all commands issued after MULTI
      Returns:

    - #### exists

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

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

    - #### rxExists

          public Single<String> rxExists(String key)

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

    - #### existsMany

          public RedisTransaction existsMany(List<String> keys,
                                             Handler<AsyncResult<String>> handler)

      Determine if one or many keys exist
      Parameters:
        `keys` - List of key strings
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxExistsMany

          public Single<String> rxExistsMany(List<String> keys)

      Determine if one or many keys exist
      Parameters:
        `keys` - List of key strings
      Returns:

    - #### expire

          public RedisTransaction expire(String key,
                                         int seconds,
                                         Handler<AsyncResult<String>> handler)

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

    - #### rxExpire

          public Single<String> rxExpire(String key,
                                         int seconds)

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

    - #### expireat

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

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

    - #### rxExpireat

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

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

    - #### flushall

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

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

    - #### rxFlushall

          public Single<String> rxFlushall()

      Remove all keys from all databases
      Returns:

    - #### flushdb

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

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

    - #### rxFlushdb

          public Single<String> rxFlushdb()

      Remove all keys from the current database
      Returns:

    - #### get

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

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

    - #### rxGet

          public Single<String> rxGet(String key)

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

    - #### getBinary

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

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

    - #### rxGetBinary

          public Single<Buffer> rxGetBinary(String key)

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

    - #### getbit

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

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

    - #### rxGetbit

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

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

    - #### getrange

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

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

    - #### rxGetrange

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

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

    - #### getset

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

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

    - #### rxGetset

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

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

    - #### hdel

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

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

    - #### rxHdel

          public Single<String> rxHdel(String key,
                                       String field)

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

    - #### hdelMany

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

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

    - #### rxHdelMany

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

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

    - #### hexists

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

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

    - #### rxHexists

          public Single<String> rxHexists(String key,
                                          String field)

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

    - #### hget

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

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

    - #### rxHget

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

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

    - #### hgetall

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

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

    - #### rxHgetall

          public Single<String> rxHgetall(String key)

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

    - #### hincrby

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

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

    - #### rxHincrby

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

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

    - #### hincrbyfloat

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

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

    - #### rxHincrbyfloat

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

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

    - #### hkeys

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

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

    - #### rxHkeys

          public Single<String> rxHkeys(String key)

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

    - #### hlen

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

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

    - #### rxHlen

          public Single<String> rxHlen(String key)

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

    - #### hmget

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

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

    - #### rxHmget

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

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

    - #### hmset

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

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

    - #### rxHmset

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

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

    - #### hset

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

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

    - #### rxHset

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

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

    - #### hsetnx

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

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

    - #### rxHsetnx

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

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

    - #### hvals

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

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

    - #### rxHvals

          public Single<String> rxHvals(String key)

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

    - #### incr

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

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

    - #### rxIncr

          public Single<String> rxIncr(String key)

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

    - #### incrby

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

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

    - #### rxIncrby

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

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

    - #### incrbyfloat

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

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

    - #### rxIncrbyfloat

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

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

    - #### info

          public RedisTransaction info(Handler<AsyncResult<String>> handler)

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

    - #### rxInfo

          public Single<String> rxInfo()

      Get information and statistics about the server
      Returns:

    - #### infoSection

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

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

    - #### rxInfoSection

          public Single<String> rxInfoSection(String section)

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

    - #### keys

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

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

    - #### rxKeys

          public Single<String> rxKeys(String pattern)

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

    - #### lastsave

          public RedisTransaction lastsave(Handler<AsyncResult<String>> handler)

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

    - #### rxLastsave

          public Single<String> rxLastsave()

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

    - #### lindex

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

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

    - #### rxLindex

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

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

    - #### linsert

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

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

    - #### rxLinsert

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

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

    - #### llen

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

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

    - #### rxLlen

          public Single<String> rxLlen(String key)

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

    - #### lpop

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

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

    - #### rxLpop

          public Single<String> rxLpop(String key)

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

    - #### lpushMany

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

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

    - #### rxLpushMany

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

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

    - #### lpush

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

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

    - #### rxLpush

          public Single<String> rxLpush(String key,
                                        String value)

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

    - #### lpushx

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

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

    - #### rxLpushx

          public Single<String> rxLpushx(String key,
                                         String value)

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

    - #### lrange

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

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

    - #### rxLrange

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

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

    - #### lrem

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

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

    - #### rxLrem

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

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

    - #### lset

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

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

    - #### rxLset

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

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

    - #### ltrim

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

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

    - #### rxLtrim

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

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

    - #### mget

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

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

    - #### rxMget

          public Single<String> rxMget(String key)

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

    - #### mgetMany

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

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

    - #### rxMgetMany

          public Single<String> rxMgetMany(List<String> keys)

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

    - #### migrate

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

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

    - #### rxMigrate

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

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

    - #### monitor

          public RedisTransaction monitor(Handler<AsyncResult<String>> handler)

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

    - #### rxMonitor

          public Single<String> rxMonitor()

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

    - #### move

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

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

    - #### rxMove

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

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

    - #### mset

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

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

    - #### rxMset

          public Single<String> rxMset(JsonObject keyvals)

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

    - #### msetnx

          public RedisTransaction msetnx(JsonObject keyvals,
                                         Handler<AsyncResult<String>> handler)

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

    - #### rxMsetnx

          public Single<String> rxMsetnx(JsonObject keyvals)

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

    - #### multi

          public RedisTransaction multi(Handler<AsyncResult<String>> handler)

      Mark the start of a RedisTransaction block
      Parameters:
        `handler` -
      Returns:

    - #### rxMulti

          public Single<String> rxMulti()

      Mark the start of a RedisTransaction block
      Returns:

    - #### object

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

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

    - #### rxObject

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

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

    - #### persist

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

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

    - #### rxPersist

          public Single<String> rxPersist(String key)

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

    - #### pexpire

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

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

    - #### rxPexpire

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

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

    - #### pexpireat

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

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

    - #### rxPexpireat

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

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

    - #### pfadd

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

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

    - #### rxPfadd

          public Single<String> rxPfadd(String key,
                                        String element)

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

    - #### pfaddMany

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

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

    - #### rxPfaddMany

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

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

    - #### pfcount

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

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

    - #### rxPfcount

          public Single<String> rxPfcount(String key)

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

    - #### pfcountMany

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

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

    - #### rxPfcountMany

          public Single<String> rxPfcountMany(List<String> keys)

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

    - #### pfmerge

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

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

    - #### rxPfmerge

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

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

    - #### ping

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

      Ping the server
      Parameters:
        `handler` -
      Returns:

    - #### rxPing

          public Single<String> rxPing()

      Ping the server
      Returns:

    - #### psetex

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

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

    - #### rxPsetex

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

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

    - #### psubscribe

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

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

    - #### rxPsubscribe

          public Single<String> rxPsubscribe(String pattern)

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

    - #### psubscribeMany

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

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

    - #### rxPsubscribeMany

          public Single<String> rxPsubscribeMany(List<String> patterns)

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

    - #### pubsubChannels

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

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

    - #### rxPubsubChannels

          public Single<String> rxPubsubChannels(String pattern)

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

    - #### pubsubNumsub

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

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

    - #### rxPubsubNumsub

          public Single<String> rxPubsubNumsub(List<String> channels)

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

    - #### pubsubNumpat

          public RedisTransaction pubsubNumpat(Handler<AsyncResult<String>> handler)

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

    - #### rxPubsubNumpat

          public Single<String> rxPubsubNumpat()

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

    - #### pttl

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

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

    - #### rxPttl

          public Single<String> rxPttl(String key)

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

    - #### publish

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

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

    - #### rxPublish

          public Single<String> rxPublish(String channel,
                                          String message)

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

    - #### punsubscribe

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

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

    - #### rxPunsubscribe

          public Single<String> rxPunsubscribe(List<String> patterns)

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

    - #### randomkey

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

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

    - #### rxRandomkey

          public Single<String> rxRandomkey()

      Return a random key from the keyspace
      Returns:

    - #### rename

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

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

    - #### rxRename

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

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

    - #### renamenx

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

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

    - #### rxRenamenx

          public Single<String> rxRenamenx(String key,
                                           String newkey)

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

    - #### restore

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

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

    - #### rxRestore

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

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

    - #### role

          public RedisTransaction role(Handler<AsyncResult<String>> handler)

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

    - #### rxRole

          public Single<String> rxRole()

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

    - #### rpop

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

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

    - #### rxRpop

          public Single<String> rxRpop(String key)

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

    - #### rpoplpush

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

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

    - #### rxRpoplpush

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

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

    - #### rpushMany

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

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

    - #### rxRpushMany

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

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

    - #### rpush

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

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

    - #### rxRpush

          public Single<String> rxRpush(String key,
                                        String value)

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

    - #### rpushx

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

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

    - #### rxRpushx

          public Single<String> rxRpushx(String key,
                                         String value)

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

    - #### sadd

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

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

    - #### rxSadd

          public Single<String> rxSadd(String key,
                                       String member)

      Add a member to a set
      Parameters:
        `key` - Key string
        `member` - Value to be added to the set
      Returns:

    - #### saddMany

          public RedisTransaction saddMany(String key,
                                           List<String> members,
                                           Handler<AsyncResult<String>> handler)

      Add one or more members to a set
      Parameters:
        `key` - Key string
        `members` - Values to be added to the set
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSaddMany

          public Single<String> rxSaddMany(String key,
                                           List<String> members)

      Add one or more members to a set
      Parameters:
        `key` - Key string
        `members` - Values to be added to the set
      Returns:

    - #### save

          public RedisTransaction save(Handler<AsyncResult<String>> handler)

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

    - #### rxSave

          public Single<String> rxSave()

      Synchronously save the dataset to disk
      Returns:

    - #### scard

          public RedisTransaction scard(String key,
                                        Handler<AsyncResult<String>> handler)

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

    - #### rxScard

          public Single<String> rxScard(String key)

      Get the number of members in a set
      Parameters:
        `key` - Key string
      Returns:

    - #### scriptExists

          public RedisTransaction scriptExists(String script,
                                               Handler<AsyncResult<String>> handler)

      Check existence of script in the script cache.
      Parameters:
        `script` - SHA1 digest identifying a script in the script cache
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxScriptExists

          public Single<String> rxScriptExists(String script)

      Check existence of script in the script cache.
      Parameters:
        `script` - SHA1 digest identifying a script in the script cache
      Returns:

    - #### scriptExistsMany

          public RedisTransaction scriptExistsMany(List<String> scripts,
                                                   Handler<AsyncResult<String>> handler)

      Check existence of scripts in the script cache.
      Parameters:
        `scripts` - List of SHA1 digests identifying scripts in the script cache
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxScriptExistsMany

          public Single<String> rxScriptExistsMany(List<String> scripts)

      Check existence of scripts in the script cache.
      Parameters:
        `scripts` - List of SHA1 digests identifying scripts in the script cache
      Returns:

    - #### scriptFlush

          public RedisTransaction scriptFlush(Handler<AsyncResult<String>> handler)

      Remove all the scripts from the script cache.
      Parameters:
        `handler` -
      Returns:

    - #### rxScriptFlush

          public Single<String> rxScriptFlush()

      Remove all the scripts from the script cache.
      Returns:

    - #### scriptKill

          public RedisTransaction scriptKill(Handler<AsyncResult<String>> handler)

      Kill the script currently in execution.
      Parameters:
        `handler` -
      Returns:

    - #### rxScriptKill

          public Single<String> rxScriptKill()

      Kill the script currently in execution.
      Returns:

    - #### scriptLoad

          public RedisTransaction scriptLoad(String script,
                                             Handler<AsyncResult<String>> handler)

      Load the specified Lua script into the script cache.
      Parameters:
        `script` - Lua script
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxScriptLoad

          public Single<String> rxScriptLoad(String script)

      Load the specified Lua script into the script cache.
      Parameters:
        `script` - Lua script
      Returns:

    - #### sdiff

          public RedisTransaction sdiff(String key,
                                        List<String> cmpkeys,
                                        Handler<AsyncResult<String>> handler)

      Subtract multiple sets
      Parameters:
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSdiff

          public Single<String> rxSdiff(String key,
                                        List<String> cmpkeys)

      Subtract multiple sets
      Parameters:
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
      Returns:

    - #### sdiffstore

          public RedisTransaction sdiffstore(String destkey,
                                             String key,
                                             List<String> cmpkeys,
                                             Handler<AsyncResult<String>> handler)

      Subtract multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key where the result should be stored
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSdiffstore

          public Single<String> rxSdiffstore(String destkey,
                                             String key,
                                             List<String> cmpkeys)

      Subtract multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key where the result should be stored
        `key` - Key identifying the set to compare with all other sets combined
        `cmpkeys` - List of keys identifying sets to subtract from the key set
      Returns:

    - #### select

          public RedisTransaction select(int dbindex,
                                         Handler<AsyncResult<String>> handler)

      Change the selected database for the current connection
      Parameters:
        `dbindex` - Index identifying the new active database
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSelect

          public Single<String> rxSelect(int dbindex)

      Change the selected database for the current connection
      Parameters:
        `dbindex` - Index identifying the new active database
      Returns:

    - #### set

          public RedisTransaction set(String key,
                                      String value,
                                      Handler<AsyncResult<String>> handler)

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

    - #### rxSet

          public Single<String> rxSet(String key,
                                      String value)

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

    - #### setWithOptions

          public RedisTransaction setWithOptions(String key,
                                                 String value,
                                                 SetOptions options,
                                                 Handler<AsyncResult<String>> handler)

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

    - #### rxSetWithOptions

          public Single<String> rxSetWithOptions(String key,
                                                 String value,
                                                 SetOptions options)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `options` - Set options
      Returns:

    - #### setBinary

          public RedisTransaction setBinary(String key,
                                            Buffer value,
                                            Handler<AsyncResult<String>> handler)

      Set the binary string value of a key - without encoding as utf-8
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSetBinary

          public Single<String> rxSetBinary(String key,
                                            Buffer value)

      Set the binary string value of a key - without encoding as utf-8
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
      Returns:

    - #### setBinaryWithOptions

          public RedisTransaction setBinaryWithOptions(String key,
                                                       Buffer value,
                                                       SetOptions options,
                                                       Handler<AsyncResult<String>> handler)

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

    - #### rxSetBinaryWithOptions

          public Single<String> rxSetBinaryWithOptions(String key,
                                                       Buffer value,
                                                       SetOptions options)

      Set the string value of a key
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `options` - Set options
      Returns:

    - #### setbit

          public RedisTransaction setbit(String key,
                                         long offset,
                                         int bit,
                                         Handler<AsyncResult<String>> handler)

      Sets or clears the bit at offset in the string value stored at key
      Parameters:
        `key` - Key string
        `offset` - Bit offset
        `bit` - New value - must be 1 or 0
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSetbit

          public Single<String> rxSetbit(String key,
                                         long offset,
                                         int bit)

      Sets or clears the bit at offset in the string value stored at key
      Parameters:
        `key` - Key string
        `offset` - Bit offset
        `bit` - New value - must be 1 or 0
      Returns:

    - #### setex

          public RedisTransaction setex(String key,
                                        long seconds,
                                        String value,
                                        Handler<AsyncResult<String>> handler)

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

    - #### rxSetex

          public Single<String> rxSetex(String key,
                                        long seconds,
                                        String value)

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

    - #### setnx

          public RedisTransaction setnx(String key,
                                        String value,
                                        Handler<AsyncResult<String>> handler)

      Set the value of a key, only if the key does not exist
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSetnx

          public Single<String> rxSetnx(String key,
                                        String value)

      Set the value of a key, only if the key does not exist
      Parameters:
        `key` - Key of which value to set
        `value` - New value for the key
      Returns:

    - #### setrange

          public RedisTransaction setrange(String key,
                                           int offset,
                                           String value,
                                           Handler<AsyncResult<String>> handler)

      Overwrite part of a string at key starting at the specified offset
      Parameters:
        `key` - Key string
        `offset` - Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
        `value` - Value to overwrite with
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSetrange

          public Single<String> rxSetrange(String key,
                                           int offset,
                                           String value)

      Overwrite part of a string at key starting at the specified offset
      Parameters:
        `key` - Key string
        `offset` - Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
        `value` - Value to overwrite with
      Returns:

    - #### sinter

          public RedisTransaction sinter(List<String> keys,
                                         Handler<AsyncResult<String>> handler)

      Intersect multiple sets
      Parameters:
        `keys` - List of keys to perform intersection on
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSinter

          public Single<String> rxSinter(List<String> keys)

      Intersect multiple sets
      Parameters:
        `keys` - List of keys to perform intersection on
      Returns:

    - #### sinterstore

          public RedisTransaction sinterstore(String destkey,
                                              List<String> keys,
                                              Handler<AsyncResult<String>> handler)

      Intersect multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Key where to store the results
        `keys` - List of keys to perform intersection on
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSinterstore

          public Single<String> rxSinterstore(String destkey,
                                              List<String> keys)

      Intersect multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Key where to store the results
        `keys` - List of keys to perform intersection on
      Returns:

    - #### sismember

          public RedisTransaction sismember(String key,
                                            String member,
                                            Handler<AsyncResult<String>> handler)

      Determine if a given value is a member of a set
      Parameters:
        `key` - Key string
        `member` - Member to look for
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSismember

          public Single<String> rxSismember(String key,
                                            String member)

      Determine if a given value is a member of a set
      Parameters:
        `key` - Key string
        `member` - Member to look for
      Returns:

    - #### slaveof

          public RedisTransaction slaveof(String host,
                                          int port,
                                          Handler<AsyncResult<String>> handler)

      Make the server a slave of another instance
      Parameters:
        `host` - Host to become this server's master
        `port` - Port of our new master
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSlaveof

          public Single<String> rxSlaveof(String host,
                                          int port)

      Make the server a slave of another instance
      Parameters:
        `host` - Host to become this server's master
        `port` - Port of our new master
      Returns:

    - #### slaveofNoone

          public RedisTransaction slaveofNoone(Handler<AsyncResult<String>> handler)

      Make this server a master
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSlaveofNoone

          public Single<String> rxSlaveofNoone()

      Make this server a master
      Returns:

    - #### slowlogGet

          public RedisTransaction slowlogGet(int limit,
                                             Handler<AsyncResult<String>> handler)

      Read the Redis slow queries log
      Parameters:
        `limit` - Number of log entries to return. If value is less than zero all entries are returned
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSlowlogGet

          public Single<String> rxSlowlogGet(int limit)

      Read the Redis slow queries log
      Parameters:
        `limit` - Number of log entries to return. If value is less than zero all entries are returned
      Returns:

    - #### slowlogLen

          public RedisTransaction slowlogLen(Handler<AsyncResult<String>> handler)

      Get the length of the Redis slow queries log
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSlowlogLen

          public Single<String> rxSlowlogLen()

      Get the length of the Redis slow queries log
      Returns:

    - #### slowlogReset

          public RedisTransaction slowlogReset(Handler<AsyncResult<String>> handler)

      Reset the Redis slow queries log
      Parameters:
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSlowlogReset

          public Single<String> rxSlowlogReset()

      Reset the Redis slow queries log
      Returns:

    - #### smembers

          public RedisTransaction smembers(String key,
                                           Handler<AsyncResult<JsonArray>> handler)

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

    - #### rxSmembers

          public Single<JsonArray> rxSmembers(String key)

      Get all the members in a set
      Parameters:
        `key` - Key string
      Returns:

    - #### smove

          public RedisTransaction smove(String key,
                                        String destkey,
                                        String member,
                                        Handler<AsyncResult<String>> handler)

      Move a member from one set to another
      Parameters:
        `key` - Key of source set currently containing the member
        `destkey` - Key identifying the destination set
        `member` - Member to move
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSmove

          public Single<String> rxSmove(String key,
                                        String destkey,
                                        String member)

      Move a member from one set to another
      Parameters:
        `key` - Key of source set currently containing the member
        `destkey` - Key identifying the destination set
        `member` - Member to move
      Returns:

    - #### sort

          public RedisTransaction sort(String key,
                                       SortOptions options,
                                       Handler<AsyncResult<String>> handler)

      Sort the elements in a list, set or sorted set
      Parameters:
        `key` - Key string
        `options` - Sort options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSort

          public Single<String> rxSort(String key,
                                       SortOptions options)

      Sort the elements in a list, set or sorted set
      Parameters:
        `key` - Key string
        `options` - Sort options
      Returns:

    - #### spop

          public RedisTransaction spop(String key,
                                       Handler<AsyncResult<String>> handler)

      Remove and return a random member from a set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSpop

          public Single<String> rxSpop(String key)

      Remove and return a random member from a set
      Parameters:
        `key` - Key string
      Returns:

    - #### spopMany

          public RedisTransaction 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.
      Returns:

    - #### rxSpopMany

          public Single<String> rxSpopMany(String key,
                                           int count)

      Remove and return random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to remove
      Returns:

    - #### srandmember

          public RedisTransaction srandmember(String key,
                                              Handler<AsyncResult<String>> handler)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSrandmember

          public Single<String> rxSrandmember(String key)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
      Returns:

    - #### srandmemberCount

          public RedisTransaction srandmemberCount(String key,
                                                   int count,
                                                   Handler<AsyncResult<String>> handler)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to get
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSrandmemberCount

          public Single<String> rxSrandmemberCount(String key,
                                                   int count)

      Get one or multiple random members from a set
      Parameters:
        `key` - Key string
        `count` - Number of members to get
      Returns:

    - #### srem

          public RedisTransaction srem(String key,
                                       String member,
                                       Handler<AsyncResult<String>> handler)

      Remove one member from a set
      Parameters:
        `key` - Key string
        `member` - Member to remove
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSrem

          public Single<String> rxSrem(String key,
                                       String member)

      Remove one member from a set
      Parameters:
        `key` - Key string
        `member` - Member to remove
      Returns:

    - #### sremMany

          public RedisTransaction sremMany(String key,
                                           List<String> members,
                                           Handler<AsyncResult<String>> handler)

      Remove one or more members from a set
      Parameters:
        `key` - Key string
        `members` - Members to remove
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSremMany

          public Single<String> rxSremMany(String key,
                                           List<String> members)

      Remove one or more members from a set
      Parameters:
        `key` - Key string
        `members` - Members to remove
      Returns:

    - #### strlen

          public RedisTransaction strlen(String key,
                                         Handler<AsyncResult<String>> handler)

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

    - #### rxStrlen

          public Single<String> rxStrlen(String key)

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

    - #### subscribe

          public RedisTransaction subscribe(String channel,
                                            Handler<AsyncResult<String>> handler)

      Listen for messages published to the given channels
      Parameters:
        `channel` - Channel to subscribe to
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSubscribe

          public Single<String> rxSubscribe(String channel)

      Listen for messages published to the given channels
      Parameters:
        `channel` - Channel to subscribe to
      Returns:

    - #### subscribeMany

          public RedisTransaction subscribeMany(List<String> channels,
                                                Handler<AsyncResult<String>> handler)

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

    - #### rxSubscribeMany

          public Single<String> rxSubscribeMany(List<String> channels)

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

    - #### sunion

          public RedisTransaction sunion(List<String> keys,
                                         Handler<AsyncResult<String>> handler)

      Add multiple sets
      Parameters:
        `keys` - List of keys identifying sets to add up
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSunion

          public Single<String> rxSunion(List<String> keys)

      Add multiple sets
      Parameters:
        `keys` - List of keys identifying sets to add up
      Returns:

    - #### sunionstore

          public RedisTransaction sunionstore(String destkey,
                                              List<String> keys,
                                              Handler<AsyncResult<String>> handler)

      Add multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key
        `keys` - List of keys identifying sets to add up
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSunionstore

          public Single<String> rxSunionstore(String destkey,
                                              List<String> keys)

      Add multiple sets and store the resulting set in a key
      Parameters:
        `destkey` - Destination key
        `keys` - List of keys identifying sets to add up
      Returns:

    - #### sync

          public RedisTransaction sync(Handler<AsyncResult<String>> handler)

      Internal command used for replication
      Parameters:
        `handler` -
      Returns:

    - #### rxSync

          public Single<String> rxSync()

      Internal command used for replication
      Returns:

    - #### time

          public RedisTransaction time(Handler<AsyncResult<String>> handler)

      Return the current server time
      Parameters:
        `handler` -
      Returns:

    - #### rxTime

          public Single<String> rxTime()

      Return the current server time
      Returns:

    - #### ttl

          public RedisTransaction ttl(String key,
                                      Handler<AsyncResult<String>> handler)

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

    - #### rxTtl

          public Single<String> rxTtl(String key)

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

    - #### type

          public RedisTransaction type(String key,
                                       Handler<AsyncResult<String>> handler)

      Determine the type stored at key
      Parameters:
        `key` - Key string
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxType

          public Single<String> rxType(String key)

      Determine the type stored at key
      Parameters:
        `key` - Key string
      Returns:

    - #### unsubscribe

          public RedisTransaction unsubscribe(List<String> channels,
                                              Handler<AsyncResult<String>> handler)

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

    - #### rxUnsubscribe

          public Single<String> rxUnsubscribe(List<String> channels)

      Stop listening for messages posted to the given channels
      Parameters:
        `channels` - List of channels to subscribe to
      Returns:

    - #### unwatch

          public RedisTransaction unwatch(Handler<AsyncResult<String>> handler)

      Forget about all watched keys
      Parameters:
        `handler` -
      Returns:

    - #### rxUnwatch

          public Single<String> rxUnwatch()

      Forget about all watched keys
      Returns:

    - #### wait

          public RedisTransaction wait(long numSlaves,
                                       long timeout,
                                       Handler<AsyncResult<String>> handler)

      Wait for the synchronous replication of all the write commands sent in the context of the current connection.
      Parameters:
        `numSlaves` -
        `timeout` -
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxWait

          public Single<String> rxWait(long numSlaves,
                                       long timeout)

      Wait for the synchronous replication of all the write commands sent in the context of the current connection.
      Parameters:
        `numSlaves` -
        `timeout` -
      Returns:

    - #### watch

          public RedisTransaction watch(String key,
                                        Handler<AsyncResult<String>> handler)

      Watch the given keys to determine execution of the MULTI/EXEC block
      Parameters:
        `key` - Key to watch
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxWatch

          public Single<String> rxWatch(String key)

      Watch the given keys to determine execution of the MULTI/EXEC block
      Parameters:
        `key` - Key to watch
      Returns:

    - #### watchMany

          public RedisTransaction watchMany(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.
      Returns:

    - #### rxWatchMany

          public Single<String> rxWatchMany(List<String> keys)

      Watch the given keys to determine execution of the MULTI/EXEC block
      Parameters:
        `keys` - List of keys to watch
      Returns:

    - #### zadd

          public RedisTransaction zadd(String key,
                                       double score,
                                       String member,
                                       Handler<AsyncResult<String>> handler)

      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `score` - Score used for sorting
        `member` - New member key
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZadd

          public Single<String> rxZadd(String key,
                                       double score,
                                       String member)

      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `score` - Score used for sorting
        `member` - New member key
      Returns:

    - #### zaddMany

          public RedisTransaction zaddMany(String key,
                                           Map<String,Double> members,
                                           Handler<AsyncResult<String>> handler)

      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `members` - New member keys and their scores
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZaddMany

          public Single<String> rxZaddMany(String key,
                                           Map<String,Double> members)

      Add one or more members to a sorted set, or update its score if it already exists
      Parameters:
        `key` - Key string
        `members` - New member keys and their scores
      Returns:

    - #### zcard

          public RedisTransaction zcard(String key,
                                        Handler<AsyncResult<String>> handler)

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

    - #### rxZcard

          public Single<String> rxZcard(String key)

      Get the number of members in a sorted set
      Parameters:
        `key` - Key string
      Returns:

    - #### zcount

          public RedisTransaction zcount(String key,
                                         double min,
                                         double max,
                                         Handler<AsyncResult<String>> handler)

      Count the members in a sorted set with scores within the given values
      Parameters:
        `key` - Key string
        `min` - Minimum score
        `max` - Maximum score
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZcount

          public Single<String> rxZcount(String key,
                                         double min,
                                         double max)

      Count the members in a sorted set with scores within the given values
      Parameters:
        `key` - Key string
        `min` - Minimum score
        `max` - Maximum score
      Returns:

    - #### zincrby

          public RedisTransaction zincrby(String key,
                                          double increment,
                                          String member,
                                          Handler<AsyncResult<String>> handler)

      Increment the score of a member in a sorted set
      Parameters:
        `key` - Key string
        `increment` - Increment amount
        `member` - Member key
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZincrby

          public Single<String> rxZincrby(String key,
                                          double increment,
                                          String member)

      Increment the score of a member in a sorted set
      Parameters:
        `key` - Key string
        `increment` - Increment amount
        `member` - Member key
      Returns:

    - #### zinterstore

          public RedisTransaction zinterstore(String destkey,
                                              List<String> sets,
                                              AggregateOptions options,
                                              Handler<AsyncResult<String>> handler)

      Intersect multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZinterstore

          public Single<String> rxZinterstore(String destkey,
                                              List<String> sets,
                                              AggregateOptions options)

      Intersect multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
      Returns:

    - #### zinterstoreWeighed

          public RedisTransaction zinterstoreWeighed(String destkey,
                                                     Map<String,Double> sets,
                                                     AggregateOptions options,
                                                     Handler<AsyncResult<String>> handler)

      Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZinterstoreWeighed

          public Single<String> rxZinterstoreWeighed(String destkey,
                                                     Map<String,Double> sets,
                                                     AggregateOptions options)

      Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets to intersect
        `options` - Aggregation options
      Returns:

    - #### zlexcount

          public RedisTransaction zlexcount(String key,
                                            String min,
                                            String max,
                                            Handler<AsyncResult<String>> handler)

      Count the number of members in a sorted set between a given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern to compare against for minimum value
        `max` - Pattern to compare against for maximum value
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZlexcount

          public Single<String> rxZlexcount(String key,
                                            String min,
                                            String max)

      Count the number of members in a sorted set between a given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern to compare against for minimum value
        `max` - Pattern to compare against for maximum value
      Returns:

    - #### zrange

          public RedisTransaction zrange(String key,
                                         long start,
                                         long stop,
                                         Handler<AsyncResult<String>> handler)

      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZrange

          public Single<String> rxZrange(String key,
                                         long start,
                                         long stop)

      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
      Returns:

    - #### zrangeWithOptions

          public RedisTransaction zrangeWithOptions(String key,
                                                    long start,
                                                    long stop,
                                                    RangeOptions options,
                                                    Handler<AsyncResult<String>> handler)

      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZrangeWithOptions

          public Single<String> rxZrangeWithOptions(String key,
                                                    long start,
                                                    long stop,
                                                    RangeOptions options)

      Return a range of members in a sorted set, by index
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
      Returns:

    - #### zrangebylex

          public RedisTransaction zrangebylex(String key,
                                              String min,
                                              String max,
                                              LimitOptions options,
                                              Handler<AsyncResult<String>> handler)

      Return a range of members in a sorted set, by lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern representing a minimum allowed value
        `max` - Pattern representing a maximum allowed value
        `options` - Limit options where limit can be specified
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZrangebylex

          public Single<String> rxZrangebylex(String key,
                                              String min,
                                              String max,
                                              LimitOptions options)

      Return a range of members in a sorted set, by lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern representing a minimum allowed value
        `max` - Pattern representing a maximum allowed value
        `options` - Limit options where limit can be specified
      Returns:

    - #### zrangebyscore

          public RedisTransaction zrangebyscore(String key,
                                                String min,
                                                String max,
                                                RangeLimitOptions options,
                                                Handler<AsyncResult<String>> handler)

      Return a range of members in a sorted set, by score
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `options` - Range and limit options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZrangebyscore

          public Single<String> rxZrangebyscore(String key,
                                                String min,
                                                String max,
                                                RangeLimitOptions options)

      Return a range of members in a sorted set, by score
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `options` - Range and limit options
      Returns:

    - #### zrank

          public RedisTransaction zrank(String key,
                                        String member,
                                        Handler<AsyncResult<String>> handler)

      Determine the index of a member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZrank

          public Single<String> rxZrank(String key,
                                        String member)

      Determine the index of a member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### zrem

          public RedisTransaction zrem(String key,
                                       String member,
                                       Handler<AsyncResult<String>> handler)

      Remove one member from a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZrem

          public Single<String> rxZrem(String key,
                                       String member)

      Remove one member from a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### zremMany

          public RedisTransaction zremMany(String key,
                                           List<String> members,
                                           Handler<AsyncResult<String>> handler)

      Remove one or more members from a sorted set
      Parameters:
        `key` - Key string
        `members` - Members in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZremMany

          public Single<String> rxZremMany(String key,
                                           List<String> members)

      Remove one or more members from a sorted set
      Parameters:
        `key` - Key string
        `members` - Members in the sorted set identified by key
      Returns:

    - #### zremrangebylex

          public RedisTransaction zremrangebylex(String key,
                                                 String min,
                                                 String max,
                                                 Handler<AsyncResult<String>> handler)

      Remove all members in a sorted set between the given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZremrangebylex

          public Single<String> rxZremrangebylex(String key,
                                                 String min,
                                                 String max)

      Remove all members in a sorted set between the given lexicographical range
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
      Returns:

    - #### zremrangebyrank

          public RedisTransaction zremrangebyrank(String key,
                                                  long start,
                                                  long stop,
                                                  Handler<AsyncResult<String>> handler)

      Remove all members in a sorted set within the given indexes
      Parameters:
        `key` - Key string
        `start` - Start index
        `stop` - Stop index
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZremrangebyrank

          public Single<String> rxZremrangebyrank(String key,
                                                  long start,
                                                  long stop)

      Remove all members in a sorted set within the given indexes
      Parameters:
        `key` - Key string
        `start` - Start index
        `stop` - Stop index
      Returns:

    - #### zremrangebyscore

          public RedisTransaction zremrangebyscore(String key,
                                                   String min,
                                                   String max,
                                                   Handler<AsyncResult<String>> handler)

      Remove all members in a sorted set within the given scores
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
        `handler` -
      Returns:

    - #### rxZremrangebyscore

          public Single<String> rxZremrangebyscore(String key,
                                                   String min,
                                                   String max)

      Remove all members in a sorted set within the given scores
      Parameters:
        `key` - Key string
        `min` - Pattern defining a minimum value
        `max` - Pattern defining a maximum value
      Returns:

    - #### zrevrange

          public RedisTransaction zrevrange(String key,
                                            long start,
                                            long stop,
                                            RangeOptions options,
                                            Handler<AsyncResult<String>> handler)

      Return a range of members in a sorted set, by index, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZrevrange

          public Single<String> rxZrevrange(String key,
                                            long start,
                                            long stop,
                                            RangeOptions options)

      Return a range of members in a sorted set, by index, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `start` - Start index for the range
        `stop` - Stop index for the range - inclusive
        `options` - Range options
      Returns:

    - #### zrevrangebylex

          public RedisTransaction zrevrangebylex(String key,
                                                 String max,
                                                 String min,
                                                 LimitOptions options,
                                                 Handler<AsyncResult<String>> handler)

      Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Limit options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZrevrangebylex

          public Single<String> rxZrevrangebylex(String key,
                                                 String max,
                                                 String min,
                                                 LimitOptions options)

      Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Limit options
      Returns:

    - #### zrevrangebyscore

          public RedisTransaction zrevrangebyscore(String key,
                                                   String max,
                                                   String min,
                                                   RangeLimitOptions options,
                                                   Handler<AsyncResult<String>> handler)

      Return a range of members in a sorted set, by score, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Range and limit options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZrevrangebyscore

          public Single<String> rxZrevrangebyscore(String key,
                                                   String max,
                                                   String min,
                                                   RangeLimitOptions options)

      Return a range of members in a sorted set, by score, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `max` - Pattern defining a maximum value
        `min` - Pattern defining a minimum value
        `options` - Range and limit options
      Returns:

    - #### zrevrank

          public RedisTransaction zrevrank(String key,
                                           String member,
                                           Handler<AsyncResult<String>> handler)

      Determine the index of a member in a sorted set, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZrevrank

          public Single<String> rxZrevrank(String key,
                                           String member)

      Determine the index of a member in a sorted set, with scores ordered from high to low
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### zscore

          public RedisTransaction zscore(String key,
                                         String member,
                                         Handler<AsyncResult<String>> handler)

      Get the score associated with the given member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZscore

          public Single<String> rxZscore(String key,
                                         String member)

      Get the score associated with the given member in a sorted set
      Parameters:
        `key` - Key string
        `member` - Member in the sorted set identified by key
      Returns:

    - #### zunionstore

          public RedisTransaction zunionstore(String destkey,
                                              List<String> sets,
                                              AggregateOptions options,
                                              Handler<AsyncResult<String>> handler)

      Add multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZunionstore

          public Single<String> rxZunionstore(String destkey,
                                              List<String> sets,
                                              AggregateOptions options)

      Add multiple sorted sets and store the resulting sorted set in a new key
      Parameters:
        `destkey` - Destination key
        `sets` - List of keys identifying sorted sets
        `options` - Aggregation options
      Returns:

    - #### zunionstoreWeighed

          public RedisTransaction zunionstoreWeighed(String key,
                                                     Map<String,Double> sets,
                                                     AggregateOptions options,
                                                     Handler<AsyncResult<String>> handler)

      Add multiple sorted sets using weights, and store the resulting sorted set in a new key
      Parameters:
        `key` - Destination key
        `sets` - Map containing set-key:weight pairs
        `options` - Aggregation options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZunionstoreWeighed

          public Single<String> rxZunionstoreWeighed(String key,
                                                     Map<String,Double> sets,
                                                     AggregateOptions options)

      Add multiple sorted sets using weights, and store the resulting sorted set in a new key
      Parameters:
        `key` - Destination key
        `sets` - Map containing set-key:weight pairs
        `options` - Aggregation options
      Returns:

    - #### scan

          public RedisTransaction scan(String cursor,
                                       ScanOptions options,
                                       Handler<AsyncResult<String>> handler)

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

    - #### rxScan

          public Single<String> rxScan(String cursor,
                                       ScanOptions options)

      Incrementally iterate the keys space
      Parameters:
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### sscan

          public RedisTransaction sscan(String key,
                                        String cursor,
                                        ScanOptions options,
                                        Handler<AsyncResult<String>> handler)

      Incrementally iterate Set elements
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxSscan

          public Single<String> rxSscan(String key,
                                        String cursor,
                                        ScanOptions options)

      Incrementally iterate Set elements
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### hscan

          public RedisTransaction hscan(String key,
                                        String cursor,
                                        ScanOptions options,
                                        Handler<AsyncResult<String>> handler)

      Incrementally iterate hash fields and associated values
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxHscan

          public Single<String> rxHscan(String key,
                                        String cursor,
                                        ScanOptions options)

      Incrementally iterate hash fields and associated values
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### zscan

          public RedisTransaction zscan(String key,
                                        String cursor,
                                        ScanOptions options,
                                        Handler<AsyncResult<String>> handler)

      Incrementally iterate sorted sets elements and associated scores
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxZscan

          public Single<String> rxZscan(String key,
                                        String cursor,
                                        ScanOptions options)

      Incrementally iterate sorted sets elements and associated scores
      Parameters:
        `key` - Key string
        `cursor` - Cursor id
        `options` - Scan options
      Returns:

    - #### geoadd

          public RedisTransaction geoadd(String key,
                                         double longitude,
                                         double latitude,
                                         String member,
                                         Handler<AsyncResult<String>> handler)

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `member` - member
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeoadd

          public Single<String> rxGeoadd(String key,
                                         double longitude,
                                         double latitude,
                                         String member)

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `member` - member
      Returns:

    - #### geoaddMany

          public RedisTransaction geoaddMany(String key,
                                             List<GeoMember> members,
                                             Handler<AsyncResult<String>> handler)

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `members` - list of <lon, lat, member>
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeoaddMany

          public Single<String> rxGeoaddMany(String key,
                                             List<GeoMember> members)

      Add one or more geospatial items in the geospatial index represented using a sorted set.
      Parameters:
        `key` - Key string
        `members` - list of <lon, lat, member>
      Returns:

    - #### geohash

          public RedisTransaction geohash(String key,
                                          String member,
                                          Handler<AsyncResult<String>> handler)

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `member` - member
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeohash

          public Single<String> rxGeohash(String key,
                                          String member)

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `member` - member
      Returns:

    - #### geohashMany

          public RedisTransaction geohashMany(String key,
                                              List<String> members,
                                              Handler<AsyncResult<String>> handler)

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `members` - list of members
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeohashMany

          public Single<String> rxGeohashMany(String key,
                                              List<String> members)

      Return valid Geohash strings representing the position of one or more elements in a sorted set value representing a geospatial index (where elements were added using GEOADD).
      Parameters:
        `key` - Key string
        `members` - list of members
      Returns:

    - #### geopos

          public RedisTransaction geopos(String key,
                                         String member,
                                         Handler<AsyncResult<String>> handler)

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `member` - member
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeopos

          public Single<String> rxGeopos(String key,
                                         String member)

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `member` - member
      Returns:

    - #### geoposMany

          public RedisTransaction geoposMany(String key,
                                             List<String> members,
                                             Handler<AsyncResult<String>> handler)

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `members` - list of members
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeoposMany

          public Single<String> rxGeoposMany(String key,
                                             List<String> members)

      Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the sorted set at key.
      Parameters:
        `key` - Key string
        `members` - list of members
      Returns:

    - #### geodist

          public RedisTransaction geodist(String key,
                                          String member1,
                                          String member2,
                                          Handler<AsyncResult<String>> handler)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeodist

          public Single<String> rxGeodist(String key,
                                          String member1,
                                          String member2)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
      Returns:

    - #### geodistWithUnit

          public RedisTransaction geodistWithUnit(String key,
                                                  String member1,
                                                  String member2,
                                                  GeoUnit unit,
                                                  Handler<AsyncResult<String>> handler)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
        `unit` - geo unit
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeodistWithUnit

          public Single<String> rxGeodistWithUnit(String key,
                                                  String member1,
                                                  String member2,
                                                  GeoUnit unit)

      Return the distance between two members in the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member1` - member 1
        `member2` - member 2
        `unit` - geo unit
      Returns:

    - #### georadius

          public RedisTransaction georadius(String key,
                                            double longitude,
                                            double latitude,
                                            double radius,
                                            GeoUnit unit,
                                            Handler<AsyncResult<String>> handler)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeoradius

          public Single<String> rxGeoradius(String key,
                                            double longitude,
                                            double latitude,
                                            double radius,
                                            GeoUnit unit)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
      Returns:

    - #### georadiusWithOptions

          public RedisTransaction georadiusWithOptions(String key,
                                                       double longitude,
                                                       double latitude,
                                                       double radius,
                                                       GeoUnit unit,
                                                       GeoRadiusOptions options,
                                                       Handler<AsyncResult<String>> handler)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeoradiusWithOptions

          public Single<String> rxGeoradiusWithOptions(String key,
                                                       double longitude,
                                                       double latitude,
                                                       double radius,
                                                       GeoUnit unit,
                                                       GeoRadiusOptions options)

      Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders of the area specified with the center location and the maximum distance from the center (the radius).
      Parameters:
        `key` - Key string
        `longitude` - longitude
        `latitude` - latitude
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
      Returns:

    - #### georadiusbymember

          public RedisTransaction georadiusbymember(String key,
                                                    String member,
                                                    double radius,
                                                    GeoUnit unit,
                                                    Handler<AsyncResult<String>> handler)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeoradiusbymember

          public Single<String> rxGeoradiusbymember(String key,
                                                    String member,
                                                    double radius,
                                                    GeoUnit unit)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
      Returns:

    - #### georadiusbymemberWithOptions

          public RedisTransaction georadiusbymemberWithOptions(String key,
                                                               String member,
                                                               double radius,
                                                               GeoUnit unit,
                                                               GeoRadiusOptions options,
                                                               Handler<AsyncResult<String>> handler)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
        `handler` - Handler for the result of this call.
      Returns:

    - #### rxGeoradiusbymemberWithOptions

          public Single<String> rxGeoradiusbymemberWithOptions(String key,
                                                               String member,
                                                               double radius,
                                                               GeoUnit unit,
                                                               GeoRadiusOptions options)

      This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set.
      Parameters:
        `key` - Key string
        `member` - member
        `radius` - radius
        `unit` - geo unit
        `options` - geo radius options
      Returns:

    - #### unlink

          public RedisTransaction unlink(String key,
                                         Handler<AsyncResult<String>> handler)

      Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
      Parameters:
        `key` - Key string
        `handler` -
      Returns:

    - #### rxUnlink

          public Single<String> rxUnlink(String key)

      Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
      Parameters:
        `key` - Key string
      Returns:

    - #### unlinkMany

          public RedisTransaction unlinkMany(List<String> keys,
                                             Handler<AsyncResult<String>> handler)

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

    - #### rxUnlinkMany

          public Single<String> rxUnlinkMany(List<String> keys)

      Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
      Parameters:
        `keys` - List of keys to delete
      Returns:

    - #### swapdb

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

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

    - #### rxSwapdb

          public Single<String> rxSwapdb(int index1,
                                         int index2)

      Swaps two Redis databases
      Parameters:
        `index1` - index of first database to swap
        `index2` - index of second database to swap
      Returns:

    - #### newInstance

          public static RedisTransaction newInstance(RedisTransaction arg)

Copyright © 2020 Eclipse. All rights reserved.