io.vertx.rxjava.redis.client

## Class RedisAPI

- java.lang.Object
- - io.vertx.rxjava.redis.client.RedisAPI

- All Implemented Interfaces:
    io.vertx.lang.rx.RxDelegate

      public class RedisAPI
      extends Object
      implements io.vertx.lang.rx.RxDelegate

  Auto generated Redis API client wrapper.

  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<RedisAPI>` | `__TYPE_ARG`

  - ### Constructor Summary

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

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `RedisAPI` | `acl(List<String> args)` A container for Access List Control commands.
    `RedisAPI` | `acl(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Access List Control commands.
    `static RedisAPI` | `api(Redis client)`
    `static RedisAPI` | `api(RedisConnection connection)`
    `RedisAPI` | `append(String arg0, String arg1)` Append a value to a key.
    `RedisAPI` | `append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Append a value to a key.
    `RedisAPI` | `asking()` Sent by cluster clients after an -ASK redirect.
    `RedisAPI` | `asking(Handler<AsyncResult<Response>> handler)` Sent by cluster clients after an -ASK redirect.
    `RedisAPI` | `auth(List<String> args)` Authenticate to the server.
    `RedisAPI` | `auth(List<String> args, Handler<AsyncResult<Response>> handler)` Authenticate to the server.
    `RedisAPI` | `bfAdd(List<String> args)` Redis command BF.ADD.
    `RedisAPI` | `bfAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.ADD.
    `RedisAPI` | `bfCard(List<String> args)` Redis command BF.CARD.
    `RedisAPI` | `bfCard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.CARD.
    `RedisAPI` | `bfDebug(List<String> args)` Redis command BF.DEBUG.
    `RedisAPI` | `bfDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.DEBUG.
    `RedisAPI` | `bfExists(List<String> args)` Redis command BF.EXISTS.
    `RedisAPI` | `bfExists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.EXISTS.
    `RedisAPI` | `bfInfo(List<String> args)` Redis command BF.INFO.
    `RedisAPI` | `bfInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.INFO.
    `RedisAPI` | `bfInsert(List<String> args)` Redis command BF.INSERT.
    `RedisAPI` | `bfInsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.INSERT.
    `RedisAPI` | `bfLoadchunk(List<String> args)` Redis command BF.LOADCHUNK.
    `RedisAPI` | `bfLoadchunk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.LOADCHUNK.
    `RedisAPI` | `bfMadd(List<String> args)` Redis command BF.MADD.
    `RedisAPI` | `bfMadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.MADD.
    `RedisAPI` | `bfMexists(List<String> args)` Redis command BF.MEXISTS.
    `RedisAPI` | `bfMexists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.MEXISTS.
    `RedisAPI` | `bfReserve(List<String> args)` Redis command BF.RESERVE.
    `RedisAPI` | `bfReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.RESERVE.
    `RedisAPI` | `bfScandump(List<String> args)` Redis command BF.SCANDUMP.
    `RedisAPI` | `bfScandump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BF.SCANDUMP.
    `RedisAPI` | `bgrewriteaof()` Asynchronously rewrite the append-only file.
    `RedisAPI` | `bgrewriteaof(Handler<AsyncResult<Response>> handler)` Asynchronously rewrite the append-only file.
    `RedisAPI` | `bgsave(List<String> args)` Asynchronously save the dataset to disk.
    `RedisAPI` | `bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Asynchronously save the dataset to disk.
    `RedisAPI` | `bitcount(List<String> args)` Count set bits in a string.
    `RedisAPI` | `bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Count set bits in a string.
    `RedisAPI` | `bitfield(List<String> args)` Perform arbitrary bitfield integer operations on strings.
    `RedisAPI` | `bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisAPI` | `bitfieldRo(List<String> args)` Perform arbitrary bitfield integer operations on strings.
    `RedisAPI` | `bitfieldRo(List<String> args, Handler<AsyncResult<Response>> handler)` Perform arbitrary bitfield integer operations on strings.
    `RedisAPI` | `bitop(List<String> args)` Perform bitwise operations between strings.
    `RedisAPI` | `bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Perform bitwise operations between strings.
    `RedisAPI` | `bitpos(List<String> args)` Find first bit set or clear in a string.
    `RedisAPI` | `bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Find first bit set or clear in a string.
    `RedisAPI` | `blmove(String arg0, String arg1, String arg2, String arg3, String arg4)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `RedisAPI` | `blmove(String arg0, String arg1, String arg2, String arg3, String arg4, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `RedisAPI` | `blmpop(List<String> args)` Pop elements from a list, or block until one is available.
    `RedisAPI` | `blmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Pop elements from a list, or block until one is available.
    `RedisAPI` | `blpop(List<String> args)` Remove and get the first element in a list, or block until one is available.
    `RedisAPI` | `blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the first element in a list, or block until one is available.
    `RedisAPI` | `brpop(List<String> args)` Remove and get the last element in a list, or block until one is available.
    `RedisAPI` | `brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the last element in a list, or block until one is available.
    `RedisAPI` | `brpoplpush(String arg0, String arg1, String arg2)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `RedisAPI` | `brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `RedisAPI` | `bzmpop(List<String> args)` Remove and return members with scores in a sorted set or block until one is available.
    `RedisAPI` | `bzmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with scores in a sorted set or block until one is available.
    `RedisAPI` | `bzpopmax(List<String> args)` Remove and return the member with the highest score from one or more sorted sets, or block until one is available.
    `RedisAPI` | `bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return the member with the highest score from one or more sorted sets, or block until one is available.
    `RedisAPI` | `bzpopmin(List<String> args)` Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.
    `RedisAPI` | `bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.
    `RedisAPI` | `cfAdd(List<String> args)` Redis command CF.ADD.
    `RedisAPI` | `cfAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.ADD.
    `RedisAPI` | `cfAddnx(List<String> args)` Redis command CF.ADDNX.
    `RedisAPI` | `cfAddnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.ADDNX.
    `RedisAPI` | `cfCompact(List<String> args)` Redis command CF.COMPACT.
    `RedisAPI` | `cfCompact(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.COMPACT.
    `RedisAPI` | `cfCount(List<String> args)` Redis command CF.COUNT.
    `RedisAPI` | `cfCount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.COUNT.
    `RedisAPI` | `cfDebug(List<String> args)` Redis command CF.DEBUG.
    `RedisAPI` | `cfDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.DEBUG.
    `RedisAPI` | `cfDel(List<String> args)` Redis command CF.DEL.
    `RedisAPI` | `cfDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.DEL.
    `RedisAPI` | `cfExists(List<String> args)` Redis command CF.EXISTS.
    `RedisAPI` | `cfExists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.EXISTS.
    `RedisAPI` | `cfInfo(List<String> args)` Redis command CF.INFO.
    `RedisAPI` | `cfInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INFO.
    `RedisAPI` | `cfInsert(List<String> args)` Redis command CF.INSERT.
    `RedisAPI` | `cfInsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INSERT.
    `RedisAPI` | `cfInsertnx(List<String> args)` Redis command CF.INSERTNX.
    `RedisAPI` | `cfInsertnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.INSERTNX.
    `RedisAPI` | `cfLoadchunk(List<String> args)` Redis command CF.LOADCHUNK.
    `RedisAPI` | `cfLoadchunk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.LOADCHUNK.
    `RedisAPI` | `cfMexists(List<String> args)` Redis command CF.MEXISTS.
    `RedisAPI` | `cfMexists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.MEXISTS.
    `RedisAPI` | `cfReserve(List<String> args)` Redis command CF.RESERVE.
    `RedisAPI` | `cfReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.RESERVE.
    `RedisAPI` | `cfScandump(List<String> args)` Redis command CF.SCANDUMP.
    `RedisAPI` | `cfScandump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CF.SCANDUMP.
    `RedisAPI` | `client(List<String> args)` A container for client connection commands.
    `RedisAPI` | `client(List<String> args, Handler<AsyncResult<Response>> handler)` A container for client connection commands.
    `void` | `close()`
    `RedisAPI` | `cluster(List<String> args)` A container for cluster commands.
    `RedisAPI` | `cluster(List<String> args, Handler<AsyncResult<Response>> handler)` A container for cluster commands.
    `RedisAPI` | `cmsIncrby(List<String> args)` Redis command CMS.INCRBY.
    `RedisAPI` | `cmsIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INCRBY.
    `RedisAPI` | `cmsInfo(List<String> args)` Redis command CMS.INFO.
    `RedisAPI` | `cmsInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INFO.
    `RedisAPI` | `cmsInitbydim(List<String> args)` Redis command CMS.INITBYDIM.
    `RedisAPI` | `cmsInitbydim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INITBYDIM.
    `RedisAPI` | `cmsInitbyprob(List<String> args)` Redis command CMS.INITBYPROB.
    `RedisAPI` | `cmsInitbyprob(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.INITBYPROB.
    `RedisAPI` | `cmsMerge(List<String> args)` Redis command CMS.MERGE.
    `RedisAPI` | `cmsMerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.MERGE.
    `RedisAPI` | `cmsQuery(List<String> args)` Redis command CMS.QUERY.
    `RedisAPI` | `cmsQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CMS.QUERY.
    `RedisAPI` | `command(List<String> args)` Get array of Redis command details.
    `RedisAPI` | `command(List<String> args, Handler<AsyncResult<Response>> handler)` Get array of Redis command details.
    `RedisAPI` | `config(List<String> args)` A container for server configuration commands.
    `RedisAPI` | `config(List<String> args, Handler<AsyncResult<Response>> handler)` A container for server configuration commands.
    `RedisAPI` | `copy(List<String> args)` Copy a key.
    `RedisAPI` | `copy(List<String> args, Handler<AsyncResult<Response>> handler)` Copy a key.
    `RedisAPI` | `dbsize()` Return the number of keys in the selected database.
    `RedisAPI` | `dbsize(Handler<AsyncResult<Response>> handler)` Return the number of keys in the selected database.
    `RedisAPI` | `debug(List<String> args)` A container for debugging commands.
    `RedisAPI` | `debug(List<String> args, Handler<AsyncResult<Response>> handler)` A container for debugging commands.
    `RedisAPI` | `decr(String arg0)` Decrement the integer value of a key by one.
    `RedisAPI` | `decr(String arg0, Handler<AsyncResult<Response>> handler)` Decrement the integer value of a key by one.
    `RedisAPI` | `decrby(String arg0, String arg1)` Decrement the integer value of a key by the given number.
    `RedisAPI` | `decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Decrement the integer value of a key by the given number.
    `RedisAPI` | `del(List<String> args)` Delete a key.
    `RedisAPI` | `del(List<String> args, Handler<AsyncResult<Response>> handler)` Delete a key.
    `RedisAPI` | `discard()` Discard all commands issued after MULTI.
    `RedisAPI` | `discard(Handler<AsyncResult<Response>> handler)` Discard all commands issued after MULTI.
    `RedisAPI` | `dump(String arg0)` Return a serialized version of the value stored at the specified key.
    `RedisAPI` | `dump(String arg0, Handler<AsyncResult<Response>> handler)` Return a serialized version of the value stored at the specified key.
    `RedisAPI` | `echo(String arg0)` Echo the given string.
    `RedisAPI` | `echo(String arg0, Handler<AsyncResult<Response>> handler)` Echo the given string.
    `boolean` | `equals(Object o)`
    `RedisAPI` | `eval(List<String> args)` Execute a Lua script server side.
    `RedisAPI` | `eval(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a Lua script server side.
    `RedisAPI` | `evalRo(List<String> args)` Execute a read-only Lua script server side.
    `RedisAPI` | `evalRo(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a read-only Lua script server side.
    `RedisAPI` | `evalsha(List<String> args)` Execute a Lua script server side.
    `RedisAPI` | `evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a Lua script server side.
    `RedisAPI` | `evalshaRo(List<String> args)` Execute a read-only Lua script server side.
    `RedisAPI` | `evalshaRo(List<String> args, Handler<AsyncResult<Response>> handler)` Execute a read-only Lua script server side.
    `RedisAPI` | `exec()` Execute all commands issued after MULTI.
    `RedisAPI` | `exec(Handler<AsyncResult<Response>> handler)` Execute all commands issued after MULTI.
    `RedisAPI` | `exists(List<String> args)` Determine if a key exists.
    `RedisAPI` | `exists(List<String> args, Handler<AsyncResult<Response>> handler)` Determine if a key exists.
    `RedisAPI` | `expire(List<String> args)` Set a key's time to live in seconds.
    `RedisAPI` | `expire(List<String> args, Handler<AsyncResult<Response>> handler)` Set a key's time to live in seconds.
    `RedisAPI` | `expireat(List<String> args)` Set the expiration for a key as a UNIX timestamp.
    `RedisAPI` | `expireat(List<String> args, Handler<AsyncResult<Response>> handler)` Set the expiration for a key as a UNIX timestamp.
    `RedisAPI` | `expiretime(String arg0)` Get the expiration Unix timestamp for a key.
    `RedisAPI` | `expiretime(String arg0, Handler<AsyncResult<Response>> handler)` Get the expiration Unix timestamp for a key.
    `RedisAPI` | `failover(List<String> args)` Start a coordinated failover between this server and one of its replicas.
    `RedisAPI` | `failover(List<String> args, Handler<AsyncResult<Response>> handler)` Start a coordinated failover between this server and one of its replicas.
    `RedisAPI` | `fcall(List<String> args)` Invoke a function.
    `RedisAPI` | `fcall(List<String> args, Handler<AsyncResult<Response>> handler)` Invoke a function.
    `RedisAPI` | `fcallRo(List<String> args)` Invoke a read-only function.
    `RedisAPI` | `fcallRo(List<String> args, Handler<AsyncResult<Response>> handler)` Invoke a read-only function.
    `RedisAPI` | `flushall(List<String> args)` Remove all keys from all databases.
    `RedisAPI` | `flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Remove all keys from all databases.
    `RedisAPI` | `flushdb(List<String> args)` Remove all keys from the current database.
    `RedisAPI` | `flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Remove all keys from the current database.
    `RedisAPI` | `ftAdd(List<String> args)` Redis command FT.ADD.
    `RedisAPI` | `ftAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ADD.
    `RedisAPI` | `ftAggregate(List<String> args)` Redis command FT.AGGREGATE.
    `RedisAPI` | `ftAggregate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.AGGREGATE.
    `RedisAPI` | `ftAliasadd(List<String> args)` Redis command FT.ALIASADD.
    `RedisAPI` | `ftAliasadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASADD.
    `RedisAPI` | `ftAliasaddifnx(List<String> args)` Redis command FT._ALIASADDIFNX.
    `RedisAPI` | `ftAliasaddifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALIASADDIFNX.
    `RedisAPI` | `ftAliasdel(List<String> args)` Redis command FT.ALIASDEL.
    `RedisAPI` | `ftAliasdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASDEL.
    `RedisAPI` | `ftAliasdelifx(List<String> args)` Redis command FT._ALIASDELIFX.
    `RedisAPI` | `ftAliasdelifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALIASDELIFX.
    `RedisAPI` | `ftAliasupdate(List<String> args)` Redis command FT.ALIASUPDATE.
    `RedisAPI` | `ftAliasupdate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALIASUPDATE.
    `RedisAPI` | `ftAlter(List<String> args)` Redis command FT.ALTER.
    `RedisAPI` | `ftAlter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.ALTER.
    `RedisAPI` | `ftAlterifnx(List<String> args)` Redis command FT._ALTERIFNX.
    `RedisAPI` | `ftAlterifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._ALTERIFNX.
    `RedisAPI` | `ftConfig(List<String> args)` Redis command FT.CONFIG.
    `RedisAPI` | `ftConfig(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CONFIG.
    `RedisAPI` | `ftCreate(List<String> args)` Redis command FT.CREATE.
    `RedisAPI` | `ftCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CREATE.
    `RedisAPI` | `ftCreateifnx(List<String> args)` Redis command FT._CREATEIFNX.
    `RedisAPI` | `ftCreateifnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._CREATEIFNX.
    `RedisAPI` | `ftCursor(List<String> args)` Redis command FT.CURSOR.
    `RedisAPI` | `ftCursor(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.CURSOR.
    `RedisAPI` | `ftDebug(List<String> args)` Redis command FT.DEBUG.
    `RedisAPI` | `ftDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DEBUG.
    `RedisAPI` | `ftDel(List<String> args)` Redis command FT.DEL.
    `RedisAPI` | `ftDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DEL.
    `RedisAPI` | `ftDictadd(List<String> args)` Redis command FT.DICTADD.
    `RedisAPI` | `ftDictadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTADD.
    `RedisAPI` | `ftDictdel(List<String> args)` Redis command FT.DICTDEL.
    `RedisAPI` | `ftDictdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTDEL.
    `RedisAPI` | `ftDictdump(List<String> args)` Redis command FT.DICTDUMP.
    `RedisAPI` | `ftDictdump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DICTDUMP.
    `RedisAPI` | `ftDrop(List<String> args)` Redis command FT.DROP.
    `RedisAPI` | `ftDrop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DROP.
    `RedisAPI` | `ftDropifx(List<String> args)` Redis command FT._DROPIFX.
    `RedisAPI` | `ftDropifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._DROPIFX.
    `RedisAPI` | `ftDropindex(List<String> args)` Redis command FT.DROPINDEX.
    `RedisAPI` | `ftDropindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.DROPINDEX.
    `RedisAPI` | `ftDropindexifx(List<String> args)` Redis command FT._DROPINDEXIFX.
    `RedisAPI` | `ftDropindexifx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._DROPINDEXIFX.
    `RedisAPI` | `ftExplain(List<String> args)` Redis command FT.EXPLAIN.
    `RedisAPI` | `ftExplain(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.EXPLAIN.
    `RedisAPI` | `ftExplaincli(List<String> args)` Redis command FT.EXPLAINCLI.
    `RedisAPI` | `ftExplaincli(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.EXPLAINCLI.
    `RedisAPI` | `ftGet(List<String> args)` Redis command FT.GET.
    `RedisAPI` | `ftGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.GET.
    `RedisAPI` | `ftInfo(List<String> args)` Redis command FT.INFO.
    `RedisAPI` | `ftInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.INFO.
    `RedisAPI` | `ftList(List<String> args)` Redis command FT._LIST.
    `RedisAPI` | `ftList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT._LIST.
    `RedisAPI` | `ftMget(List<String> args)` Redis command FT.MGET.
    `RedisAPI` | `ftMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.MGET.
    `RedisAPI` | `ftProfile(List<String> args)` Redis command FT.PROFILE.
    `RedisAPI` | `ftProfile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.PROFILE.
    `RedisAPI` | `ftSafeadd(List<String> args)` Redis command FT.SAFEADD.
    `RedisAPI` | `ftSafeadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SAFEADD.
    `RedisAPI` | `ftSearch(List<String> args)` Redis command FT.SEARCH.
    `RedisAPI` | `ftSearch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SEARCH.
    `RedisAPI` | `ftSpellcheck(List<String> args)` Redis command FT.SPELLCHECK.
    `RedisAPI` | `ftSpellcheck(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SPELLCHECK.
    `RedisAPI` | `ftSugadd(List<String> args)` Redis command FT.SUGADD.
    `RedisAPI` | `ftSugadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGADD.
    `RedisAPI` | `ftSugdel(List<String> args)` Redis command FT.SUGDEL.
    `RedisAPI` | `ftSugdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGDEL.
    `RedisAPI` | `ftSugget(List<String> args)` Redis command FT.SUGGET.
    `RedisAPI` | `ftSugget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGGET.
    `RedisAPI` | `ftSuglen(List<String> args)` Redis command FT.SUGLEN.
    `RedisAPI` | `ftSuglen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SUGLEN.
    `RedisAPI` | `ftSynadd(List<String> args)` Redis command FT.SYNADD.
    `RedisAPI` | `ftSynadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNADD.
    `RedisAPI` | `ftSyndump(List<String> args)` Redis command FT.SYNDUMP.
    `RedisAPI` | `ftSyndump(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNDUMP.
    `RedisAPI` | `ftSynupdate(List<String> args)` Redis command FT.SYNUPDATE.
    `RedisAPI` | `ftSynupdate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.SYNUPDATE.
    `RedisAPI` | `ftTagvals(List<String> args)` Redis command FT.TAGVALS.
    `RedisAPI` | `ftTagvals(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FT.TAGVALS.
    `RedisAPI` | `function(List<String> args)` A container for function commands.
    `RedisAPI` | `function(List<String> args, Handler<AsyncResult<Response>> handler)` A container for function commands.
    `RedisAPI` | `geoadd(List<String> args)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisAPI` | `geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `RedisAPI` | `geodist(List<String> args)` Returns the distance between two members of a geospatial index.
    `RedisAPI` | `geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Returns the distance between two members of a geospatial index.
    `RedisAPI` | `geohash(List<String> args)` Returns members of a geospatial index as standard geohash strings.
    `RedisAPI` | `geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Returns members of a geospatial index as standard geohash strings.
    `RedisAPI` | `geopos(List<String> args)` Returns longitude and latitude of members of a geospatial index.
    `RedisAPI` | `geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Returns longitude and latitude of members of a geospatial index.
    `RedisAPI` | `georadius(List<String> args)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
    `RedisAPI` | `georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
    `RedisAPI` | `georadiusbymember(List<String> args)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
    `RedisAPI` | `georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
    `RedisAPI` | `georadiusbymemberRo(List<String> args)` A read-only variant for GEORADIUSBYMEMBER.
    `RedisAPI` | `georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` A read-only variant for GEORADIUSBYMEMBER.
    `RedisAPI` | `georadiusRo(List<String> args)` A read-only variant for GEORADIUS.
    `RedisAPI` | `georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` A read-only variant for GEORADIUS.
    `RedisAPI` | `geosearch(List<String> args)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
    `RedisAPI` | `geosearch(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
    `RedisAPI` | `geosearchstore(List<String> args)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.
    `RedisAPI` | `geosearchstore(List<String> args, Handler<AsyncResult<Response>> handler)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.
    `RedisAPI` | `get(String arg0)` Get the value of a key.
    `RedisAPI` | `get(String arg0, Handler<AsyncResult<Response>> handler)` Get the value of a key.
    `RedisAPI` | `getbit(String arg0, String arg1)` Returns the bit value at offset in the string value stored at key.
    `RedisAPI` | `getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Returns the bit value at offset in the string value stored at key.
    `RedisAPI` | `getdel(String arg0)` Get the value of a key and delete the key.
    `RedisAPI` | `getdel(String arg0, Handler<AsyncResult<Response>> handler)` Get the value of a key and delete the key.
    `RedisAPI` | `getDelegate()`
    `RedisAPI` | `getex(List<String> args)` Get the value of a key and optionally set its expiration.
    `RedisAPI` | `getex(List<String> args, Handler<AsyncResult<Response>> handler)` Get the value of a key and optionally set its expiration.
    `RedisAPI` | `getrange(String arg0, String arg1, String arg2)` Get a substring of the string stored at a key.
    `RedisAPI` | `getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a substring of the string stored at a key.
    `RedisAPI` | `getset(String arg0, String arg1)` Set the string value of a key and return its old value.
    `RedisAPI` | `getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Set the string value of a key and return its old value.
    `RedisAPI` | `graphBulk(List<String> args)` Redis command GRAPH.BULK.
    `RedisAPI` | `graphBulk(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.BULK.
    `RedisAPI` | `graphConfig(List<String> args)` Redis command GRAPH.CONFIG.
    `RedisAPI` | `graphConfig(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.CONFIG.
    `RedisAPI` | `graphDebug(List<String> args)` Redis command GRAPH.DEBUG.
    `RedisAPI` | `graphDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.DEBUG.
    `RedisAPI` | `graphDelete(List<String> args)` Redis command GRAPH.DELETE.
    `RedisAPI` | `graphDelete(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.DELETE.
    `RedisAPI` | `graphExplain(List<String> args)` Redis command GRAPH.EXPLAIN.
    `RedisAPI` | `graphExplain(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.EXPLAIN.
    `RedisAPI` | `graphList(List<String> args)` Redis command GRAPH.LIST.
    `RedisAPI` | `graphList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.LIST.
    `RedisAPI` | `graphProfile(List<String> args)` Redis command GRAPH.PROFILE.
    `RedisAPI` | `graphProfile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.PROFILE.
    `RedisAPI` | `graphQuery(List<String> args)` Redis command GRAPH.QUERY.
    `RedisAPI` | `graphQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.QUERY.
    `RedisAPI` | `graphRoQuery(List<String> args)` Redis command GRAPH.RO_QUERY.
    `RedisAPI` | `graphRoQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.RO_QUERY.
    `RedisAPI` | `graphSlowlog(List<String> args)` Redis command GRAPH.SLOWLOG.
    `RedisAPI` | `graphSlowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GRAPH.SLOWLOG.
    `int` | `hashCode()`
    `RedisAPI` | `hdel(List<String> args)` Delete one or more hash fields.
    `RedisAPI` | `hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Delete one or more hash fields.
    `RedisAPI` | `hello(List<String> args)` Handshake with Redis.
    `RedisAPI` | `hello(List<String> args, Handler<AsyncResult<Response>> handler)` Handshake with Redis.
    `RedisAPI` | `hexists(String arg0, String arg1)` Determine if a hash field exists.
    `RedisAPI` | `hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine if a hash field exists.
    `RedisAPI` | `hget(String arg0, String arg1)` Get the value of a hash field.
    `RedisAPI` | `hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the value of a hash field.
    `RedisAPI` | `hgetall(String arg0)` Get all the fields and values in a hash.
    `RedisAPI` | `hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Get all the fields and values in a hash.
    `RedisAPI` | `hincrby(String arg0, String arg1, String arg2)` Increment the integer value of a hash field by the given number.
    `RedisAPI` | `hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the integer value of a hash field by the given number.
    `RedisAPI` | `hincrbyfloat(String arg0, String arg1, String arg2)` Increment the float value of a hash field by the given amount.
    `RedisAPI` | `hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the float value of a hash field by the given amount.
    `RedisAPI` | `hkeys(String arg0)` Get all the fields in a hash.
    `RedisAPI` | `hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Get all the fields in a hash.
    `RedisAPI` | `hlen(String arg0)` Get the number of fields in a hash.
    `RedisAPI` | `hlen(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of fields in a hash.
    `RedisAPI` | `hmget(List<String> args)` Get the values of all the given hash fields.
    `RedisAPI` | `hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Get the values of all the given hash fields.
    `RedisAPI` | `hmset(List<String> args)` Set multiple hash fields to multiple values.
    `RedisAPI` | `hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple hash fields to multiple values.
    `RedisAPI` | `hrandfield(List<String> args)` Get one or multiple random fields from a hash.
    `RedisAPI` | `hrandfield(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random fields from a hash.
    `RedisAPI` | `hscan(List<String> args)` Incrementally iterate hash fields and associated values.
    `RedisAPI` | `hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate hash fields and associated values.
    `RedisAPI` | `hset(List<String> args)` Set the string value of a hash field.
    `RedisAPI` | `hset(List<String> args, Handler<AsyncResult<Response>> handler)` Set the string value of a hash field.
    `RedisAPI` | `hsetnx(String arg0, String arg1, String arg2)` Set the value of a hash field, only if the field does not exist.
    `RedisAPI` | `hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value of a hash field, only if the field does not exist.
    `RedisAPI` | `hstrlen(String arg0, String arg1)` Get the length of the value of a hash field.
    `RedisAPI` | `hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the length of the value of a hash field.
    `RedisAPI` | `hvals(String arg0)` Get all the values in a hash.
    `RedisAPI` | `hvals(String arg0, Handler<AsyncResult<Response>> handler)` Get all the values in a hash.
    `RedisAPI` | `incr(String arg0)` Increment the integer value of a key by one.
    `RedisAPI` | `incr(String arg0, Handler<AsyncResult<Response>> handler)` Increment the integer value of a key by one.
    `RedisAPI` | `incrby(String arg0, String arg1)` Increment the integer value of a key by the given amount.
    `RedisAPI` | `incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Increment the integer value of a key by the given amount.
    `RedisAPI` | `incrbyfloat(String arg0, String arg1)` Increment the float value of a key by the given amount.
    `RedisAPI` | `incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Increment the float value of a key by the given amount.
    `RedisAPI` | `info(List<String> args)` Get information and statistics about the server.
    `RedisAPI` | `info(List<String> args, Handler<AsyncResult<Response>> handler)` Get information and statistics about the server.
    `RedisAPI` | `jsonArrappend(List<String> args)` Redis command JSON.ARRAPPEND.
    `RedisAPI` | `jsonArrappend(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRAPPEND.
    `RedisAPI` | `jsonArrindex(List<String> args)` Redis command JSON.ARRINDEX.
    `RedisAPI` | `jsonArrindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRINDEX.
    `RedisAPI` | `jsonArrinsert(List<String> args)` Redis command JSON.ARRINSERT.
    `RedisAPI` | `jsonArrinsert(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRINSERT.
    `RedisAPI` | `jsonArrlen(List<String> args)` Redis command JSON.ARRLEN.
    `RedisAPI` | `jsonArrlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRLEN.
    `RedisAPI` | `jsonArrpop(List<String> args)` Redis command JSON.ARRPOP.
    `RedisAPI` | `jsonArrpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRPOP.
    `RedisAPI` | `jsonArrtrim(List<String> args)` Redis command JSON.ARRTRIM.
    `RedisAPI` | `jsonArrtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.ARRTRIM.
    `RedisAPI` | `jsonClear(List<String> args)` Redis command JSON.CLEAR.
    `RedisAPI` | `jsonClear(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.CLEAR.
    `RedisAPI` | `jsonDebug(List<String> args)` Redis command JSON.DEBUG.
    `RedisAPI` | `jsonDebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.DEBUG.
    `RedisAPI` | `jsonDel(List<String> args)` Redis command JSON.DEL.
    `RedisAPI` | `jsonDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.DEL.
    `RedisAPI` | `jsonForget(List<String> args)` Redis command JSON.FORGET.
    `RedisAPI` | `jsonForget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.FORGET.
    `RedisAPI` | `jsonGet(List<String> args)` Redis command JSON.GET.
    `RedisAPI` | `jsonGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.GET.
    `RedisAPI` | `jsonMget(List<String> args)` Redis command JSON.MGET.
    `RedisAPI` | `jsonMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.MGET.
    `RedisAPI` | `jsonNumincrby(List<String> args)` Redis command JSON.NUMINCRBY.
    `RedisAPI` | `jsonNumincrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMINCRBY.
    `RedisAPI` | `jsonNummultby(List<String> args)` Redis command JSON.NUMMULTBY.
    `RedisAPI` | `jsonNummultby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMMULTBY.
    `RedisAPI` | `jsonNumpowby(List<String> args)` Redis command JSON.NUMPOWBY.
    `RedisAPI` | `jsonNumpowby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.NUMPOWBY.
    `RedisAPI` | `jsonObjkeys(List<String> args)` Redis command JSON.OBJKEYS.
    `RedisAPI` | `jsonObjkeys(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.OBJKEYS.
    `RedisAPI` | `jsonObjlen(List<String> args)` Redis command JSON.OBJLEN.
    `RedisAPI` | `jsonObjlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.OBJLEN.
    `RedisAPI` | `jsonResp(List<String> args)` Redis command JSON.RESP.
    `RedisAPI` | `jsonResp(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.RESP.
    `RedisAPI` | `jsonSet(List<String> args)` Redis command JSON.SET.
    `RedisAPI` | `jsonSet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.SET.
    `RedisAPI` | `jsonStrappend(List<String> args)` Redis command JSON.STRAPPEND.
    `RedisAPI` | `jsonStrappend(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.STRAPPEND.
    `RedisAPI` | `jsonStrlen(List<String> args)` Redis command JSON.STRLEN.
    `RedisAPI` | `jsonStrlen(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.STRLEN.
    `RedisAPI` | `jsonToggle(List<String> args)` Redis command JSON.TOGGLE.
    `RedisAPI` | `jsonToggle(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.TOGGLE.
    `RedisAPI` | `jsonType(List<String> args)` Redis command JSON.TYPE.
    `RedisAPI` | `jsonType(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command JSON.TYPE.
    `RedisAPI` | `keys(String arg0)` Find all keys matching the given pattern.
    `RedisAPI` | `keys(String arg0, Handler<AsyncResult<Response>> handler)` Find all keys matching the given pattern.
    `RedisAPI` | `lastsave()` Get the UNIX time stamp of the last successful save to disk.
    `RedisAPI` | `lastsave(Handler<AsyncResult<Response>> handler)` Get the UNIX time stamp of the last successful save to disk.
    `RedisAPI` | `latency(List<String> args)` A container for latency diagnostics commands.
    `RedisAPI` | `latency(List<String> args, Handler<AsyncResult<Response>> handler)` A container for latency diagnostics commands.
    `RedisAPI` | `lcs(List<String> args)` Find longest common substring.
    `RedisAPI` | `lcs(List<String> args, Handler<AsyncResult<Response>> handler)` Find longest common substring.
    `RedisAPI` | `lindex(String arg0, String arg1)` Get an element from a list by its index.
    `RedisAPI` | `lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get an element from a list by its index.
    `RedisAPI` | `linsert(String arg0, String arg1, String arg2, String arg3)` Insert an element before or after another element in a list.
    `RedisAPI` | `linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Insert an element before or after another element in a list.
    `RedisAPI` | `llen(String arg0)` Get the length of a list.
    `RedisAPI` | `llen(String arg0, Handler<AsyncResult<Response>> handler)` Get the length of a list.
    `RedisAPI` | `lmove(String arg0, String arg1, String arg2, String arg3)` Pop an element from a list, push it to another list and return it.
    `RedisAPI` | `lmove(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Pop an element from a list, push it to another list and return it.
    `RedisAPI` | `lmpop(List<String> args)` Pop elements from a list.
    `RedisAPI` | `lmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Pop elements from a list.
    `RedisAPI` | `lolwut(List<String> args)` Display some computer art and the Redis version.
    `RedisAPI` | `lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Display some computer art and the Redis version.
    `RedisAPI` | `lpop(List<String> args)` Remove and get the first elements in a list.
    `RedisAPI` | `lpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the first elements in a list.
    `RedisAPI` | `lpos(List<String> args)` Return the index of matching elements on a list.
    `RedisAPI` | `lpos(List<String> args, Handler<AsyncResult<Response>> handler)` Return the index of matching elements on a list.
    `RedisAPI` | `lpush(List<String> args)` Prepend one or multiple elements to a list.
    `RedisAPI` | `lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Prepend one or multiple elements to a list.
    `RedisAPI` | `lpushx(List<String> args)` Prepend an element to a list, only if the list exists.
    `RedisAPI` | `lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Prepend an element to a list, only if the list exists.
    `RedisAPI` | `lrange(String arg0, String arg1, String arg2)` Get a range of elements from a list.
    `RedisAPI` | `lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a range of elements from a list.
    `RedisAPI` | `lrem(String arg0, String arg1, String arg2)` Remove elements from a list.
    `RedisAPI` | `lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove elements from a list.
    `RedisAPI` | `lset(String arg0, String arg1, String arg2)` Set the value of an element in a list by its index.
    `RedisAPI` | `lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value of an element in a list by its index.
    `RedisAPI` | `ltrim(String arg0, String arg1, String arg2)` Trim a list to the specified range.
    `RedisAPI` | `ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Trim a list to the specified range.
    `RedisAPI` | `memory(List<String> args)` A container for memory diagnostics commands.
    `RedisAPI` | `memory(List<String> args, Handler<AsyncResult<Response>> handler)` A container for memory diagnostics commands.
    `RedisAPI` | `mget(List<String> args)` Get the values of all the given keys.
    `RedisAPI` | `mget(List<String> args, Handler<AsyncResult<Response>> handler)` Get the values of all the given keys.
    `RedisAPI` | `migrate(List<String> args)` Atomically transfer a key from a Redis instance to another one.
    `RedisAPI` | `migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Atomically transfer a key from a Redis instance to another one.
    `RedisAPI` | `module(List<String> args)` A container for module commands.
    `RedisAPI` | `module(List<String> args, Handler<AsyncResult<Response>> handler)` A container for module commands.
    `RedisAPI` | `monitor()` Listen for all requests received by the server in real time.
    `RedisAPI` | `monitor(Handler<AsyncResult<Response>> handler)` Listen for all requests received by the server in real time.
    `RedisAPI` | `move(String arg0, String arg1)` Move a key to another database.
    `RedisAPI` | `move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Move a key to another database.
    `RedisAPI` | `mset(List<String> args)` Set multiple keys to multiple values.
    `RedisAPI` | `mset(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple keys to multiple values.
    `RedisAPI` | `msetnx(List<String> args)` Set multiple keys to multiple values, only if none of the keys exist.
    `RedisAPI` | `msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Set multiple keys to multiple values, only if none of the keys exist.
    `RedisAPI` | `multi()` Mark the start of a transaction block.
    `RedisAPI` | `multi(Handler<AsyncResult<Response>> handler)` Mark the start of a transaction block.
    `static RedisAPI` | `newInstance(RedisAPI arg)`
    `RedisAPI` | `object(List<String> args)` A container for object introspection commands.
    `RedisAPI` | `object(List<String> args, Handler<AsyncResult<Response>> handler)` A container for object introspection commands.
    `RedisAPI` | `persist(String arg0)` Remove the expiration from a key.
    `RedisAPI` | `persist(String arg0, Handler<AsyncResult<Response>> handler)` Remove the expiration from a key.
    `RedisAPI` | `pexpire(List<String> args)` Set a key's time to live in milliseconds.
    `RedisAPI` | `pexpire(List<String> args, Handler<AsyncResult<Response>> handler)` Set a key's time to live in milliseconds.
    `RedisAPI` | `pexpireat(List<String> args)` Set the expiration for a key as a UNIX timestamp specified in milliseconds.
    `RedisAPI` | `pexpireat(List<String> args, Handler<AsyncResult<Response>> handler)` Set the expiration for a key as a UNIX timestamp specified in milliseconds.
    `RedisAPI` | `pexpiretime(String arg0)` Get the expiration Unix timestamp for a key in milliseconds.
    `RedisAPI` | `pexpiretime(String arg0, Handler<AsyncResult<Response>> handler)` Get the expiration Unix timestamp for a key in milliseconds.
    `RedisAPI` | `pfadd(List<String> args)` Adds the specified elements to the specified HyperLogLog.
    `RedisAPI` | `pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Adds the specified elements to the specified HyperLogLog.
    `RedisAPI` | `pfcount(List<String> args)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisAPI` | `pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `RedisAPI` | `pfdebug(String arg0, String arg1)` Internal commands for debugging HyperLogLog values.
    `RedisAPI` | `pfdebug(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Internal commands for debugging HyperLogLog values.
    `RedisAPI` | `pfmerge(List<String> args)` Merge N different HyperLogLogs into a single one.
    `RedisAPI` | `pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Merge N different HyperLogLogs into a single one.
    `RedisAPI` | `pfselftest()` An internal command for testing HyperLogLog values.
    `RedisAPI` | `pfselftest(Handler<AsyncResult<Response>> handler)` An internal command for testing HyperLogLog values.
    `RedisAPI` | `ping(List<String> args)` Ping the server.
    `RedisAPI` | `ping(List<String> args, Handler<AsyncResult<Response>> handler)` Ping the server.
    `RedisAPI` | `psetex(String arg0, String arg1, String arg2)` Set the value and expiration in milliseconds of a key.
    `RedisAPI` | `psetex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value and expiration in milliseconds of a key.
    `RedisAPI` | `psubscribe(List<String> args)` Listen for messages published to channels matching the given patterns.
    `RedisAPI` | `psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to channels matching the given patterns.
    `RedisAPI` | `psync(List<String> args)` Internal command used for replication.
    `RedisAPI` | `psync(List<String> args, Handler<AsyncResult<Response>> handler)` Internal command used for replication.
    `RedisAPI` | `pttl(String arg0)` Get the time to live for a key in milliseconds.
    `RedisAPI` | `pttl(String arg0, Handler<AsyncResult<Response>> handler)` Get the time to live for a key in milliseconds.
    `RedisAPI` | `publish(String arg0, String arg1)` Post a message to a channel.
    `RedisAPI` | `publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Post a message to a channel.
    `RedisAPI` | `pubsub(List<String> args)` A container for Pub/Sub commands.
    `RedisAPI` | `pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Pub/Sub commands.
    `RedisAPI` | `punsubscribe(List<String> args)` Stop listening for messages posted to channels matching the given patterns.
    `RedisAPI` | `punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to channels matching the given patterns.
    `RedisAPI` | `quit(List<String> args)` Close the connection.
    `RedisAPI` | `quit(List<String> args, Handler<AsyncResult<Response>> handler)` Close the connection.
    `RedisAPI` | `randomkey()` Return a random key from the keyspace.
    `RedisAPI` | `randomkey(Handler<AsyncResult<Response>> handler)` Return a random key from the keyspace.
    `RedisAPI` | `readonly()` Enables read queries for a connection to a cluster replica node.
    `RedisAPI` | `readonly(Handler<AsyncResult<Response>> handler)` Enables read queries for a connection to a cluster replica node.
    `RedisAPI` | `readwrite()` Disables read queries for a connection to a cluster replica node.
    `RedisAPI` | `readwrite(Handler<AsyncResult<Response>> handler)` Disables read queries for a connection to a cluster replica node.
    `RedisAPI` | `rename(String arg0, String arg1)` Rename a key.
    `RedisAPI` | `rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Rename a key.
    `RedisAPI` | `renamenx(String arg0, String arg1)` Rename a key, only if the new key does not exist.
    `RedisAPI` | `renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Rename a key, only if the new key does not exist.
    `RedisAPI` | `replconf(List<String> args)` An internal command for configuring the replication stream.
    `RedisAPI` | `replconf(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for configuring the replication stream.
    `RedisAPI` | `replicaof(String arg0, String arg1)` Make the server a replica of another instance, or promote it as master.
    `RedisAPI` | `replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Make the server a replica of another instance, or promote it as master.
    `RedisAPI` | `reset()` Reset the connection.
    `RedisAPI` | `reset(Handler<AsyncResult<Response>> handler)` Reset the connection.
    `RedisAPI` | `restore(List<String> args)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisAPI` | `restore(List<String> args, Handler<AsyncResult<Response>> handler)` Create a key using the provided serialized value, previously obtained using DUMP.
    `RedisAPI` | `restoreAsking(List<String> args)` An internal command for migrating keys in a cluster.
    `RedisAPI` | `restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for migrating keys in a cluster.
    `RedisAPI` | `role()` Return the role of the instance in the context of replication.
    `RedisAPI` | `role(Handler<AsyncResult<Response>> handler)` Return the role of the instance in the context of replication.
    `RedisAPI` | `rpop(List<String> args)` Remove and get the last elements in a list.
    `RedisAPI` | `rpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and get the last elements in a list.
    `RedisAPI` | `rpoplpush(String arg0, String arg1)` Remove the last element in a list, prepend it to another list and return it.
    `RedisAPI` | `rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Remove the last element in a list, prepend it to another list and return it.
    `RedisAPI` | `rpush(List<String> args)` Append one or multiple elements to a list.
    `RedisAPI` | `rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Append one or multiple elements to a list.
    `RedisAPI` | `rpushx(List<String> args)` Append an element to a list, only if the list exists.
    `RedisAPI` | `rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Append an element to a list, only if the list exists.
    `Single<Response>` | `rxAcl(List<String> args)` A container for Access List Control commands.
    `Single<Response>` | `rxAppend(String arg0, String arg1)` Append a value to a key.
    `Single<Response>` | `rxAsking()` Sent by cluster clients after an -ASK redirect.
    `Single<Response>` | `rxAuth(List<String> args)` Authenticate to the server.
    `Single<Response>` | `rxBfAdd(List<String> args)` Redis command BF.ADD.
    `Single<Response>` | `rxBfCard(List<String> args)` Redis command BF.CARD.
    `Single<Response>` | `rxBfDebug(List<String> args)` Redis command BF.DEBUG.
    `Single<Response>` | `rxBfExists(List<String> args)` Redis command BF.EXISTS.
    `Single<Response>` | `rxBfInfo(List<String> args)` Redis command BF.INFO.
    `Single<Response>` | `rxBfInsert(List<String> args)` Redis command BF.INSERT.
    `Single<Response>` | `rxBfLoadchunk(List<String> args)` Redis command BF.LOADCHUNK.
    `Single<Response>` | `rxBfMadd(List<String> args)` Redis command BF.MADD.
    `Single<Response>` | `rxBfMexists(List<String> args)` Redis command BF.MEXISTS.
    `Single<Response>` | `rxBfReserve(List<String> args)` Redis command BF.RESERVE.
    `Single<Response>` | `rxBfScandump(List<String> args)` Redis command BF.SCANDUMP.
    `Single<Response>` | `rxBgrewriteaof()` Asynchronously rewrite the append-only file.
    `Single<Response>` | `rxBgsave(List<String> args)` Asynchronously save the dataset to disk.
    `Single<Response>` | `rxBitcount(List<String> args)` Count set bits in a string.
    `Single<Response>` | `rxBitfield(List<String> args)` Perform arbitrary bitfield integer operations on strings.
    `Single<Response>` | `rxBitfieldRo(List<String> args)` Perform arbitrary bitfield integer operations on strings.
    `Single<Response>` | `rxBitop(List<String> args)` Perform bitwise operations between strings.
    `Single<Response>` | `rxBitpos(List<String> args)` Find first bit set or clear in a string.
    `Single<Response>` | `rxBlmove(String arg0, String arg1, String arg2, String arg3, String arg4)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `Single<Response>` | `rxBlmpop(List<String> args)` Pop elements from a list, or block until one is available.
    `Single<Response>` | `rxBlpop(List<String> args)` Remove and get the first element in a list, or block until one is available.
    `Single<Response>` | `rxBrpop(List<String> args)` Remove and get the last element in a list, or block until one is available.
    `Single<Response>` | `rxBrpoplpush(String arg0, String arg1, String arg2)` Pop an element from a list, push it to another list and return it; or block until one is available.
    `Single<Response>` | `rxBzmpop(List<String> args)` Remove and return members with scores in a sorted set or block until one is available.
    `Single<Response>` | `rxBzpopmax(List<String> args)` Remove and return the member with the highest score from one or more sorted sets, or block until one is available.
    `Single<Response>` | `rxBzpopmin(List<String> args)` Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.
    `Single<Response>` | `rxCfAdd(List<String> args)` Redis command CF.ADD.
    `Single<Response>` | `rxCfAddnx(List<String> args)` Redis command CF.ADDNX.
    `Single<Response>` | `rxCfCompact(List<String> args)` Redis command CF.COMPACT.
    `Single<Response>` | `rxCfCount(List<String> args)` Redis command CF.COUNT.
    `Single<Response>` | `rxCfDebug(List<String> args)` Redis command CF.DEBUG.
    `Single<Response>` | `rxCfDel(List<String> args)` Redis command CF.DEL.
    `Single<Response>` | `rxCfExists(List<String> args)` Redis command CF.EXISTS.
    `Single<Response>` | `rxCfInfo(List<String> args)` Redis command CF.INFO.
    `Single<Response>` | `rxCfInsert(List<String> args)` Redis command CF.INSERT.
    `Single<Response>` | `rxCfInsertnx(List<String> args)` Redis command CF.INSERTNX.
    `Single<Response>` | `rxCfLoadchunk(List<String> args)` Redis command CF.LOADCHUNK.
    `Single<Response>` | `rxCfMexists(List<String> args)` Redis command CF.MEXISTS.
    `Single<Response>` | `rxCfReserve(List<String> args)` Redis command CF.RESERVE.
    `Single<Response>` | `rxCfScandump(List<String> args)` Redis command CF.SCANDUMP.
    `Single<Response>` | `rxClient(List<String> args)` A container for client connection commands.
    `Single<Response>` | `rxCluster(List<String> args)` A container for cluster commands.
    `Single<Response>` | `rxCmsIncrby(List<String> args)` Redis command CMS.INCRBY.
    `Single<Response>` | `rxCmsInfo(List<String> args)` Redis command CMS.INFO.
    `Single<Response>` | `rxCmsInitbydim(List<String> args)` Redis command CMS.INITBYDIM.
    `Single<Response>` | `rxCmsInitbyprob(List<String> args)` Redis command CMS.INITBYPROB.
    `Single<Response>` | `rxCmsMerge(List<String> args)` Redis command CMS.MERGE.
    `Single<Response>` | `rxCmsQuery(List<String> args)` Redis command CMS.QUERY.
    `Single<Response>` | `rxCommand(List<String> args)` Get array of Redis command details.
    `Single<Response>` | `rxConfig(List<String> args)` A container for server configuration commands.
    `Single<Response>` | `rxCopy(List<String> args)` Copy a key.
    `Single<Response>` | `rxDbsize()` Return the number of keys in the selected database.
    `Single<Response>` | `rxDebug(List<String> args)` A container for debugging commands.
    `Single<Response>` | `rxDecr(String arg0)` Decrement the integer value of a key by one.
    `Single<Response>` | `rxDecrby(String arg0, String arg1)` Decrement the integer value of a key by the given number.
    `Single<Response>` | `rxDel(List<String> args)` Delete a key.
    `Single<Response>` | `rxDiscard()` Discard all commands issued after MULTI.
    `Single<Response>` | `rxDump(String arg0)` Return a serialized version of the value stored at the specified key.
    `Single<Response>` | `rxEcho(String arg0)` Echo the given string.
    `Single<Response>` | `rxEval(List<String> args)` Execute a Lua script server side.
    `Single<Response>` | `rxEvalRo(List<String> args)` Execute a read-only Lua script server side.
    `Single<Response>` | `rxEvalsha(List<String> args)` Execute a Lua script server side.
    `Single<Response>` | `rxEvalshaRo(List<String> args)` Execute a read-only Lua script server side.
    `Single<Response>` | `rxExec()` Execute all commands issued after MULTI.
    `Single<Response>` | `rxExists(List<String> args)` Determine if a key exists.
    `Single<Response>` | `rxExpire(List<String> args)` Set a key's time to live in seconds.
    `Single<Response>` | `rxExpireat(List<String> args)` Set the expiration for a key as a UNIX timestamp.
    `Single<Response>` | `rxExpiretime(String arg0)` Get the expiration Unix timestamp for a key.
    `Single<Response>` | `rxFailover(List<String> args)` Start a coordinated failover between this server and one of its replicas.
    `Single<Response>` | `rxFcall(List<String> args)` Invoke a function.
    `Single<Response>` | `rxFcallRo(List<String> args)` Invoke a read-only function.
    `Single<Response>` | `rxFlushall(List<String> args)` Remove all keys from all databases.
    `Single<Response>` | `rxFlushdb(List<String> args)` Remove all keys from the current database.
    `Single<Response>` | `rxFtAdd(List<String> args)` Redis command FT.ADD.
    `Single<Response>` | `rxFtAggregate(List<String> args)` Redis command FT.AGGREGATE.
    `Single<Response>` | `rxFtAliasadd(List<String> args)` Redis command FT.ALIASADD.
    `Single<Response>` | `rxFtAliasaddifnx(List<String> args)` Redis command FT._ALIASADDIFNX.
    `Single<Response>` | `rxFtAliasdel(List<String> args)` Redis command FT.ALIASDEL.
    `Single<Response>` | `rxFtAliasdelifx(List<String> args)` Redis command FT._ALIASDELIFX.
    `Single<Response>` | `rxFtAliasupdate(List<String> args)` Redis command FT.ALIASUPDATE.
    `Single<Response>` | `rxFtAlter(List<String> args)` Redis command FT.ALTER.
    `Single<Response>` | `rxFtAlterifnx(List<String> args)` Redis command FT._ALTERIFNX.
    `Single<Response>` | `rxFtConfig(List<String> args)` Redis command FT.CONFIG.
    `Single<Response>` | `rxFtCreate(List<String> args)` Redis command FT.CREATE.
    `Single<Response>` | `rxFtCreateifnx(List<String> args)` Redis command FT._CREATEIFNX.
    `Single<Response>` | `rxFtCursor(List<String> args)` Redis command FT.CURSOR.
    `Single<Response>` | `rxFtDebug(List<String> args)` Redis command FT.DEBUG.
    `Single<Response>` | `rxFtDel(List<String> args)` Redis command FT.DEL.
    `Single<Response>` | `rxFtDictadd(List<String> args)` Redis command FT.DICTADD.
    `Single<Response>` | `rxFtDictdel(List<String> args)` Redis command FT.DICTDEL.
    `Single<Response>` | `rxFtDictdump(List<String> args)` Redis command FT.DICTDUMP.
    `Single<Response>` | `rxFtDrop(List<String> args)` Redis command FT.DROP.
    `Single<Response>` | `rxFtDropifx(List<String> args)` Redis command FT._DROPIFX.
    `Single<Response>` | `rxFtDropindex(List<String> args)` Redis command FT.DROPINDEX.
    `Single<Response>` | `rxFtDropindexifx(List<String> args)` Redis command FT._DROPINDEXIFX.
    `Single<Response>` | `rxFtExplain(List<String> args)` Redis command FT.EXPLAIN.
    `Single<Response>` | `rxFtExplaincli(List<String> args)` Redis command FT.EXPLAINCLI.
    `Single<Response>` | `rxFtGet(List<String> args)` Redis command FT.GET.
    `Single<Response>` | `rxFtInfo(List<String> args)` Redis command FT.INFO.
    `Single<Response>` | `rxFtList(List<String> args)` Redis command FT._LIST.
    `Single<Response>` | `rxFtMget(List<String> args)` Redis command FT.MGET.
    `Single<Response>` | `rxFtProfile(List<String> args)` Redis command FT.PROFILE.
    `Single<Response>` | `rxFtSafeadd(List<String> args)` Redis command FT.SAFEADD.
    `Single<Response>` | `rxFtSearch(List<String> args)` Redis command FT.SEARCH.
    `Single<Response>` | `rxFtSpellcheck(List<String> args)` Redis command FT.SPELLCHECK.
    `Single<Response>` | `rxFtSugadd(List<String> args)` Redis command FT.SUGADD.
    `Single<Response>` | `rxFtSugdel(List<String> args)` Redis command FT.SUGDEL.
    `Single<Response>` | `rxFtSugget(List<String> args)` Redis command FT.SUGGET.
    `Single<Response>` | `rxFtSuglen(List<String> args)` Redis command FT.SUGLEN.
    `Single<Response>` | `rxFtSynadd(List<String> args)` Redis command FT.SYNADD.
    `Single<Response>` | `rxFtSyndump(List<String> args)` Redis command FT.SYNDUMP.
    `Single<Response>` | `rxFtSynupdate(List<String> args)` Redis command FT.SYNUPDATE.
    `Single<Response>` | `rxFtTagvals(List<String> args)` Redis command FT.TAGVALS.
    `Single<Response>` | `rxFunction(List<String> args)` A container for function commands.
    `Single<Response>` | `rxGeoadd(List<String> args)` Add one or more geospatial items in the geospatial index represented using a sorted set.
    `Single<Response>` | `rxGeodist(List<String> args)` Returns the distance between two members of a geospatial index.
    `Single<Response>` | `rxGeohash(List<String> args)` Returns members of a geospatial index as standard geohash strings.
    `Single<Response>` | `rxGeopos(List<String> args)` Returns longitude and latitude of members of a geospatial index.
    `Single<Response>` | `rxGeoradius(List<String> args)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
    `Single<Response>` | `rxGeoradiusbymember(List<String> args)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
    `Single<Response>` | `rxGeoradiusbymemberRo(List<String> args)` A read-only variant for GEORADIUSBYMEMBER.
    `Single<Response>` | `rxGeoradiusRo(List<String> args)` A read-only variant for GEORADIUS.
    `Single<Response>` | `rxGeosearch(List<String> args)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
    `Single<Response>` | `rxGeosearchstore(List<String> args)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.
    `Single<Response>` | `rxGet(String arg0)` Get the value of a key.
    `Single<Response>` | `rxGetbit(String arg0, String arg1)` Returns the bit value at offset in the string value stored at key.
    `Single<Response>` | `rxGetdel(String arg0)` Get the value of a key and delete the key.
    `Single<Response>` | `rxGetex(List<String> args)` Get the value of a key and optionally set its expiration.
    `Single<Response>` | `rxGetrange(String arg0, String arg1, String arg2)` Get a substring of the string stored at a key.
    `Single<Response>` | `rxGetset(String arg0, String arg1)` Set the string value of a key and return its old value.
    `Single<Response>` | `rxGraphBulk(List<String> args)` Redis command GRAPH.BULK.
    `Single<Response>` | `rxGraphConfig(List<String> args)` Redis command GRAPH.CONFIG.
    `Single<Response>` | `rxGraphDebug(List<String> args)` Redis command GRAPH.DEBUG.
    `Single<Response>` | `rxGraphDelete(List<String> args)` Redis command GRAPH.DELETE.
    `Single<Response>` | `rxGraphExplain(List<String> args)` Redis command GRAPH.EXPLAIN.
    `Single<Response>` | `rxGraphList(List<String> args)` Redis command GRAPH.LIST.
    `Single<Response>` | `rxGraphProfile(List<String> args)` Redis command GRAPH.PROFILE.
    `Single<Response>` | `rxGraphQuery(List<String> args)` Redis command GRAPH.QUERY.
    `Single<Response>` | `rxGraphRoQuery(List<String> args)` Redis command GRAPH.RO_QUERY.
    `Single<Response>` | `rxGraphSlowlog(List<String> args)` Redis command GRAPH.SLOWLOG.
    `Single<Response>` | `rxHdel(List<String> args)` Delete one or more hash fields.
    `Single<Response>` | `rxHello(List<String> args)` Handshake with Redis.
    `Single<Response>` | `rxHexists(String arg0, String arg1)` Determine if a hash field exists.
    `Single<Response>` | `rxHget(String arg0, String arg1)` Get the value of a hash field.
    `Single<Response>` | `rxHgetall(String arg0)` Get all the fields and values in a hash.
    `Single<Response>` | `rxHincrby(String arg0, String arg1, String arg2)` Increment the integer value of a hash field by the given number.
    `Single<Response>` | `rxHincrbyfloat(String arg0, String arg1, String arg2)` Increment the float value of a hash field by the given amount.
    `Single<Response>` | `rxHkeys(String arg0)` Get all the fields in a hash.
    `Single<Response>` | `rxHlen(String arg0)` Get the number of fields in a hash.
    `Single<Response>` | `rxHmget(List<String> args)` Get the values of all the given hash fields.
    `Single<Response>` | `rxHmset(List<String> args)` Set multiple hash fields to multiple values.
    `Single<Response>` | `rxHrandfield(List<String> args)` Get one or multiple random fields from a hash.
    `Single<Response>` | `rxHscan(List<String> args)` Incrementally iterate hash fields and associated values.
    `Single<Response>` | `rxHset(List<String> args)` Set the string value of a hash field.
    `Single<Response>` | `rxHsetnx(String arg0, String arg1, String arg2)` Set the value of a hash field, only if the field does not exist.
    `Single<Response>` | `rxHstrlen(String arg0, String arg1)` Get the length of the value of a hash field.
    `Single<Response>` | `rxHvals(String arg0)` Get all the values in a hash.
    `Single<Response>` | `rxIncr(String arg0)` Increment the integer value of a key by one.
    `Single<Response>` | `rxIncrby(String arg0, String arg1)` Increment the integer value of a key by the given amount.
    `Single<Response>` | `rxIncrbyfloat(String arg0, String arg1)` Increment the float value of a key by the given amount.
    `Single<Response>` | `rxInfo(List<String> args)` Get information and statistics about the server.
    `Single<Response>` | `rxJsonArrappend(List<String> args)` Redis command JSON.ARRAPPEND.
    `Single<Response>` | `rxJsonArrindex(List<String> args)` Redis command JSON.ARRINDEX.
    `Single<Response>` | `rxJsonArrinsert(List<String> args)` Redis command JSON.ARRINSERT.
    `Single<Response>` | `rxJsonArrlen(List<String> args)` Redis command JSON.ARRLEN.
    `Single<Response>` | `rxJsonArrpop(List<String> args)` Redis command JSON.ARRPOP.
    `Single<Response>` | `rxJsonArrtrim(List<String> args)` Redis command JSON.ARRTRIM.
    `Single<Response>` | `rxJsonClear(List<String> args)` Redis command JSON.CLEAR.
    `Single<Response>` | `rxJsonDebug(List<String> args)` Redis command JSON.DEBUG.
    `Single<Response>` | `rxJsonDel(List<String> args)` Redis command JSON.DEL.
    `Single<Response>` | `rxJsonForget(List<String> args)` Redis command JSON.FORGET.
    `Single<Response>` | `rxJsonGet(List<String> args)` Redis command JSON.GET.
    `Single<Response>` | `rxJsonMget(List<String> args)` Redis command JSON.MGET.
    `Single<Response>` | `rxJsonNumincrby(List<String> args)` Redis command JSON.NUMINCRBY.
    `Single<Response>` | `rxJsonNummultby(List<String> args)` Redis command JSON.NUMMULTBY.
    `Single<Response>` | `rxJsonNumpowby(List<String> args)` Redis command JSON.NUMPOWBY.
    `Single<Response>` | `rxJsonObjkeys(List<String> args)` Redis command JSON.OBJKEYS.
    `Single<Response>` | `rxJsonObjlen(List<String> args)` Redis command JSON.OBJLEN.
    `Single<Response>` | `rxJsonResp(List<String> args)` Redis command JSON.RESP.
    `Single<Response>` | `rxJsonSet(List<String> args)` Redis command JSON.SET.
    `Single<Response>` | `rxJsonStrappend(List<String> args)` Redis command JSON.STRAPPEND.
    `Single<Response>` | `rxJsonStrlen(List<String> args)` Redis command JSON.STRLEN.
    `Single<Response>` | `rxJsonToggle(List<String> args)` Redis command JSON.TOGGLE.
    `Single<Response>` | `rxJsonType(List<String> args)` Redis command JSON.TYPE.
    `Single<Response>` | `rxKeys(String arg0)` Find all keys matching the given pattern.
    `Single<Response>` | `rxLastsave()` Get the UNIX time stamp of the last successful save to disk.
    `Single<Response>` | `rxLatency(List<String> args)` A container for latency diagnostics commands.
    `Single<Response>` | `rxLcs(List<String> args)` Find longest common substring.
    `Single<Response>` | `rxLindex(String arg0, String arg1)` Get an element from a list by its index.
    `Single<Response>` | `rxLinsert(String arg0, String arg1, String arg2, String arg3)` Insert an element before or after another element in a list.
    `Single<Response>` | `rxLlen(String arg0)` Get the length of a list.
    `Single<Response>` | `rxLmove(String arg0, String arg1, String arg2, String arg3)` Pop an element from a list, push it to another list and return it.
    `Single<Response>` | `rxLmpop(List<String> args)` Pop elements from a list.
    `Single<Response>` | `rxLolwut(List<String> args)` Display some computer art and the Redis version.
    `Single<Response>` | `rxLpop(List<String> args)` Remove and get the first elements in a list.
    `Single<Response>` | `rxLpos(List<String> args)` Return the index of matching elements on a list.
    `Single<Response>` | `rxLpush(List<String> args)` Prepend one or multiple elements to a list.
    `Single<Response>` | `rxLpushx(List<String> args)` Prepend an element to a list, only if the list exists.
    `Single<Response>` | `rxLrange(String arg0, String arg1, String arg2)` Get a range of elements from a list.
    `Single<Response>` | `rxLrem(String arg0, String arg1, String arg2)` Remove elements from a list.
    `Single<Response>` | `rxLset(String arg0, String arg1, String arg2)` Set the value of an element in a list by its index.
    `Single<Response>` | `rxLtrim(String arg0, String arg1, String arg2)` Trim a list to the specified range.
    `Single<Response>` | `rxMemory(List<String> args)` A container for memory diagnostics commands.
    `Single<Response>` | `rxMget(List<String> args)` Get the values of all the given keys.
    `Single<Response>` | `rxMigrate(List<String> args)` Atomically transfer a key from a Redis instance to another one.
    `Single<Response>` | `rxModule(List<String> args)` A container for module commands.
    `Single<Response>` | `rxMonitor()` Listen for all requests received by the server in real time.
    `Single<Response>` | `rxMove(String arg0, String arg1)` Move a key to another database.
    `Single<Response>` | `rxMset(List<String> args)` Set multiple keys to multiple values.
    `Single<Response>` | `rxMsetnx(List<String> args)` Set multiple keys to multiple values, only if none of the keys exist.
    `Single<Response>` | `rxMulti()` Mark the start of a transaction block.
    `Single<Response>` | `rxObject(List<String> args)` A container for object introspection commands.
    `Single<Response>` | `rxPersist(String arg0)` Remove the expiration from a key.
    `Single<Response>` | `rxPexpire(List<String> args)` Set a key's time to live in milliseconds.
    `Single<Response>` | `rxPexpireat(List<String> args)` Set the expiration for a key as a UNIX timestamp specified in milliseconds.
    `Single<Response>` | `rxPexpiretime(String arg0)` Get the expiration Unix timestamp for a key in milliseconds.
    `Single<Response>` | `rxPfadd(List<String> args)` Adds the specified elements to the specified HyperLogLog.
    `Single<Response>` | `rxPfcount(List<String> args)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    `Single<Response>` | `rxPfdebug(String arg0, String arg1)` Internal commands for debugging HyperLogLog values.
    `Single<Response>` | `rxPfmerge(List<String> args)` Merge N different HyperLogLogs into a single one.
    `Single<Response>` | `rxPfselftest()` An internal command for testing HyperLogLog values.
    `Single<Response>` | `rxPing(List<String> args)` Ping the server.
    `Single<Response>` | `rxPsetex(String arg0, String arg1, String arg2)` Set the value and expiration in milliseconds of a key.
    `Single<Response>` | `rxPsubscribe(List<String> args)` Listen for messages published to channels matching the given patterns.
    `Single<Response>` | `rxPsync(List<String> args)` Internal command used for replication.
    `Single<Response>` | `rxPttl(String arg0)` Get the time to live for a key in milliseconds.
    `Single<Response>` | `rxPublish(String arg0, String arg1)` Post a message to a channel.
    `Single<Response>` | `rxPubsub(List<String> args)` A container for Pub/Sub commands.
    `Single<Response>` | `rxPunsubscribe(List<String> args)` Stop listening for messages posted to channels matching the given patterns.
    `Single<Response>` | `rxQuit(List<String> args)` Close the connection.
    `Single<Response>` | `rxRandomkey()` Return a random key from the keyspace.
    `Single<Response>` | `rxReadonly()` Enables read queries for a connection to a cluster replica node.
    `Single<Response>` | `rxReadwrite()` Disables read queries for a connection to a cluster replica node.
    `Single<Response>` | `rxRename(String arg0, String arg1)` Rename a key.
    `Single<Response>` | `rxRenamenx(String arg0, String arg1)` Rename a key, only if the new key does not exist.
    `Single<Response>` | `rxReplconf(List<String> args)` An internal command for configuring the replication stream.
    `Single<Response>` | `rxReplicaof(String arg0, String arg1)` Make the server a replica of another instance, or promote it as master.
    `Single<Response>` | `rxReset()` Reset the connection.
    `Single<Response>` | `rxRestore(List<String> args)` Create a key using the provided serialized value, previously obtained using DUMP.
    `Single<Response>` | `rxRestoreAsking(List<String> args)` An internal command for migrating keys in a cluster.
    `Single<Response>` | `rxRole()` Return the role of the instance in the context of replication.
    `Single<Response>` | `rxRpop(List<String> args)` Remove and get the last elements in a list.
    `Single<Response>` | `rxRpoplpush(String arg0, String arg1)` Remove the last element in a list, prepend it to another list and return it.
    `Single<Response>` | `rxRpush(List<String> args)` Append one or multiple elements to a list.
    `Single<Response>` | `rxRpushx(List<String> args)` Append an element to a list, only if the list exists.
    `Single<Response>` | `rxSadd(List<String> args)` Add one or more members to a set.
    `Single<Response>` | `rxSave()` Synchronously save the dataset to disk.
    `Single<Response>` | `rxScan(List<String> args)` Incrementally iterate the keys space.
    `Single<Response>` | `rxScard(String arg0)` Get the number of members in a set.
    `Single<Response>` | `rxScript(List<String> args)` A container for Lua scripts management commands.
    `Single<Response>` | `rxSdiff(List<String> args)` Subtract multiple sets.
    `Single<Response>` | `rxSdiffstore(List<String> args)` Subtract multiple sets and store the resulting set in a key.
    `Single<Response>` | `rxSelect(String arg0)` Change the selected database for the current connection.
    `Single<Response>` | `rxSet(List<String> args)` Set the string value of a key.
    `Single<Response>` | `rxSetbit(String arg0, String arg1, String arg2)` Sets or clears the bit at offset in the string value stored at key.
    `Single<Response>` | `rxSetex(String arg0, String arg1, String arg2)` Set the value and expiration of a key.
    `Single<Response>` | `rxSetnx(String arg0, String arg1)` Set the value of a key, only if the key does not exist.
    `Single<Response>` | `rxSetrange(String arg0, String arg1, String arg2)` Overwrite part of a string at key starting at the specified offset.
    `Single<Response>` | `rxShutdown(List<String> args)` Synchronously save the dataset to disk and then shut down the server.
    `Single<Response>` | `rxSinter(List<String> args)` Intersect multiple sets.
    `Single<Response>` | `rxSintercard(List<String> args)` Intersect multiple sets and return the cardinality of the result.
    `Single<Response>` | `rxSinterstore(List<String> args)` Intersect multiple sets and store the resulting set in a key.
    `Single<Response>` | `rxSismember(String arg0, String arg1)` Determine if a given value is a member of a set.
    `Single<Response>` | `rxSlaveof(String arg0, String arg1)` Make the server a replica of another instance, or promote it as master.
    `Single<Response>` | `rxSlowlog(List<String> args)` A container for slow log commands.
    `Single<Response>` | `rxSmembers(String arg0)` Get all the members in a set.
    `Single<Response>` | `rxSmismember(List<String> args)` Returns the membership associated with the given elements for a set.
    `Single<Response>` | `rxSmove(String arg0, String arg1, String arg2)` Move a member from one set to another.
    `Single<Response>` | `rxSort(List<String> args)` Sort the elements in a list, set or sorted set.
    `Single<Response>` | `rxSortRo(List<String> args)` Sort the elements in a list, set or sorted set.
    `Single<Response>` | `rxSpop(List<String> args)` Remove and return one or multiple random members from a set.
    `Single<Response>` | `rxSpublish(String arg0, String arg1)` Post a message to a shard channel.
    `Single<Response>` | `rxSrandmember(List<String> args)` Get one or multiple random members from a set.
    `Single<Response>` | `rxSrem(List<String> args)` Remove one or more members from a set.
    `Single<Response>` | `rxSscan(List<String> args)` Incrementally iterate Set elements.
    `Single<Response>` | `rxSsubscribe(List<String> args)` Listen for messages published to the given shard channels.
    `Single<Response>` | `rxStrlen(String arg0)` Get the length of the value stored in a key.
    `Single<Response>` | `rxSubscribe(List<String> args)` Listen for messages published to the given channels.
    `Single<Response>` | `rxSubstr(String arg0, String arg1, String arg2)` Get a substring of the string stored at a key.
    `Single<Response>` | `rxSunion(List<String> args)` Add multiple sets.
    `Single<Response>` | `rxSunionstore(List<String> args)` Add multiple sets and store the resulting set in a key.
    `Single<Response>` | `rxSunsubscribe(List<String> args)` Stop listening for messages posted to the given shard channels.
    `Single<Response>` | `rxSwapdb(String arg0, String arg1)` Swaps two Redis databases.
    `Single<Response>` | `rxSync()` Internal command used for replication.
    `Single<Response>` | `rxTdigestAdd(List<String> args)` Redis command TDIGEST.ADD.
    `Single<Response>` | `rxTdigestByrank(List<String> args)` Redis command TDIGEST.BYRANK.
    `Single<Response>` | `rxTdigestByrevrank(List<String> args)` Redis command TDIGEST.BYREVRANK.
    `Single<Response>` | `rxTdigestCdf(List<String> args)` Redis command TDIGEST.CDF.
    `Single<Response>` | `rxTdigestCreate(List<String> args)` Redis command TDIGEST.CREATE.
    `Single<Response>` | `rxTdigestInfo(List<String> args)` Redis command TDIGEST.INFO.
    `Single<Response>` | `rxTdigestMax(List<String> args)` Redis command TDIGEST.MAX.
    `Single<Response>` | `rxTdigestMerge(List<String> args)` Redis command TDIGEST.MERGE.
    `Single<Response>` | `rxTdigestMin(List<String> args)` Redis command TDIGEST.MIN.
    `Single<Response>` | `rxTdigestQuantile(List<String> args)` Redis command TDIGEST.QUANTILE.
    `Single<Response>` | `rxTdigestRank(List<String> args)` Redis command TDIGEST.RANK.
    `Single<Response>` | `rxTdigestReset(List<String> args)` Redis command TDIGEST.RESET.
    `Single<Response>` | `rxTdigestRevrank(List<String> args)` Redis command TDIGEST.REVRANK.
    `Single<Response>` | `rxTdigestTrimmedMean(List<String> args)` Redis command TDIGEST.TRIMMED_MEAN.
    `Single<Response>` | `rxTime()` Return the current server time.
    `Single<Response>` | `rxTimeseriesClusterset(List<String> args)` Redis command TIMESERIES.CLUSTERSET.
    `Single<Response>` | `rxTimeseriesClustersetfromshard(List<String> args)` Redis command TIMESERIES.CLUSTERSETFROMSHARD.
    `Single<Response>` | `rxTimeseriesHello(List<String> args)` Redis command TIMESERIES.HELLO.
    `Single<Response>` | `rxTimeseriesInfocluster(List<String> args)` Redis command TIMESERIES.INFOCLUSTER.
    `Single<Response>` | `rxTimeseriesInnercommunication(List<String> args)` Redis command TIMESERIES.INNERCOMMUNICATION.
    `Single<Response>` | `rxTimeseriesNetworktest(List<String> args)` Redis command TIMESERIES.NETWORKTEST.
    `Single<Response>` | `rxTimeseriesRefreshcluster(List<String> args)` Redis command TIMESERIES.REFRESHCLUSTER.
    `Single<Response>` | `rxTopkAdd(List<String> args)` Redis command TOPK.ADD.
    `Single<Response>` | `rxTopkCount(List<String> args)` Redis command TOPK.COUNT.
    `Single<Response>` | `rxTopkIncrby(List<String> args)` Redis command TOPK.INCRBY.
    `Single<Response>` | `rxTopkInfo(List<String> args)` Redis command TOPK.INFO.
    `Single<Response>` | `rxTopkList(List<String> args)` Redis command TOPK.LIST.
    `Single<Response>` | `rxTopkQuery(List<String> args)` Redis command TOPK.QUERY.
    `Single<Response>` | `rxTopkReserve(List<String> args)` Redis command TOPK.RESERVE.
    `Single<Response>` | `rxTouch(List<String> args)` Alters the last access time of a key(s).
    `Single<Response>` | `rxTsAdd(List<String> args)` Redis command TS.ADD.
    `Single<Response>` | `rxTsAlter(List<String> args)` Redis command TS.ALTER.
    `Single<Response>` | `rxTsCreate(List<String> args)` Redis command TS.CREATE.
    `Single<Response>` | `rxTsCreaterule(List<String> args)` Redis command TS.CREATERULE.
    `Single<Response>` | `rxTsDecrby(List<String> args)` Redis command TS.DECRBY.
    `Single<Response>` | `rxTsDel(List<String> args)` Redis command TS.DEL.
    `Single<Response>` | `rxTsDeleterule(List<String> args)` Redis command TS.DELETERULE.
    `Single<Response>` | `rxTsGet(List<String> args)` Redis command TS.GET.
    `Single<Response>` | `rxTsIncrby(List<String> args)` Redis command TS.INCRBY.
    `Single<Response>` | `rxTsInfo(List<String> args)` Redis command TS.INFO.
    `Single<Response>` | `rxTsMadd(List<String> args)` Redis command TS.MADD.
    `Single<Response>` | `rxTsMget(List<String> args)` Redis command TS.MGET.
    `Single<Response>` | `rxTsMrange(List<String> args)` Redis command TS.MRANGE.
    `Single<Response>` | `rxTsMrevrange(List<String> args)` Redis command TS.MREVRANGE.
    `Single<Response>` | `rxTsQueryindex(List<String> args)` Redis command TS.QUERYINDEX.
    `Single<Response>` | `rxTsRange(List<String> args)` Redis command TS.RANGE.
    `Single<Response>` | `rxTsRevrange(List<String> args)` Redis command TS.REVRANGE.
    `Single<Response>` | `rxTtl(String arg0)` Get the time to live for a key in seconds.
    `Single<Response>` | `rxType(String arg0)` Determine the type stored at key.
    `Single<Response>` | `rxUnlink(List<String> args)` Delete a key asynchronously in another thread.
    `Single<Response>` | `rxUnsubscribe(List<String> args)` Stop listening for messages posted to the given channels.
    `Single<Response>` | `rxUnwatch()` Forget about all watched keys.
    `Single<Response>` | `rxWait(String arg0, String arg1)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `Single<Response>` | `rxWatch(List<String> args)` Watch the given keys to determine execution of the MULTI/EXEC block.
    `Single<Response>` | `rxXack(List<String> args)` Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group.
    `Single<Response>` | `rxXadd(List<String> args)` Appends a new entry to a stream.
    `Single<Response>` | `rxXautoclaim(List<String> args)` Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
    `Single<Response>` | `rxXclaim(List<String> args)` Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
    `Single<Response>` | `rxXdel(List<String> args)` Removes the specified entries from the stream.
    `Single<Response>` | `rxXgroup(List<String> args)` A container for consumer groups commands.
    `Single<Response>` | `rxXinfo(List<String> args)` A container for stream introspection commands.
    `Single<Response>` | `rxXlen(String arg0)` Return the number of entries in a stream.
    `Single<Response>` | `rxXpending(List<String> args)` Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
    `Single<Response>` | `rxXrange(List<String> args)` Return a range of elements in a stream, with IDs matching the specified IDs interval.
    `Single<Response>` | `rxXread(List<String> args)` Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream.
    `Single<Response>` | `rxXreadgroup(List<String> args)` Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer.
    `Single<Response>` | `rxXrevrange(List<String> args)` Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.
    `Single<Response>` | `rxXsetid(List<String> args)` An internal command for replicating stream values.
    `Single<Response>` | `rxXtrim(List<String> args)` Trims the stream to (approximately if '~' is passed) a certain size.
    `Single<Response>` | `rxZadd(List<String> args)` Add one or more members to a sorted set, or update its score if it already exists.
    `Single<Response>` | `rxZcard(String arg0)` Get the number of members in a sorted set.
    `Single<Response>` | `rxZcount(String arg0, String arg1, String arg2)` Count the members in a sorted set with scores within the given values.
    `Single<Response>` | `rxZdiff(List<String> args)` Subtract multiple sorted sets.
    `Single<Response>` | `rxZdiffstore(List<String> args)` Subtract multiple sorted sets and store the resulting sorted set in a new key.
    `Single<Response>` | `rxZincrby(String arg0, String arg1, String arg2)` Increment the score of a member in a sorted set.
    `Single<Response>` | `rxZinter(List<String> args)` Intersect multiple sorted sets.
    `Single<Response>` | `rxZintercard(List<String> args)` Intersect multiple sorted sets and return the cardinality of the result.
    `Single<Response>` | `rxZinterstore(List<String> args)` Intersect multiple sorted sets and store the resulting sorted set in a new key.
    `Single<Response>` | `rxZlexcount(String arg0, String arg1, String arg2)` Count the number of members in a sorted set between a given lexicographical range.
    `Single<Response>` | `rxZmpop(List<String> args)` Remove and return members with scores in a sorted set.
    `Single<Response>` | `rxZmscore(List<String> args)` Get the score associated with the given members in a sorted set.
    `Single<Response>` | `rxZpopmax(List<String> args)` Remove and return members with the highest scores in a sorted set.
    `Single<Response>` | `rxZpopmin(List<String> args)` Remove and return members with the lowest scores in a sorted set.
    `Single<Response>` | `rxZrandmember(List<String> args)` Get one or multiple random elements from a sorted set.
    `Single<Response>` | `rxZrange(List<String> args)` Return a range of members in a sorted set.
    `Single<Response>` | `rxZrangebylex(List<String> args)` Return a range of members in a sorted set, by lexicographical range.
    `Single<Response>` | `rxZrangebyscore(List<String> args)` Return a range of members in a sorted set, by score.
    `Single<Response>` | `rxZrangestore(List<String> args)` Store a range of members from sorted set into another key.
    `Single<Response>` | `rxZrank(String arg0, String arg1)` Determine the index of a member in a sorted set.
    `Single<Response>` | `rxZrem(List<String> args)` Remove one or more members from a sorted set.
    `Single<Response>` | `rxZremrangebylex(String arg0, String arg1, String arg2)` Remove all members in a sorted set between the given lexicographical range.
    `Single<Response>` | `rxZremrangebyrank(String arg0, String arg1, String arg2)` Remove all members in a sorted set within the given indexes.
    `Single<Response>` | `rxZremrangebyscore(String arg0, String arg1, String arg2)` Remove all members in a sorted set within the given scores.
    `Single<Response>` | `rxZrevrange(List<String> args)` Return a range of members in a sorted set, by index, with scores ordered from high to low.
    `Single<Response>` | `rxZrevrangebylex(List<String> args)` Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
    `Single<Response>` | `rxZrevrangebyscore(List<String> args)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
    `Single<Response>` | `rxZrevrank(String arg0, String arg1)` Determine the index of a member in a sorted set, with scores ordered from high to low.
    `Single<Response>` | `rxZscan(List<String> args)` Incrementally iterate sorted sets elements and associated scores.
    `Single<Response>` | `rxZscore(String arg0, String arg1)` Get the score associated with the given member in a sorted set.
    `Single<Response>` | `rxZunion(List<String> args)` Add multiple sorted sets.
    `Single<Response>` | `rxZunionstore(List<String> args)` Add multiple sorted sets and store the resulting sorted set in a new key.
    `RedisAPI` | `sadd(List<String> args)` Add one or more members to a set.
    `RedisAPI` | `sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more members to a set.
    `RedisAPI` | `save()` Synchronously save the dataset to disk.
    `RedisAPI` | `save(Handler<AsyncResult<Response>> handler)` Synchronously save the dataset to disk.
    `RedisAPI` | `scan(List<String> args)` Incrementally iterate the keys space.
    `RedisAPI` | `scan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate the keys space.
    `RedisAPI` | `scard(String arg0)` Get the number of members in a set.
    `RedisAPI` | `scard(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of members in a set.
    `RedisAPI` | `script(List<String> args)` A container for Lua scripts management commands.
    `RedisAPI` | `script(List<String> args, Handler<AsyncResult<Response>> handler)` A container for Lua scripts management commands.
    `RedisAPI` | `sdiff(List<String> args)` Subtract multiple sets.
    `RedisAPI` | `sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sets.
    `RedisAPI` | `sdiffstore(List<String> args)` Subtract multiple sets and store the resulting set in a key.
    `RedisAPI` | `sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sets and store the resulting set in a key.
    `RedisAPI` | `select(String arg0)` Change the selected database for the current connection.
    `RedisAPI` | `select(String arg0, Handler<AsyncResult<Response>> handler)` Change the selected database for the current connection.
    `RedisAPI` | `set(List<String> args)` Set the string value of a key.
    `RedisAPI` | `set(List<String> args, Handler<AsyncResult<Response>> handler)` Set the string value of a key.
    `RedisAPI` | `setbit(String arg0, String arg1, String arg2)` Sets or clears the bit at offset in the string value stored at key.
    `RedisAPI` | `setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Sets or clears the bit at offset in the string value stored at key.
    `RedisAPI` | `setex(String arg0, String arg1, String arg2)` Set the value and expiration of a key.
    `RedisAPI` | `setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Set the value and expiration of a key.
    `RedisAPI` | `setnx(String arg0, String arg1)` Set the value of a key, only if the key does not exist.
    `RedisAPI` | `setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Set the value of a key, only if the key does not exist.
    `RedisAPI` | `setrange(String arg0, String arg1, String arg2)` Overwrite part of a string at key starting at the specified offset.
    `RedisAPI` | `setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Overwrite part of a string at key starting at the specified offset.
    `RedisAPI` | `shutdown(List<String> args)` Synchronously save the dataset to disk and then shut down the server.
    `RedisAPI` | `shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Synchronously save the dataset to disk and then shut down the server.
    `RedisAPI` | `sinter(List<String> args)` Intersect multiple sets.
    `RedisAPI` | `sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets.
    `RedisAPI` | `sintercard(List<String> args)` Intersect multiple sets and return the cardinality of the result.
    `RedisAPI` | `sintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets and return the cardinality of the result.
    `RedisAPI` | `sinterstore(List<String> args)` Intersect multiple sets and store the resulting set in a key.
    `RedisAPI` | `sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sets and store the resulting set in a key.
    `RedisAPI` | `sismember(String arg0, String arg1)` Determine if a given value is a member of a set.
    `RedisAPI` | `sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine if a given value is a member of a set.
    `RedisAPI` | `slaveof(String arg0, String arg1)` Make the server a replica of another instance, or promote it as master.
    `RedisAPI` | `slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Make the server a replica of another instance, or promote it as master.
    `RedisAPI` | `slowlog(List<String> args)` A container for slow log commands.
    `RedisAPI` | `slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` A container for slow log commands.
    `RedisAPI` | `smembers(String arg0)` Get all the members in a set.
    `RedisAPI` | `smembers(String arg0, Handler<AsyncResult<Response>> handler)` Get all the members in a set.
    `RedisAPI` | `smismember(List<String> args)` Returns the membership associated with the given elements for a set.
    `RedisAPI` | `smismember(List<String> args, Handler<AsyncResult<Response>> handler)` Returns the membership associated with the given elements for a set.
    `RedisAPI` | `smove(String arg0, String arg1, String arg2)` Move a member from one set to another.
    `RedisAPI` | `smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Move a member from one set to another.
    `RedisAPI` | `sort(List<String> args)` Sort the elements in a list, set or sorted set.
    `RedisAPI` | `sort(List<String> args, Handler<AsyncResult<Response>> handler)` Sort the elements in a list, set or sorted set.
    `RedisAPI` | `sortRo(List<String> args)` Sort the elements in a list, set or sorted set.
    `RedisAPI` | `sortRo(List<String> args, Handler<AsyncResult<Response>> handler)` Sort the elements in a list, set or sorted set.
    `RedisAPI` | `spop(List<String> args)` Remove and return one or multiple random members from a set.
    `RedisAPI` | `spop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return one or multiple random members from a set.
    `RedisAPI` | `spublish(String arg0, String arg1)` Post a message to a shard channel.
    `RedisAPI` | `spublish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Post a message to a shard channel.
    `RedisAPI` | `srandmember(List<String> args)` Get one or multiple random members from a set.
    `RedisAPI` | `srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random members from a set.
    `RedisAPI` | `srem(List<String> args)` Remove one or more members from a set.
    `RedisAPI` | `srem(List<String> args, Handler<AsyncResult<Response>> handler)` Remove one or more members from a set.
    `RedisAPI` | `sscan(List<String> args)` Incrementally iterate Set elements.
    `RedisAPI` | `sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate Set elements.
    `RedisAPI` | `ssubscribe(List<String> args)` Listen for messages published to the given shard channels.
    `RedisAPI` | `ssubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to the given shard channels.
    `RedisAPI` | `strlen(String arg0)` Get the length of the value stored in a key.
    `RedisAPI` | `strlen(String arg0, Handler<AsyncResult<Response>> handler)` Get the length of the value stored in a key.
    `RedisAPI` | `subscribe(List<String> args)` Listen for messages published to the given channels.
    `RedisAPI` | `subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Listen for messages published to the given channels.
    `RedisAPI` | `substr(String arg0, String arg1, String arg2)` Get a substring of the string stored at a key.
    `RedisAPI` | `substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Get a substring of the string stored at a key.
    `RedisAPI` | `sunion(List<String> args)` Add multiple sets.
    `RedisAPI` | `sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sets.
    `RedisAPI` | `sunionstore(List<String> args)` Add multiple sets and store the resulting set in a key.
    `RedisAPI` | `sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sets and store the resulting set in a key.
    `RedisAPI` | `sunsubscribe(List<String> args)` Stop listening for messages posted to the given shard channels.
    `RedisAPI` | `sunsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to the given shard channels.
    `RedisAPI` | `swapdb(String arg0, String arg1)` Swaps two Redis databases.
    `RedisAPI` | `swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Swaps two Redis databases.
    `RedisAPI` | `sync()` Internal command used for replication.
    `RedisAPI` | `sync(Handler<AsyncResult<Response>> handler)` Internal command used for replication.
    `RedisAPI` | `tdigestAdd(List<String> args)` Redis command TDIGEST.ADD.
    `RedisAPI` | `tdigestAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.ADD.
    `RedisAPI` | `tdigestByrank(List<String> args)` Redis command TDIGEST.BYRANK.
    `RedisAPI` | `tdigestByrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.BYRANK.
    `RedisAPI` | `tdigestByrevrank(List<String> args)` Redis command TDIGEST.BYREVRANK.
    `RedisAPI` | `tdigestByrevrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.BYREVRANK.
    `RedisAPI` | `tdigestCdf(List<String> args)` Redis command TDIGEST.CDF.
    `RedisAPI` | `tdigestCdf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.CDF.
    `RedisAPI` | `tdigestCreate(List<String> args)` Redis command TDIGEST.CREATE.
    `RedisAPI` | `tdigestCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.CREATE.
    `RedisAPI` | `tdigestInfo(List<String> args)` Redis command TDIGEST.INFO.
    `RedisAPI` | `tdigestInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.INFO.
    `RedisAPI` | `tdigestMax(List<String> args)` Redis command TDIGEST.MAX.
    `RedisAPI` | `tdigestMax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MAX.
    `RedisAPI` | `tdigestMerge(List<String> args)` Redis command TDIGEST.MERGE.
    `RedisAPI` | `tdigestMerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MERGE.
    `RedisAPI` | `tdigestMin(List<String> args)` Redis command TDIGEST.MIN.
    `RedisAPI` | `tdigestMin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.MIN.
    `RedisAPI` | `tdigestQuantile(List<String> args)` Redis command TDIGEST.QUANTILE.
    `RedisAPI` | `tdigestQuantile(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.QUANTILE.
    `RedisAPI` | `tdigestRank(List<String> args)` Redis command TDIGEST.RANK.
    `RedisAPI` | `tdigestRank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.RANK.
    `RedisAPI` | `tdigestReset(List<String> args)` Redis command TDIGEST.RESET.
    `RedisAPI` | `tdigestReset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.RESET.
    `RedisAPI` | `tdigestRevrank(List<String> args)` Redis command TDIGEST.REVRANK.
    `RedisAPI` | `tdigestRevrank(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.REVRANK.
    `RedisAPI` | `tdigestTrimmedMean(List<String> args)` Redis command TDIGEST.TRIMMED_MEAN.
    `RedisAPI` | `tdigestTrimmedMean(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TDIGEST.TRIMMED_MEAN.
    `RedisAPI` | `time()` Return the current server time.
    `RedisAPI` | `time(Handler<AsyncResult<Response>> handler)` Return the current server time.
    `RedisAPI` | `timeseriesClusterset(List<String> args)` Redis command TIMESERIES.CLUSTERSET.
    `RedisAPI` | `timeseriesClusterset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.CLUSTERSET.
    `RedisAPI` | `timeseriesClustersetfromshard(List<String> args)` Redis command TIMESERIES.CLUSTERSETFROMSHARD.
    `RedisAPI` | `timeseriesClustersetfromshard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.CLUSTERSETFROMSHARD.
    `RedisAPI` | `timeseriesHello(List<String> args)` Redis command TIMESERIES.HELLO.
    `RedisAPI` | `timeseriesHello(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.HELLO.
    `RedisAPI` | `timeseriesInfocluster(List<String> args)` Redis command TIMESERIES.INFOCLUSTER.
    `RedisAPI` | `timeseriesInfocluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.INFOCLUSTER.
    `RedisAPI` | `timeseriesInnercommunication(List<String> args)` Redis command TIMESERIES.INNERCOMMUNICATION.
    `RedisAPI` | `timeseriesInnercommunication(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.INNERCOMMUNICATION.
    `RedisAPI` | `timeseriesNetworktest(List<String> args)` Redis command TIMESERIES.NETWORKTEST.
    `RedisAPI` | `timeseriesNetworktest(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.NETWORKTEST.
    `RedisAPI` | `timeseriesRefreshcluster(List<String> args)` Redis command TIMESERIES.REFRESHCLUSTER.
    `RedisAPI` | `timeseriesRefreshcluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TIMESERIES.REFRESHCLUSTER.
    `RedisAPI` | `topkAdd(List<String> args)` Redis command TOPK.ADD.
    `RedisAPI` | `topkAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.ADD.
    `RedisAPI` | `topkCount(List<String> args)` Redis command TOPK.COUNT.
    `RedisAPI` | `topkCount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.COUNT.
    `RedisAPI` | `topkIncrby(List<String> args)` Redis command TOPK.INCRBY.
    `RedisAPI` | `topkIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.INCRBY.
    `RedisAPI` | `topkInfo(List<String> args)` Redis command TOPK.INFO.
    `RedisAPI` | `topkInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.INFO.
    `RedisAPI` | `topkList(List<String> args)` Redis command TOPK.LIST.
    `RedisAPI` | `topkList(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.LIST.
    `RedisAPI` | `topkQuery(List<String> args)` Redis command TOPK.QUERY.
    `RedisAPI` | `topkQuery(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.QUERY.
    `RedisAPI` | `topkReserve(List<String> args)` Redis command TOPK.RESERVE.
    `RedisAPI` | `topkReserve(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOPK.RESERVE.
    `String` | `toString()`
    `RedisAPI` | `touch(List<String> args)` Alters the last access time of a key(s).
    `RedisAPI` | `touch(List<String> args, Handler<AsyncResult<Response>> handler)` Alters the last access time of a key(s).
    `RedisAPI` | `tsAdd(List<String> args)` Redis command TS.ADD.
    `RedisAPI` | `tsAdd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.ADD.
    `RedisAPI` | `tsAlter(List<String> args)` Redis command TS.ALTER.
    `RedisAPI` | `tsAlter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.ALTER.
    `RedisAPI` | `tsCreate(List<String> args)` Redis command TS.CREATE.
    `RedisAPI` | `tsCreate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.CREATE.
    `RedisAPI` | `tsCreaterule(List<String> args)` Redis command TS.CREATERULE.
    `RedisAPI` | `tsCreaterule(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.CREATERULE.
    `RedisAPI` | `tsDecrby(List<String> args)` Redis command TS.DECRBY.
    `RedisAPI` | `tsDecrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DECRBY.
    `RedisAPI` | `tsDel(List<String> args)` Redis command TS.DEL.
    `RedisAPI` | `tsDel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DEL.
    `RedisAPI` | `tsDeleterule(List<String> args)` Redis command TS.DELETERULE.
    `RedisAPI` | `tsDeleterule(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.DELETERULE.
    `RedisAPI` | `tsGet(List<String> args)` Redis command TS.GET.
    `RedisAPI` | `tsGet(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.GET.
    `RedisAPI` | `tsIncrby(List<String> args)` Redis command TS.INCRBY.
    `RedisAPI` | `tsIncrby(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.INCRBY.
    `RedisAPI` | `tsInfo(List<String> args)` Redis command TS.INFO.
    `RedisAPI` | `tsInfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.INFO.
    `RedisAPI` | `tsMadd(List<String> args)` Redis command TS.MADD.
    `RedisAPI` | `tsMadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MADD.
    `RedisAPI` | `tsMget(List<String> args)` Redis command TS.MGET.
    `RedisAPI` | `tsMget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MGET.
    `RedisAPI` | `tsMrange(List<String> args)` Redis command TS.MRANGE.
    `RedisAPI` | `tsMrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MRANGE.
    `RedisAPI` | `tsMrevrange(List<String> args)` Redis command TS.MREVRANGE.
    `RedisAPI` | `tsMrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.MREVRANGE.
    `RedisAPI` | `tsQueryindex(List<String> args)` Redis command TS.QUERYINDEX.
    `RedisAPI` | `tsQueryindex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.QUERYINDEX.
    `RedisAPI` | `tsRange(List<String> args)` Redis command TS.RANGE.
    `RedisAPI` | `tsRange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.RANGE.
    `RedisAPI` | `tsRevrange(List<String> args)` Redis command TS.REVRANGE.
    `RedisAPI` | `tsRevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TS.REVRANGE.
    `RedisAPI` | `ttl(String arg0)` Get the time to live for a key in seconds.
    `RedisAPI` | `ttl(String arg0, Handler<AsyncResult<Response>> handler)` Get the time to live for a key in seconds.
    `RedisAPI` | `type(String arg0)` Determine the type stored at key.
    `RedisAPI` | `type(String arg0, Handler<AsyncResult<Response>> handler)` Determine the type stored at key.
    `RedisAPI` | `unlink(List<String> args)` Delete a key asynchronously in another thread.
    `RedisAPI` | `unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Delete a key asynchronously in another thread.
    `RedisAPI` | `unsubscribe(List<String> args)` Stop listening for messages posted to the given channels.
    `RedisAPI` | `unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Stop listening for messages posted to the given channels.
    `RedisAPI` | `unwatch()` Forget about all watched keys.
    `RedisAPI` | `unwatch(Handler<AsyncResult<Response>> handler)` Forget about all watched keys.
    `RedisAPI` | `wait(String arg0, String arg1)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisAPI` | `wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    `RedisAPI` | `watch(List<String> args)` Watch the given keys to determine execution of the MULTI/EXEC block.
    `RedisAPI` | `watch(List<String> args, Handler<AsyncResult<Response>> handler)` Watch the given keys to determine execution of the MULTI/EXEC block.
    `RedisAPI` | `xack(List<String> args)` Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group.
    `RedisAPI` | `xack(List<String> args, Handler<AsyncResult<Response>> handler)` Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group.
    `RedisAPI` | `xadd(List<String> args)` Appends a new entry to a stream.
    `RedisAPI` | `xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Appends a new entry to a stream.
    `RedisAPI` | `xautoclaim(List<String> args)` Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
    `RedisAPI` | `xautoclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
    `RedisAPI` | `xclaim(List<String> args)` Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
    `RedisAPI` | `xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
    `RedisAPI` | `xdel(List<String> args)` Removes the specified entries from the stream.
    `RedisAPI` | `xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Removes the specified entries from the stream.
    `RedisAPI` | `xgroup(List<String> args)` A container for consumer groups commands.
    `RedisAPI` | `xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` A container for consumer groups commands.
    `RedisAPI` | `xinfo(List<String> args)` A container for stream introspection commands.
    `RedisAPI` | `xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` A container for stream introspection commands.
    `RedisAPI` | `xlen(String arg0)` Return the number of entries in a stream.
    `RedisAPI` | `xlen(String arg0, Handler<AsyncResult<Response>> handler)` Return the number of entries in a stream.
    `RedisAPI` | `xpending(List<String> args)` Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
    `RedisAPI` | `xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
    `RedisAPI` | `xrange(List<String> args)` Return a range of elements in a stream, with IDs matching the specified IDs interval.
    `RedisAPI` | `xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of elements in a stream, with IDs matching the specified IDs interval.
    `RedisAPI` | `xread(List<String> args)` Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream.
    `RedisAPI` | `xread(List<String> args, Handler<AsyncResult<Response>> handler)` Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream.
    `RedisAPI` | `xreadgroup(List<String> args)` Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer.
    `RedisAPI` | `xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer.
    `RedisAPI` | `xrevrange(List<String> args)` Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.
    `RedisAPI` | `xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.
    `RedisAPI` | `xsetid(List<String> args)` An internal command for replicating stream values.
    `RedisAPI` | `xsetid(List<String> args, Handler<AsyncResult<Response>> handler)` An internal command for replicating stream values.
    `RedisAPI` | `xtrim(List<String> args)` Trims the stream to (approximately if '~' is passed) a certain size.
    `RedisAPI` | `xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Trims the stream to (approximately if '~' is passed) a certain size.
    `RedisAPI` | `zadd(List<String> args)` Add one or more members to a sorted set, or update its score if it already exists.
    `RedisAPI` | `zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Add one or more members to a sorted set, or update its score if it already exists.
    `RedisAPI` | `zcard(String arg0)` Get the number of members in a sorted set.
    `RedisAPI` | `zcard(String arg0, Handler<AsyncResult<Response>> handler)` Get the number of members in a sorted set.
    `RedisAPI` | `zcount(String arg0, String arg1, String arg2)` Count the members in a sorted set with scores within the given values.
    `RedisAPI` | `zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Count the members in a sorted set with scores within the given values.
    `RedisAPI` | `zdiff(List<String> args)` Subtract multiple sorted sets.
    `RedisAPI` | `zdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sorted sets.
    `RedisAPI` | `zdiffstore(List<String> args)` Subtract multiple sorted sets and store the resulting sorted set in a new key.
    `RedisAPI` | `zdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Subtract multiple sorted sets and store the resulting sorted set in a new key.
    `RedisAPI` | `zincrby(String arg0, String arg1, String arg2)` Increment the score of a member in a sorted set.
    `RedisAPI` | `zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Increment the score of a member in a sorted set.
    `RedisAPI` | `zinter(List<String> args)` Intersect multiple sorted sets.
    `RedisAPI` | `zinter(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets.
    `RedisAPI` | `zintercard(List<String> args)` Intersect multiple sorted sets and return the cardinality of the result.
    `RedisAPI` | `zintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets and return the cardinality of the result.
    `RedisAPI` | `zinterstore(List<String> args)` Intersect multiple sorted sets and store the resulting sorted set in a new key.
    `RedisAPI` | `zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Intersect multiple sorted sets and store the resulting sorted set in a new key.
    `RedisAPI` | `zlexcount(String arg0, String arg1, String arg2)` Count the number of members in a sorted set between a given lexicographical range.
    `RedisAPI` | `zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Count the number of members in a sorted set between a given lexicographical range.
    `RedisAPI` | `zmpop(List<String> args)` Remove and return members with scores in a sorted set.
    `RedisAPI` | `zmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with scores in a sorted set.
    `RedisAPI` | `zmscore(List<String> args)` Get the score associated with the given members in a sorted set.
    `RedisAPI` | `zmscore(List<String> args, Handler<AsyncResult<Response>> handler)` Get the score associated with the given members in a sorted set.
    `RedisAPI` | `zpopmax(List<String> args)` Remove and return members with the highest scores in a sorted set.
    `RedisAPI` | `zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with the highest scores in a sorted set.
    `RedisAPI` | `zpopmin(List<String> args)` Remove and return members with the lowest scores in a sorted set.
    `RedisAPI` | `zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Remove and return members with the lowest scores in a sorted set.
    `RedisAPI` | `zrandmember(List<String> args)` Get one or multiple random elements from a sorted set.
    `RedisAPI` | `zrandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Get one or multiple random elements from a sorted set.
    `RedisAPI` | `zrange(List<String> args)` Return a range of members in a sorted set.
    `RedisAPI` | `zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set.
    `RedisAPI` | `zrangebylex(List<String> args)` Return a range of members in a sorted set, by lexicographical range.
    `RedisAPI` | `zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by lexicographical range.
    `RedisAPI` | `zrangebyscore(List<String> args)` Return a range of members in a sorted set, by score.
    `RedisAPI` | `zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by score.
    `RedisAPI` | `zrangestore(List<String> args)` Store a range of members from sorted set into another key.
    `RedisAPI` | `zrangestore(List<String> args, Handler<AsyncResult<Response>> handler)` Store a range of members from sorted set into another key.
    `RedisAPI` | `zrank(String arg0, String arg1)` Determine the index of a member in a sorted set.
    `RedisAPI` | `zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine the index of a member in a sorted set.
    `RedisAPI` | `zrem(List<String> args)` Remove one or more members from a sorted set.
    `RedisAPI` | `zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Remove one or more members from a sorted set.
    `RedisAPI` | `zremrangebylex(String arg0, String arg1, String arg2)` Remove all members in a sorted set between the given lexicographical range.
    `RedisAPI` | `zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set between the given lexicographical range.
    `RedisAPI` | `zremrangebyrank(String arg0, String arg1, String arg2)` Remove all members in a sorted set within the given indexes.
    `RedisAPI` | `zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set within the given indexes.
    `RedisAPI` | `zremrangebyscore(String arg0, String arg1, String arg2)` Remove all members in a sorted set within the given scores.
    `RedisAPI` | `zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Remove all members in a sorted set within the given scores.
    `RedisAPI` | `zrevrange(List<String> args)` Return a range of members in a sorted set, by index, with scores ordered from high to low.
    `RedisAPI` | `zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by index, with scores ordered from high to low.
    `RedisAPI` | `zrevrangebylex(List<String> args)` Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
    `RedisAPI` | `zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
    `RedisAPI` | `zrevrangebyscore(List<String> args)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
    `RedisAPI` | `zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
    `RedisAPI` | `zrevrank(String arg0, String arg1)` Determine the index of a member in a sorted set, with scores ordered from high to low.
    `RedisAPI` | `zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Determine the index of a member in a sorted set, with scores ordered from high to low.
    `RedisAPI` | `zscan(List<String> args)` Incrementally iterate sorted sets elements and associated scores.
    `RedisAPI` | `zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Incrementally iterate sorted sets elements and associated scores.
    `RedisAPI` | `zscore(String arg0, String arg1)` Get the score associated with the given member in a sorted set.
    `RedisAPI` | `zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Get the score associated with the given member in a sorted set.
    `RedisAPI` | `zunion(List<String> args)` Add multiple sorted sets.
    `RedisAPI` | `zunion(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sorted sets.
    `RedisAPI` | `zunionstore(List<String> args)` Add multiple sorted sets and store the resulting sorted set in a new key.
    `RedisAPI` | `zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Add multiple sorted sets 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<RedisAPI> __TYPE_ARG

  - ### Constructor Detail

    - #### RedisAPI

          public RedisAPI(RedisAPI delegate)

    - #### RedisAPI

          public RedisAPI(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 RedisAPI getDelegate()

      Specified by:
        `getDelegate` in interface `io.vertx.lang.rx.RxDelegate`

    - #### close

          public void close()

    - #### ftAdd

          public RedisAPI ftAdd(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command FT.ADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftAdd

          public RedisAPI ftAdd(List<String> args)

      Redis command FT.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtAdd

          public Single<Response> rxFtAdd(List<String> args)

      Redis command FT.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftAggregate

          public RedisAPI ftAggregate(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command FT.AGGREGATE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftAggregate

          public RedisAPI ftAggregate(List<String> args)

      Redis command FT.AGGREGATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtAggregate

          public Single<Response> rxFtAggregate(List<String> args)

      Redis command FT.AGGREGATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftAliasadd

          public RedisAPI ftAliasadd(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command FT.ALIASADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftAliasadd

          public RedisAPI ftAliasadd(List<String> args)

      Redis command FT.ALIASADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtAliasadd

          public Single<Response> rxFtAliasadd(List<String> args)

      Redis command FT.ALIASADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftAliasdel

          public RedisAPI ftAliasdel(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command FT.ALIASDEL.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftAliasdel

          public RedisAPI ftAliasdel(List<String> args)

      Redis command FT.ALIASDEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtAliasdel

          public Single<Response> rxFtAliasdel(List<String> args)

      Redis command FT.ALIASDEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftAliasupdate

          public RedisAPI ftAliasupdate(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command FT.ALIASUPDATE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftAliasupdate

          public RedisAPI ftAliasupdate(List<String> args)

      Redis command FT.ALIASUPDATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtAliasupdate

          public Single<Response> rxFtAliasupdate(List<String> args)

      Redis command FT.ALIASUPDATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftAlter

          public RedisAPI ftAlter(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command FT.ALTER.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftAlter

          public RedisAPI ftAlter(List<String> args)

      Redis command FT.ALTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtAlter

          public Single<Response> rxFtAlter(List<String> args)

      Redis command FT.ALTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftConfig

          public RedisAPI ftConfig(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command FT.CONFIG.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftConfig

          public RedisAPI ftConfig(List<String> args)

      Redis command FT.CONFIG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtConfig

          public Single<Response> rxFtConfig(List<String> args)

      Redis command FT.CONFIG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftCreate

          public RedisAPI ftCreate(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command FT.CREATE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftCreate

          public RedisAPI ftCreate(List<String> args)

      Redis command FT.CREATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtCreate

          public Single<Response> rxFtCreate(List<String> args)

      Redis command FT.CREATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftCursor

          public RedisAPI ftCursor(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command FT.CURSOR.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftCursor

          public RedisAPI ftCursor(List<String> args)

      Redis command FT.CURSOR.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtCursor

          public Single<Response> rxFtCursor(List<String> args)

      Redis command FT.CURSOR.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftDebug

          public RedisAPI ftDebug(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command FT.DEBUG.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftDebug

          public RedisAPI ftDebug(List<String> args)

      Redis command FT.DEBUG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtDebug

          public Single<Response> rxFtDebug(List<String> args)

      Redis command FT.DEBUG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftDel

          public RedisAPI ftDel(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command FT.DEL.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftDel

          public RedisAPI ftDel(List<String> args)

      Redis command FT.DEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtDel

          public Single<Response> rxFtDel(List<String> args)

      Redis command FT.DEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftDictadd

          public RedisAPI ftDictadd(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command FT.DICTADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftDictadd

          public RedisAPI ftDictadd(List<String> args)

      Redis command FT.DICTADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtDictadd

          public Single<Response> rxFtDictadd(List<String> args)

      Redis command FT.DICTADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftDictdel

          public RedisAPI ftDictdel(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command FT.DICTDEL.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftDictdel

          public RedisAPI ftDictdel(List<String> args)

      Redis command FT.DICTDEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtDictdel

          public Single<Response> rxFtDictdel(List<String> args)

      Redis command FT.DICTDEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftDictdump

          public RedisAPI ftDictdump(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command FT.DICTDUMP.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftDictdump

          public RedisAPI ftDictdump(List<String> args)

      Redis command FT.DICTDUMP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtDictdump

          public Single<Response> rxFtDictdump(List<String> args)

      Redis command FT.DICTDUMP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftDrop

          public RedisAPI ftDrop(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command FT.DROP.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftDrop

          public RedisAPI ftDrop(List<String> args)

      Redis command FT.DROP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtDrop

          public Single<Response> rxFtDrop(List<String> args)

      Redis command FT.DROP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftDropindex

          public RedisAPI ftDropindex(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command FT.DROPINDEX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftDropindex

          public RedisAPI ftDropindex(List<String> args)

      Redis command FT.DROPINDEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtDropindex

          public Single<Response> rxFtDropindex(List<String> args)

      Redis command FT.DROPINDEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftExplain

          public RedisAPI ftExplain(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command FT.EXPLAIN.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftExplain

          public RedisAPI ftExplain(List<String> args)

      Redis command FT.EXPLAIN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtExplain

          public Single<Response> rxFtExplain(List<String> args)

      Redis command FT.EXPLAIN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftExplaincli

          public RedisAPI ftExplaincli(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command FT.EXPLAINCLI.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftExplaincli

          public RedisAPI ftExplaincli(List<String> args)

      Redis command FT.EXPLAINCLI.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtExplaincli

          public Single<Response> rxFtExplaincli(List<String> args)

      Redis command FT.EXPLAINCLI.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftGet

          public RedisAPI ftGet(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command FT.GET.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftGet

          public RedisAPI ftGet(List<String> args)

      Redis command FT.GET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtGet

          public Single<Response> rxFtGet(List<String> args)

      Redis command FT.GET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftInfo

          public RedisAPI ftInfo(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command FT.INFO.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftInfo

          public RedisAPI ftInfo(List<String> args)

      Redis command FT.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtInfo

          public Single<Response> rxFtInfo(List<String> args)

      Redis command FT.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftMget

          public RedisAPI ftMget(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command FT.MGET.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftMget

          public RedisAPI ftMget(List<String> args)

      Redis command FT.MGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtMget

          public Single<Response> rxFtMget(List<String> args)

      Redis command FT.MGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftProfile

          public RedisAPI ftProfile(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command FT.PROFILE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftProfile

          public RedisAPI ftProfile(List<String> args)

      Redis command FT.PROFILE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtProfile

          public Single<Response> rxFtProfile(List<String> args)

      Redis command FT.PROFILE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftSafeadd

          public RedisAPI ftSafeadd(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command FT.SAFEADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftSafeadd

          public RedisAPI ftSafeadd(List<String> args)

      Redis command FT.SAFEADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtSafeadd

          public Single<Response> rxFtSafeadd(List<String> args)

      Redis command FT.SAFEADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftSearch

          public RedisAPI ftSearch(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command FT.SEARCH.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftSearch

          public RedisAPI ftSearch(List<String> args)

      Redis command FT.SEARCH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtSearch

          public Single<Response> rxFtSearch(List<String> args)

      Redis command FT.SEARCH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftSpellcheck

          public RedisAPI ftSpellcheck(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command FT.SPELLCHECK.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftSpellcheck

          public RedisAPI ftSpellcheck(List<String> args)

      Redis command FT.SPELLCHECK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtSpellcheck

          public Single<Response> rxFtSpellcheck(List<String> args)

      Redis command FT.SPELLCHECK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftSugadd

          public RedisAPI ftSugadd(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command FT.SUGADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftSugadd

          public RedisAPI ftSugadd(List<String> args)

      Redis command FT.SUGADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtSugadd

          public Single<Response> rxFtSugadd(List<String> args)

      Redis command FT.SUGADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftSugdel

          public RedisAPI ftSugdel(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command FT.SUGDEL.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftSugdel

          public RedisAPI ftSugdel(List<String> args)

      Redis command FT.SUGDEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtSugdel

          public Single<Response> rxFtSugdel(List<String> args)

      Redis command FT.SUGDEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftSugget

          public RedisAPI ftSugget(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command FT.SUGGET.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftSugget

          public RedisAPI ftSugget(List<String> args)

      Redis command FT.SUGGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtSugget

          public Single<Response> rxFtSugget(List<String> args)

      Redis command FT.SUGGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftSuglen

          public RedisAPI ftSuglen(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command FT.SUGLEN.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftSuglen

          public RedisAPI ftSuglen(List<String> args)

      Redis command FT.SUGLEN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtSuglen

          public Single<Response> rxFtSuglen(List<String> args)

      Redis command FT.SUGLEN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftSynadd

          public RedisAPI ftSynadd(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command FT.SYNADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftSynadd

          public RedisAPI ftSynadd(List<String> args)

      Redis command FT.SYNADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtSynadd

          public Single<Response> rxFtSynadd(List<String> args)

      Redis command FT.SYNADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftSyndump

          public RedisAPI ftSyndump(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command FT.SYNDUMP.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftSyndump

          public RedisAPI ftSyndump(List<String> args)

      Redis command FT.SYNDUMP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtSyndump

          public Single<Response> rxFtSyndump(List<String> args)

      Redis command FT.SYNDUMP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftSynupdate

          public RedisAPI ftSynupdate(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command FT.SYNUPDATE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftSynupdate

          public RedisAPI ftSynupdate(List<String> args)

      Redis command FT.SYNUPDATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtSynupdate

          public Single<Response> rxFtSynupdate(List<String> args)

      Redis command FT.SYNUPDATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftTagvals

          public RedisAPI ftTagvals(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command FT.TAGVALS.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftTagvals

          public RedisAPI ftTagvals(List<String> args)

      Redis command FT.TAGVALS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtTagvals

          public Single<Response> rxFtTagvals(List<String> args)

      Redis command FT.TAGVALS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftAliasaddifnx

          public RedisAPI ftAliasaddifnx(List<String> args,
                                         Handler<AsyncResult<Response>> handler)

      Redis command FT._ALIASADDIFNX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftAliasaddifnx

          public RedisAPI ftAliasaddifnx(List<String> args)

      Redis command FT._ALIASADDIFNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtAliasaddifnx

          public Single<Response> rxFtAliasaddifnx(List<String> args)

      Redis command FT._ALIASADDIFNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftAliasdelifx

          public RedisAPI ftAliasdelifx(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command FT._ALIASDELIFX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftAliasdelifx

          public RedisAPI ftAliasdelifx(List<String> args)

      Redis command FT._ALIASDELIFX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtAliasdelifx

          public Single<Response> rxFtAliasdelifx(List<String> args)

      Redis command FT._ALIASDELIFX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftAlterifnx

          public RedisAPI ftAlterifnx(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command FT._ALTERIFNX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftAlterifnx

          public RedisAPI ftAlterifnx(List<String> args)

      Redis command FT._ALTERIFNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtAlterifnx

          public Single<Response> rxFtAlterifnx(List<String> args)

      Redis command FT._ALTERIFNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftCreateifnx

          public RedisAPI ftCreateifnx(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command FT._CREATEIFNX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftCreateifnx

          public RedisAPI ftCreateifnx(List<String> args)

      Redis command FT._CREATEIFNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtCreateifnx

          public Single<Response> rxFtCreateifnx(List<String> args)

      Redis command FT._CREATEIFNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftDropifx

          public RedisAPI ftDropifx(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command FT._DROPIFX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftDropifx

          public RedisAPI ftDropifx(List<String> args)

      Redis command FT._DROPIFX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtDropifx

          public Single<Response> rxFtDropifx(List<String> args)

      Redis command FT._DROPIFX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftDropindexifx

          public RedisAPI ftDropindexifx(List<String> args,
                                         Handler<AsyncResult<Response>> handler)

      Redis command FT._DROPINDEXIFX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftDropindexifx

          public RedisAPI ftDropindexifx(List<String> args)

      Redis command FT._DROPINDEXIFX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtDropindexifx

          public Single<Response> rxFtDropindexifx(List<String> args)

      Redis command FT._DROPINDEXIFX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ftList

          public RedisAPI ftList(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command FT._LIST.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ftList

          public RedisAPI ftList(List<String> args)

      Redis command FT._LIST.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFtList

          public Single<Response> rxFtList(List<String> args)

      Redis command FT._LIST.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### acl

          public RedisAPI acl(List<String> args,
                              Handler<AsyncResult<Response>> handler)

      A container for Access List Control commands.

      Redis command ACL.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### acl

          public RedisAPI acl(List<String> args)

      A container for Access List Control commands.

      Redis command ACL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxAcl

          public Single<Response> rxAcl(List<String> args)

      A container for Access List Control commands.

      Redis command ACL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### append

          public RedisAPI append(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Append a value to a key.

      Redis command APPEND.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### append

          public RedisAPI append(String arg0,
                                 String arg1)

      Append a value to a key.

      Redis command APPEND.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxAppend

          public Single<Response> rxAppend(String arg0,
                                           String arg1)

      Append a value to a key.

      Redis command APPEND.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### asking

          public RedisAPI asking(Handler<AsyncResult<Response>> handler)

      Sent by cluster clients after an -ASK redirect.

      Redis command ASKING.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### asking

          public RedisAPI asking()

      Sent by cluster clients after an -ASK redirect.

      Redis command ASKING.

      Returns:
        fluent self

    - #### rxAsking

          public Single<Response> rxAsking()

      Sent by cluster clients after an -ASK redirect.

      Redis command ASKING.

      Returns:
        fluent self

    - #### auth

          public RedisAPI auth(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Authenticate to the server.

      Redis command AUTH.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### auth

          public RedisAPI auth(List<String> args)

      Authenticate to the server.

      Redis command AUTH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxAuth

          public Single<Response> rxAuth(List<String> args)

      Authenticate to the server.

      Redis command AUTH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bfAdd

          public RedisAPI bfAdd(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command BF.ADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bfAdd

          public RedisAPI bfAdd(List<String> args)

      Redis command BF.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBfAdd

          public Single<Response> rxBfAdd(List<String> args)

      Redis command BF.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bfCard

          public RedisAPI bfCard(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command BF.CARD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bfCard

          public RedisAPI bfCard(List<String> args)

      Redis command BF.CARD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBfCard

          public Single<Response> rxBfCard(List<String> args)

      Redis command BF.CARD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bfDebug

          public RedisAPI bfDebug(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command BF.DEBUG.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bfDebug

          public RedisAPI bfDebug(List<String> args)

      Redis command BF.DEBUG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBfDebug

          public Single<Response> rxBfDebug(List<String> args)

      Redis command BF.DEBUG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bfExists

          public RedisAPI bfExists(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command BF.EXISTS.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bfExists

          public RedisAPI bfExists(List<String> args)

      Redis command BF.EXISTS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBfExists

          public Single<Response> rxBfExists(List<String> args)

      Redis command BF.EXISTS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bfInfo

          public RedisAPI bfInfo(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command BF.INFO.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bfInfo

          public RedisAPI bfInfo(List<String> args)

      Redis command BF.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBfInfo

          public Single<Response> rxBfInfo(List<String> args)

      Redis command BF.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bfInsert

          public RedisAPI bfInsert(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command BF.INSERT.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bfInsert

          public RedisAPI bfInsert(List<String> args)

      Redis command BF.INSERT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBfInsert

          public Single<Response> rxBfInsert(List<String> args)

      Redis command BF.INSERT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bfLoadchunk

          public RedisAPI bfLoadchunk(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command BF.LOADCHUNK.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bfLoadchunk

          public RedisAPI bfLoadchunk(List<String> args)

      Redis command BF.LOADCHUNK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBfLoadchunk

          public Single<Response> rxBfLoadchunk(List<String> args)

      Redis command BF.LOADCHUNK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bfMadd

          public RedisAPI bfMadd(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command BF.MADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bfMadd

          public RedisAPI bfMadd(List<String> args)

      Redis command BF.MADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBfMadd

          public Single<Response> rxBfMadd(List<String> args)

      Redis command BF.MADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bfMexists

          public RedisAPI bfMexists(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command BF.MEXISTS.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bfMexists

          public RedisAPI bfMexists(List<String> args)

      Redis command BF.MEXISTS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBfMexists

          public Single<Response> rxBfMexists(List<String> args)

      Redis command BF.MEXISTS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bfReserve

          public RedisAPI bfReserve(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command BF.RESERVE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bfReserve

          public RedisAPI bfReserve(List<String> args)

      Redis command BF.RESERVE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBfReserve

          public Single<Response> rxBfReserve(List<String> args)

      Redis command BF.RESERVE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bfScandump

          public RedisAPI bfScandump(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command BF.SCANDUMP.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bfScandump

          public RedisAPI bfScandump(List<String> args)

      Redis command BF.SCANDUMP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBfScandump

          public Single<Response> rxBfScandump(List<String> args)

      Redis command BF.SCANDUMP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bgrewriteaof

          public RedisAPI bgrewriteaof(Handler<AsyncResult<Response>> handler)

      Asynchronously rewrite the append-only file.

      Redis command BGREWRITEAOF.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### bgrewriteaof

          public RedisAPI bgrewriteaof()

      Asynchronously rewrite the append-only file.

      Redis command BGREWRITEAOF.

      Returns:
        fluent self

    - #### rxBgrewriteaof

          public Single<Response> rxBgrewriteaof()

      Asynchronously rewrite the append-only file.

      Redis command BGREWRITEAOF.

      Returns:
        fluent self

    - #### bgsave

          public RedisAPI bgsave(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Asynchronously save the dataset to disk.

      Redis command BGSAVE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bgsave

          public RedisAPI bgsave(List<String> args)

      Asynchronously save the dataset to disk.

      Redis command BGSAVE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBgsave

          public Single<Response> rxBgsave(List<String> args)

      Asynchronously save the dataset to disk.

      Redis command BGSAVE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitcount

          public RedisAPI bitcount(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Count set bits in a string.

      Redis command BITCOUNT.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bitcount

          public RedisAPI bitcount(List<String> args)

      Count set bits in a string.

      Redis command BITCOUNT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitcount

          public Single<Response> rxBitcount(List<String> args)

      Count set bits in a string.

      Redis command BITCOUNT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitfield

          public RedisAPI bitfield(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Perform arbitrary bitfield integer operations on strings.

      Redis command BITFIELD.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bitfield

          public RedisAPI bitfield(List<String> args)

      Perform arbitrary bitfield integer operations on strings.

      Redis command BITFIELD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitfield

          public Single<Response> rxBitfield(List<String> args)

      Perform arbitrary bitfield integer operations on strings.

      Redis command BITFIELD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitfieldRo

          public RedisAPI bitfieldRo(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD.

      Redis command BITFIELD_RO.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bitfieldRo

          public RedisAPI bitfieldRo(List<String> args)

      Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD.

      Redis command BITFIELD_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitfieldRo

          public Single<Response> rxBitfieldRo(List<String> args)

      Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD.

      Redis command BITFIELD_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitop

          public RedisAPI bitop(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Perform bitwise operations between strings.

      Redis command BITOP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bitop

          public RedisAPI bitop(List<String> args)

      Perform bitwise operations between strings.

      Redis command BITOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitop

          public Single<Response> rxBitop(List<String> args)

      Perform bitwise operations between strings.

      Redis command BITOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitpos

          public RedisAPI bitpos(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Find first bit set or clear in a string.

      Redis command BITPOS.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bitpos

          public RedisAPI bitpos(List<String> args)

      Find first bit set or clear in a string.

      Redis command BITPOS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitpos

          public Single<Response> rxBitpos(List<String> args)

      Find first bit set or clear in a string.

      Redis command BITPOS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### blmove

          public RedisAPI blmove(String arg0,
                                 String arg1,
                                 String arg2,
                                 String arg3,
                                 String arg4,
                                 Handler<AsyncResult<Response>> handler)

      Pop an element from a list, push it to another list and return it; or block until one is available.

      Redis command BLMOVE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
        `arg4` -
        `handler` -
      Returns:
        fluent self

    - #### blmove

          public RedisAPI blmove(String arg0,
                                 String arg1,
                                 String arg2,
                                 String arg3,
                                 String arg4)

      Pop an element from a list, push it to another list and return it; or block until one is available.

      Redis command BLMOVE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
        `arg4` -
      Returns:
        fluent self

    - #### rxBlmove

          public Single<Response> rxBlmove(String arg0,
                                           String arg1,
                                           String arg2,
                                           String arg3,
                                           String arg4)

      Pop an element from a list, push it to another list and return it; or block until one is available.

      Redis command BLMOVE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
        `arg4` -
      Returns:
        fluent self

    - #### blmpop

          public RedisAPI blmpop(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Pop elements from a list, or block until one is available.

      Redis command BLMPOP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### blmpop

          public RedisAPI blmpop(List<String> args)

      Pop elements from a list, or block until one is available.

      Redis command BLMPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBlmpop

          public Single<Response> rxBlmpop(List<String> args)

      Pop elements from a list, or block until one is available.

      Redis command BLMPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### blpop

          public RedisAPI blpop(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Remove and get the first element in a list, or block until one is available.

      Redis command BLPOP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### blpop

          public RedisAPI blpop(List<String> args)

      Remove and get the first element in a list, or block until one is available.

      Redis command BLPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBlpop

          public Single<Response> rxBlpop(List<String> args)

      Remove and get the first element in a list, or block until one is available.

      Redis command BLPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### brpop

          public RedisAPI brpop(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Remove and get the last element in a list, or block until one is available.

      Redis command BRPOP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### brpop

          public RedisAPI brpop(List<String> args)

      Remove and get the last element in a list, or block until one is available.

      Redis command BRPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBrpop

          public Single<Response> rxBrpop(List<String> args)

      Remove and get the last element in a list, or block until one is available.

      Redis command BRPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### brpoplpush

          public RedisAPI brpoplpush(String arg0,
                                     String arg1,
                                     String arg2,
                                     Handler<AsyncResult<Response>> handler)

      Pop an element from a list, push it to another list and return it; or block until one is available.

      Redis command BRPOPLPUSH.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### brpoplpush

          public RedisAPI brpoplpush(String arg0,
                                     String arg1,
                                     String arg2)

      Pop an element from a list, push it to another list and return it; or block until one is available.

      Redis command BRPOPLPUSH.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxBrpoplpush

          public Single<Response> rxBrpoplpush(String arg0,
                                               String arg1,
                                               String arg2)

      Pop an element from a list, push it to another list and return it; or block until one is available.

      Redis command BRPOPLPUSH.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### bzmpop

          public RedisAPI bzmpop(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Remove and return members with scores in a sorted set or block until one is available.

      Redis command BZMPOP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bzmpop

          public RedisAPI bzmpop(List<String> args)

      Remove and return members with scores in a sorted set or block until one is available.

      Redis command BZMPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBzmpop

          public Single<Response> rxBzmpop(List<String> args)

      Remove and return members with scores in a sorted set or block until one is available.

      Redis command BZMPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bzpopmax

          public RedisAPI bzpopmax(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Remove and return the member with the highest score from one or more sorted sets, or block until one is available.

      Redis command BZPOPMAX.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bzpopmax

          public RedisAPI bzpopmax(List<String> args)

      Remove and return the member with the highest score from one or more sorted sets, or block until one is available.

      Redis command BZPOPMAX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBzpopmax

          public Single<Response> rxBzpopmax(List<String> args)

      Remove and return the member with the highest score from one or more sorted sets, or block until one is available.

      Redis command BZPOPMAX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bzpopmin

          public RedisAPI bzpopmin(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.

      Redis command BZPOPMIN.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bzpopmin

          public RedisAPI bzpopmin(List<String> args)

      Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.

      Redis command BZPOPMIN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBzpopmin

          public Single<Response> rxBzpopmin(List<String> args)

      Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.

      Redis command BZPOPMIN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfAdd

          public RedisAPI cfAdd(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command CF.ADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfAdd

          public RedisAPI cfAdd(List<String> args)

      Redis command CF.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfAdd

          public Single<Response> rxCfAdd(List<String> args)

      Redis command CF.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfAddnx

          public RedisAPI cfAddnx(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command CF.ADDNX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfAddnx

          public RedisAPI cfAddnx(List<String> args)

      Redis command CF.ADDNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfAddnx

          public Single<Response> rxCfAddnx(List<String> args)

      Redis command CF.ADDNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfCompact

          public RedisAPI cfCompact(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command CF.COMPACT.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfCompact

          public RedisAPI cfCompact(List<String> args)

      Redis command CF.COMPACT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfCompact

          public Single<Response> rxCfCompact(List<String> args)

      Redis command CF.COMPACT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfCount

          public RedisAPI cfCount(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command CF.COUNT.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfCount

          public RedisAPI cfCount(List<String> args)

      Redis command CF.COUNT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfCount

          public Single<Response> rxCfCount(List<String> args)

      Redis command CF.COUNT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfDebug

          public RedisAPI cfDebug(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command CF.DEBUG.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfDebug

          public RedisAPI cfDebug(List<String> args)

      Redis command CF.DEBUG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfDebug

          public Single<Response> rxCfDebug(List<String> args)

      Redis command CF.DEBUG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfDel

          public RedisAPI cfDel(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command CF.DEL.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfDel

          public RedisAPI cfDel(List<String> args)

      Redis command CF.DEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfDel

          public Single<Response> rxCfDel(List<String> args)

      Redis command CF.DEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfExists

          public RedisAPI cfExists(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command CF.EXISTS.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfExists

          public RedisAPI cfExists(List<String> args)

      Redis command CF.EXISTS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfExists

          public Single<Response> rxCfExists(List<String> args)

      Redis command CF.EXISTS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfInfo

          public RedisAPI cfInfo(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command CF.INFO.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfInfo

          public RedisAPI cfInfo(List<String> args)

      Redis command CF.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfInfo

          public Single<Response> rxCfInfo(List<String> args)

      Redis command CF.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfInsert

          public RedisAPI cfInsert(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command CF.INSERT.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfInsert

          public RedisAPI cfInsert(List<String> args)

      Redis command CF.INSERT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfInsert

          public Single<Response> rxCfInsert(List<String> args)

      Redis command CF.INSERT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfInsertnx

          public RedisAPI cfInsertnx(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command CF.INSERTNX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfInsertnx

          public RedisAPI cfInsertnx(List<String> args)

      Redis command CF.INSERTNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfInsertnx

          public Single<Response> rxCfInsertnx(List<String> args)

      Redis command CF.INSERTNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfLoadchunk

          public RedisAPI cfLoadchunk(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command CF.LOADCHUNK.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfLoadchunk

          public RedisAPI cfLoadchunk(List<String> args)

      Redis command CF.LOADCHUNK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfLoadchunk

          public Single<Response> rxCfLoadchunk(List<String> args)

      Redis command CF.LOADCHUNK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfMexists

          public RedisAPI cfMexists(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command CF.MEXISTS.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfMexists

          public RedisAPI cfMexists(List<String> args)

      Redis command CF.MEXISTS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfMexists

          public Single<Response> rxCfMexists(List<String> args)

      Redis command CF.MEXISTS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfReserve

          public RedisAPI cfReserve(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command CF.RESERVE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfReserve

          public RedisAPI cfReserve(List<String> args)

      Redis command CF.RESERVE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfReserve

          public Single<Response> rxCfReserve(List<String> args)

      Redis command CF.RESERVE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cfScandump

          public RedisAPI cfScandump(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command CF.SCANDUMP.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cfScandump

          public RedisAPI cfScandump(List<String> args)

      Redis command CF.SCANDUMP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCfScandump

          public Single<Response> rxCfScandump(List<String> args)

      Redis command CF.SCANDUMP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### client

          public RedisAPI client(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      A container for client connection commands.

      Redis command CLIENT.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### client

          public RedisAPI client(List<String> args)

      A container for client connection commands.

      Redis command CLIENT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxClient

          public Single<Response> rxClient(List<String> args)

      A container for client connection commands.

      Redis command CLIENT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cluster

          public RedisAPI cluster(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      A container for cluster commands.

      Redis command CLUSTER.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cluster

          public RedisAPI cluster(List<String> args)

      A container for cluster commands.

      Redis command CLUSTER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCluster

          public Single<Response> rxCluster(List<String> args)

      A container for cluster commands.

      Redis command CLUSTER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cmsIncrby

          public RedisAPI cmsIncrby(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command CMS.INCRBY.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cmsIncrby

          public RedisAPI cmsIncrby(List<String> args)

      Redis command CMS.INCRBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCmsIncrby

          public Single<Response> rxCmsIncrby(List<String> args)

      Redis command CMS.INCRBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cmsInfo

          public RedisAPI cmsInfo(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command CMS.INFO.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cmsInfo

          public RedisAPI cmsInfo(List<String> args)

      Redis command CMS.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCmsInfo

          public Single<Response> rxCmsInfo(List<String> args)

      Redis command CMS.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cmsInitbydim

          public RedisAPI cmsInitbydim(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command CMS.INITBYDIM.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cmsInitbydim

          public RedisAPI cmsInitbydim(List<String> args)

      Redis command CMS.INITBYDIM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCmsInitbydim

          public Single<Response> rxCmsInitbydim(List<String> args)

      Redis command CMS.INITBYDIM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cmsInitbyprob

          public RedisAPI cmsInitbyprob(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command CMS.INITBYPROB.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cmsInitbyprob

          public RedisAPI cmsInitbyprob(List<String> args)

      Redis command CMS.INITBYPROB.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCmsInitbyprob

          public Single<Response> rxCmsInitbyprob(List<String> args)

      Redis command CMS.INITBYPROB.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cmsMerge

          public RedisAPI cmsMerge(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command CMS.MERGE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cmsMerge

          public RedisAPI cmsMerge(List<String> args)

      Redis command CMS.MERGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCmsMerge

          public Single<Response> rxCmsMerge(List<String> args)

      Redis command CMS.MERGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cmsQuery

          public RedisAPI cmsQuery(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command CMS.QUERY.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### cmsQuery

          public RedisAPI cmsQuery(List<String> args)

      Redis command CMS.QUERY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCmsQuery

          public Single<Response> rxCmsQuery(List<String> args)

      Redis command CMS.QUERY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### command

          public RedisAPI command(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Get array of Redis command details.

      Redis command COMMAND.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### command

          public RedisAPI command(List<String> args)

      Get array of Redis command details.

      Redis command COMMAND.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCommand

          public Single<Response> rxCommand(List<String> args)

      Get array of Redis command details.

      Redis command COMMAND.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### config

          public RedisAPI config(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      A container for server configuration commands.

      Redis command CONFIG.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### config

          public RedisAPI config(List<String> args)

      A container for server configuration commands.

      Redis command CONFIG.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxConfig

          public Single<Response> rxConfig(List<String> args)

      A container for server configuration commands.

      Redis command CONFIG.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### copy

          public RedisAPI copy(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Copy a key.

      Redis command COPY.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### copy

          public RedisAPI copy(List<String> args)

      Copy a key.

      Redis command COPY.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCopy

          public Single<Response> rxCopy(List<String> args)

      Copy a key.

      Redis command COPY.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### dbsize

          public RedisAPI dbsize(Handler<AsyncResult<Response>> handler)

      Return the number of keys in the selected database.

      Redis command DBSIZE.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### dbsize

          public RedisAPI dbsize()

      Return the number of keys in the selected database.

      Redis command DBSIZE.

      Returns:
        fluent self

    - #### rxDbsize

          public Single<Response> rxDbsize()

      Return the number of keys in the selected database.

      Redis command DBSIZE.

      Returns:
        fluent self

    - #### debug

          public RedisAPI debug(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      A container for debugging commands.

      Redis command DEBUG.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### debug

          public RedisAPI debug(List<String> args)

      A container for debugging commands.

      Redis command DEBUG.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxDebug

          public Single<Response> rxDebug(List<String> args)

      A container for debugging commands.

      Redis command DEBUG.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### decr

          public RedisAPI decr(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Decrement the integer value of a key by one.

      Redis command DECR.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### decr

          public RedisAPI decr(String arg0)

      Decrement the integer value of a key by one.

      Redis command DECR.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxDecr

          public Single<Response> rxDecr(String arg0)

      Decrement the integer value of a key by one.

      Redis command DECR.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### decrby

          public RedisAPI decrby(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Decrement the integer value of a key by the given number.

      Redis command DECRBY.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### decrby

          public RedisAPI decrby(String arg0,
                                 String arg1)

      Decrement the integer value of a key by the given number.

      Redis command DECRBY.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxDecrby

          public Single<Response> rxDecrby(String arg0,
                                           String arg1)

      Decrement the integer value of a key by the given number.

      Redis command DECRBY.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### del

          public RedisAPI del(List<String> args,
                              Handler<AsyncResult<Response>> handler)

      Delete a key.

      Redis command DEL.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### del

          public RedisAPI del(List<String> args)

      Delete a key.

      Redis command DEL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxDel

          public Single<Response> rxDel(List<String> args)

      Delete a key.

      Redis command DEL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### discard

          public RedisAPI discard(Handler<AsyncResult<Response>> handler)

      Discard all commands issued after MULTI.

      Redis command DISCARD.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### discard

          public RedisAPI discard()

      Discard all commands issued after MULTI.

      Redis command DISCARD.

      Returns:
        fluent self

    - #### rxDiscard

          public Single<Response> rxDiscard()

      Discard all commands issued after MULTI.

      Redis command DISCARD.

      Returns:
        fluent self

    - #### dump

          public RedisAPI dump(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Return a serialized version of the value stored at the specified key.

      Redis command DUMP.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### dump

          public RedisAPI dump(String arg0)

      Return a serialized version of the value stored at the specified key.

      Redis command DUMP.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxDump

          public Single<Response> rxDump(String arg0)

      Return a serialized version of the value stored at the specified key.

      Redis command DUMP.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### echo

          public RedisAPI echo(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Echo the given string.

      Redis command ECHO.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### echo

          public RedisAPI echo(String arg0)

      Echo the given string.

      Redis command ECHO.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxEcho

          public Single<Response> rxEcho(String arg0)

      Echo the given string.

      Redis command ECHO.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### eval

          public RedisAPI eval(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Execute a Lua script server side.

      Redis command EVAL.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### eval

          public RedisAPI eval(List<String> args)

      Execute a Lua script server side.

      Redis command EVAL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxEval

          public Single<Response> rxEval(List<String> args)

      Execute a Lua script server side.

      Redis command EVAL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### evalRo

          public RedisAPI evalRo(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Execute a read-only Lua script server side.

      Redis command EVAL_RO.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### evalRo

          public RedisAPI evalRo(List<String> args)

      Execute a read-only Lua script server side.

      Redis command EVAL_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxEvalRo

          public Single<Response> rxEvalRo(List<String> args)

      Execute a read-only Lua script server side.

      Redis command EVAL_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### evalsha

          public RedisAPI evalsha(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Execute a Lua script server side.

      Redis command EVALSHA.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### evalsha

          public RedisAPI evalsha(List<String> args)

      Execute a Lua script server side.

      Redis command EVALSHA.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxEvalsha

          public Single<Response> rxEvalsha(List<String> args)

      Execute a Lua script server side.

      Redis command EVALSHA.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### evalshaRo

          public RedisAPI evalshaRo(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Execute a read-only Lua script server side.

      Redis command EVALSHA_RO.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### evalshaRo

          public RedisAPI evalshaRo(List<String> args)

      Execute a read-only Lua script server side.

      Redis command EVALSHA_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxEvalshaRo

          public Single<Response> rxEvalshaRo(List<String> args)

      Execute a read-only Lua script server side.

      Redis command EVALSHA_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### exec

          public RedisAPI exec(Handler<AsyncResult<Response>> handler)

      Execute all commands issued after MULTI.

      Redis command EXEC.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### exec

          public RedisAPI exec()

      Execute all commands issued after MULTI.

      Redis command EXEC.

      Returns:
        fluent self

    - #### rxExec

          public Single<Response> rxExec()

      Execute all commands issued after MULTI.

      Redis command EXEC.

      Returns:
        fluent self

    - #### exists

          public RedisAPI exists(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Determine if a key exists.

      Redis command EXISTS.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### exists

          public RedisAPI exists(List<String> args)

      Determine if a key exists.

      Redis command EXISTS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxExists

          public Single<Response> rxExists(List<String> args)

      Determine if a key exists.

      Redis command EXISTS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### expire

          public RedisAPI expire(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Set a key's time to live in seconds.

      Redis command EXPIRE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### expire

          public RedisAPI expire(List<String> args)

      Set a key's time to live in seconds.

      Redis command EXPIRE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxExpire

          public Single<Response> rxExpire(List<String> args)

      Set a key's time to live in seconds.

      Redis command EXPIRE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### expireat

          public RedisAPI expireat(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Set the expiration for a key as a UNIX timestamp.

      Redis command EXPIREAT.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### expireat

          public RedisAPI expireat(List<String> args)

      Set the expiration for a key as a UNIX timestamp.

      Redis command EXPIREAT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxExpireat

          public Single<Response> rxExpireat(List<String> args)

      Set the expiration for a key as a UNIX timestamp.

      Redis command EXPIREAT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### expiretime

          public RedisAPI expiretime(String arg0,
                                     Handler<AsyncResult<Response>> handler)

      Get the expiration Unix timestamp for a key.

      Redis command EXPIRETIME.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### expiretime

          public RedisAPI expiretime(String arg0)

      Get the expiration Unix timestamp for a key.

      Redis command EXPIRETIME.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxExpiretime

          public Single<Response> rxExpiretime(String arg0)

      Get the expiration Unix timestamp for a key.

      Redis command EXPIRETIME.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### failover

          public RedisAPI failover(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Start a coordinated failover between this server and one of its replicas.

      Redis command FAILOVER.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### failover

          public RedisAPI failover(List<String> args)

      Start a coordinated failover between this server and one of its replicas.

      Redis command FAILOVER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFailover

          public Single<Response> rxFailover(List<String> args)

      Start a coordinated failover between this server and one of its replicas.

      Redis command FAILOVER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### fcall

          public RedisAPI fcall(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Invoke a function.

      Redis command FCALL.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### fcall

          public RedisAPI fcall(List<String> args)

      Invoke a function.

      Redis command FCALL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFcall

          public Single<Response> rxFcall(List<String> args)

      Invoke a function.

      Redis command FCALL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### fcallRo

          public RedisAPI fcallRo(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Invoke a read-only function.

      Redis command FCALL_RO.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### fcallRo

          public RedisAPI fcallRo(List<String> args)

      Invoke a read-only function.

      Redis command FCALL_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFcallRo

          public Single<Response> rxFcallRo(List<String> args)

      Invoke a read-only function.

      Redis command FCALL_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### flushall

          public RedisAPI flushall(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Remove all keys from all databases.

      Redis command FLUSHALL.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### flushall

          public RedisAPI flushall(List<String> args)

      Remove all keys from all databases.

      Redis command FLUSHALL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFlushall

          public Single<Response> rxFlushall(List<String> args)

      Remove all keys from all databases.

      Redis command FLUSHALL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### flushdb

          public RedisAPI flushdb(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Remove all keys from the current database.

      Redis command FLUSHDB.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### flushdb

          public RedisAPI flushdb(List<String> args)

      Remove all keys from the current database.

      Redis command FLUSHDB.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFlushdb

          public Single<Response> rxFlushdb(List<String> args)

      Remove all keys from the current database.

      Redis command FLUSHDB.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### function

          public RedisAPI function(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      A container for function commands.

      Redis command FUNCTION.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### function

          public RedisAPI function(List<String> args)

      A container for function commands.

      Redis command FUNCTION.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFunction

          public Single<Response> rxFunction(List<String> args)

      A container for function commands.

      Redis command FUNCTION.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geoadd

          public RedisAPI geoadd(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Add one or more geospatial items in the geospatial index represented using a sorted set.

      Redis command GEOADD.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### geoadd

          public RedisAPI geoadd(List<String> args)

      Add one or more geospatial items in the geospatial index represented using a sorted set.

      Redis command GEOADD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoadd

          public Single<Response> rxGeoadd(List<String> args)

      Add one or more geospatial items in the geospatial index represented using a sorted set.

      Redis command GEOADD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geodist

          public RedisAPI geodist(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Returns the distance between two members of a geospatial index.

      Redis command GEODIST.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### geodist

          public RedisAPI geodist(List<String> args)

      Returns the distance between two members of a geospatial index.

      Redis command GEODIST.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeodist

          public Single<Response> rxGeodist(List<String> args)

      Returns the distance between two members of a geospatial index.

      Redis command GEODIST.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geohash

          public RedisAPI geohash(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Returns members of a geospatial index as standard geohash strings.

      Redis command GEOHASH.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### geohash

          public RedisAPI geohash(List<String> args)

      Returns members of a geospatial index as standard geohash strings.

      Redis command GEOHASH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeohash

          public Single<Response> rxGeohash(List<String> args)

      Returns members of a geospatial index as standard geohash strings.

      Redis command GEOHASH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geopos

          public RedisAPI geopos(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Returns longitude and latitude of members of a geospatial index.

      Redis command GEOPOS.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### geopos

          public RedisAPI geopos(List<String> args)

      Returns longitude and latitude of members of a geospatial index.

      Redis command GEOPOS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeopos

          public Single<Response> rxGeopos(List<String> args)

      Returns longitude and latitude of members of a geospatial index.

      Redis command GEOPOS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadius

          public RedisAPI georadius(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.

      Redis command GEORADIUS.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### georadius

          public RedisAPI georadius(List<String> args)

      Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.

      Redis command GEORADIUS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradius

          public Single<Response> rxGeoradius(List<String> args)

      Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.

      Redis command GEORADIUS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadiusRo

          public RedisAPI georadiusRo(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      A read-only variant for GEORADIUS.

      Redis command GEORADIUS_RO.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### georadiusRo

          public RedisAPI georadiusRo(List<String> args)

      A read-only variant for GEORADIUS.

      Redis command GEORADIUS_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradiusRo

          public Single<Response> rxGeoradiusRo(List<String> args)

      A read-only variant for GEORADIUS.

      Redis command GEORADIUS_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadiusbymember

          public RedisAPI georadiusbymember(List<String> args,
                                            Handler<AsyncResult<Response>> handler)

      Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.

      Redis command GEORADIUSBYMEMBER.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### georadiusbymember

          public RedisAPI georadiusbymember(List<String> args)

      Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.

      Redis command GEORADIUSBYMEMBER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradiusbymember

          public Single<Response> rxGeoradiusbymember(List<String> args)

      Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.

      Redis command GEORADIUSBYMEMBER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadiusbymemberRo

          public RedisAPI georadiusbymemberRo(List<String> args,
                                              Handler<AsyncResult<Response>> handler)

      A read-only variant for GEORADIUSBYMEMBER.

      Redis command GEORADIUSBYMEMBER_RO.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### georadiusbymemberRo

          public RedisAPI georadiusbymemberRo(List<String> args)

      A read-only variant for GEORADIUSBYMEMBER.

      Redis command GEORADIUSBYMEMBER_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradiusbymemberRo

          public Single<Response> rxGeoradiusbymemberRo(List<String> args)

      A read-only variant for GEORADIUSBYMEMBER.

      Redis command GEORADIUSBYMEMBER_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geosearch

          public RedisAPI geosearch(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.

      Redis command GEOSEARCH.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### geosearch

          public RedisAPI geosearch(List<String> args)

      Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.

      Redis command GEOSEARCH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeosearch

          public Single<Response> rxGeosearch(List<String> args)

      Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.

      Redis command GEOSEARCH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geosearchstore

          public RedisAPI geosearchstore(List<String> args,
                                         Handler<AsyncResult<Response>> handler)

      Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.

      Redis command GEOSEARCHSTORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### geosearchstore

          public RedisAPI geosearchstore(List<String> args)

      Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.

      Redis command GEOSEARCHSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeosearchstore

          public Single<Response> rxGeosearchstore(List<String> args)

      Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.

      Redis command GEOSEARCHSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### get

          public RedisAPI get(String arg0,
                              Handler<AsyncResult<Response>> handler)

      Get the value of a key.

      Redis command GET.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### get

          public RedisAPI get(String arg0)

      Get the value of a key.

      Redis command GET.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxGet

          public Single<Response> rxGet(String arg0)

      Get the value of a key.

      Redis command GET.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### getbit

          public RedisAPI getbit(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

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

      Redis command GETBIT.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### getbit

          public RedisAPI getbit(String arg0,
                                 String arg1)

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

      Redis command GETBIT.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxGetbit

          public Single<Response> rxGetbit(String arg0,
                                           String arg1)

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

      Redis command GETBIT.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### getdel

          public RedisAPI getdel(String arg0,
                                 Handler<AsyncResult<Response>> handler)

      Get the value of a key and delete the key.

      Redis command GETDEL.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### getdel

          public RedisAPI getdel(String arg0)

      Get the value of a key and delete the key.

      Redis command GETDEL.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxGetdel

          public Single<Response> rxGetdel(String arg0)

      Get the value of a key and delete the key.

      Redis command GETDEL.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### getex

          public RedisAPI getex(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Get the value of a key and optionally set its expiration.

      Redis command GETEX.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### getex

          public RedisAPI getex(List<String> args)

      Get the value of a key and optionally set its expiration.

      Redis command GETEX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGetex

          public Single<Response> rxGetex(List<String> args)

      Get the value of a key and optionally set its expiration.

      Redis command GETEX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### getrange

          public RedisAPI getrange(String arg0,
                                   String arg1,
                                   String arg2,
                                   Handler<AsyncResult<Response>> handler)

      Get a substring of the string stored at a key.

      Redis command GETRANGE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### getrange

          public RedisAPI getrange(String arg0,
                                   String arg1,
                                   String arg2)

      Get a substring of the string stored at a key.

      Redis command GETRANGE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxGetrange

          public Single<Response> rxGetrange(String arg0,
                                             String arg1,
                                             String arg2)

      Get a substring of the string stored at a key.

      Redis command GETRANGE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### getset

          public RedisAPI getset(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Set the string value of a key and return its old value.

      Redis command GETSET.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### getset

          public RedisAPI getset(String arg0,
                                 String arg1)

      Set the string value of a key and return its old value.

      Redis command GETSET.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxGetset

          public Single<Response> rxGetset(String arg0,
                                           String arg1)

      Set the string value of a key and return its old value.

      Redis command GETSET.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### graphBulk

          public RedisAPI graphBulk(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command GRAPH.BULK.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### graphBulk

          public RedisAPI graphBulk(List<String> args)

      Redis command GRAPH.BULK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGraphBulk

          public Single<Response> rxGraphBulk(List<String> args)

      Redis command GRAPH.BULK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### graphConfig

          public RedisAPI graphConfig(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command GRAPH.CONFIG.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### graphConfig

          public RedisAPI graphConfig(List<String> args)

      Redis command GRAPH.CONFIG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGraphConfig

          public Single<Response> rxGraphConfig(List<String> args)

      Redis command GRAPH.CONFIG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### graphDebug

          public RedisAPI graphDebug(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command GRAPH.DEBUG.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### graphDebug

          public RedisAPI graphDebug(List<String> args)

      Redis command GRAPH.DEBUG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGraphDebug

          public Single<Response> rxGraphDebug(List<String> args)

      Redis command GRAPH.DEBUG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### graphDelete

          public RedisAPI graphDelete(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command GRAPH.DELETE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### graphDelete

          public RedisAPI graphDelete(List<String> args)

      Redis command GRAPH.DELETE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGraphDelete

          public Single<Response> rxGraphDelete(List<String> args)

      Redis command GRAPH.DELETE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### graphExplain

          public RedisAPI graphExplain(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command GRAPH.EXPLAIN.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### graphExplain

          public RedisAPI graphExplain(List<String> args)

      Redis command GRAPH.EXPLAIN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGraphExplain

          public Single<Response> rxGraphExplain(List<String> args)

      Redis command GRAPH.EXPLAIN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### graphList

          public RedisAPI graphList(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command GRAPH.LIST.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### graphList

          public RedisAPI graphList(List<String> args)

      Redis command GRAPH.LIST.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGraphList

          public Single<Response> rxGraphList(List<String> args)

      Redis command GRAPH.LIST.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### graphProfile

          public RedisAPI graphProfile(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command GRAPH.PROFILE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### graphProfile

          public RedisAPI graphProfile(List<String> args)

      Redis command GRAPH.PROFILE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGraphProfile

          public Single<Response> rxGraphProfile(List<String> args)

      Redis command GRAPH.PROFILE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### graphQuery

          public RedisAPI graphQuery(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command GRAPH.QUERY.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### graphQuery

          public RedisAPI graphQuery(List<String> args)

      Redis command GRAPH.QUERY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGraphQuery

          public Single<Response> rxGraphQuery(List<String> args)

      Redis command GRAPH.QUERY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### graphRoQuery

          public RedisAPI graphRoQuery(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command GRAPH.RO_QUERY.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### graphRoQuery

          public RedisAPI graphRoQuery(List<String> args)

      Redis command GRAPH.RO_QUERY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGraphRoQuery

          public Single<Response> rxGraphRoQuery(List<String> args)

      Redis command GRAPH.RO_QUERY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### graphSlowlog

          public RedisAPI graphSlowlog(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command GRAPH.SLOWLOG.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### graphSlowlog

          public RedisAPI graphSlowlog(List<String> args)

      Redis command GRAPH.SLOWLOG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGraphSlowlog

          public Single<Response> rxGraphSlowlog(List<String> args)

      Redis command GRAPH.SLOWLOG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hdel

          public RedisAPI hdel(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Delete one or more hash fields.

      Redis command HDEL.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hdel

          public RedisAPI hdel(List<String> args)

      Delete one or more hash fields.

      Redis command HDEL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHdel

          public Single<Response> rxHdel(List<String> args)

      Delete one or more hash fields.

      Redis command HDEL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hello

          public RedisAPI hello(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Handshake with Redis.

      Redis command HELLO.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hello

          public RedisAPI hello(List<String> args)

      Handshake with Redis.

      Redis command HELLO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHello

          public Single<Response> rxHello(List<String> args)

      Handshake with Redis.

      Redis command HELLO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hexists

          public RedisAPI hexists(String arg0,
                                  String arg1,
                                  Handler<AsyncResult<Response>> handler)

      Determine if a hash field exists.

      Redis command HEXISTS.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### hexists

          public RedisAPI hexists(String arg0,
                                  String arg1)

      Determine if a hash field exists.

      Redis command HEXISTS.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxHexists

          public Single<Response> rxHexists(String arg0,
                                            String arg1)

      Determine if a hash field exists.

      Redis command HEXISTS.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### hget

          public RedisAPI hget(String arg0,
                               String arg1,
                               Handler<AsyncResult<Response>> handler)

      Get the value of a hash field.

      Redis command HGET.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### hget

          public RedisAPI hget(String arg0,
                               String arg1)

      Get the value of a hash field.

      Redis command HGET.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxHget

          public Single<Response> rxHget(String arg0,
                                         String arg1)

      Get the value of a hash field.

      Redis command HGET.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### hgetall

          public RedisAPI hgetall(String arg0,
                                  Handler<AsyncResult<Response>> handler)

      Get all the fields and values in a hash.

      Redis command HGETALL.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hgetall

          public RedisAPI hgetall(String arg0)

      Get all the fields and values in a hash.

      Redis command HGETALL.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHgetall

          public Single<Response> rxHgetall(String arg0)

      Get all the fields and values in a hash.

      Redis command HGETALL.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### hincrby

          public RedisAPI hincrby(String arg0,
                                  String arg1,
                                  String arg2,
                                  Handler<AsyncResult<Response>> handler)

      Increment the integer value of a hash field by the given number.

      Redis command HINCRBY.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### hincrby

          public RedisAPI hincrby(String arg0,
                                  String arg1,
                                  String arg2)

      Increment the integer value of a hash field by the given number.

      Redis command HINCRBY.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxHincrby

          public Single<Response> rxHincrby(String arg0,
                                            String arg1,
                                            String arg2)

      Increment the integer value of a hash field by the given number.

      Redis command HINCRBY.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### hincrbyfloat

          public RedisAPI hincrbyfloat(String arg0,
                                       String arg1,
                                       String arg2,
                                       Handler<AsyncResult<Response>> handler)

      Increment the float value of a hash field by the given amount.

      Redis command HINCRBYFLOAT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### hincrbyfloat

          public RedisAPI hincrbyfloat(String arg0,
                                       String arg1,
                                       String arg2)

      Increment the float value of a hash field by the given amount.

      Redis command HINCRBYFLOAT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxHincrbyfloat

          public Single<Response> rxHincrbyfloat(String arg0,
                                                 String arg1,
                                                 String arg2)

      Increment the float value of a hash field by the given amount.

      Redis command HINCRBYFLOAT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### hkeys

          public RedisAPI hkeys(String arg0,
                                Handler<AsyncResult<Response>> handler)

      Get all the fields in a hash.

      Redis command HKEYS.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hkeys

          public RedisAPI hkeys(String arg0)

      Get all the fields in a hash.

      Redis command HKEYS.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHkeys

          public Single<Response> rxHkeys(String arg0)

      Get all the fields in a hash.

      Redis command HKEYS.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### hlen

          public RedisAPI hlen(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Get the number of fields in a hash.

      Redis command HLEN.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hlen

          public RedisAPI hlen(String arg0)

      Get the number of fields in a hash.

      Redis command HLEN.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHlen

          public Single<Response> rxHlen(String arg0)

      Get the number of fields in a hash.

      Redis command HLEN.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### hmget

          public RedisAPI hmget(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Get the values of all the given hash fields.

      Redis command HMGET.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hmget

          public RedisAPI hmget(List<String> args)

      Get the values of all the given hash fields.

      Redis command HMGET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHmget

          public Single<Response> rxHmget(List<String> args)

      Get the values of all the given hash fields.

      Redis command HMGET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hmset

          public RedisAPI hmset(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Set multiple hash fields to multiple values.

      Redis command HMSET.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hmset

          public RedisAPI hmset(List<String> args)

      Set multiple hash fields to multiple values.

      Redis command HMSET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHmset

          public Single<Response> rxHmset(List<String> args)

      Set multiple hash fields to multiple values.

      Redis command HMSET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hrandfield

          public RedisAPI hrandfield(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Get one or multiple random fields from a hash.

      Redis command HRANDFIELD.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hrandfield

          public RedisAPI hrandfield(List<String> args)

      Get one or multiple random fields from a hash.

      Redis command HRANDFIELD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHrandfield

          public Single<Response> rxHrandfield(List<String> args)

      Get one or multiple random fields from a hash.

      Redis command HRANDFIELD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hscan

          public RedisAPI hscan(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Incrementally iterate hash fields and associated values.

      Redis command HSCAN.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hscan

          public RedisAPI hscan(List<String> args)

      Incrementally iterate hash fields and associated values.

      Redis command HSCAN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHscan

          public Single<Response> rxHscan(List<String> args)

      Incrementally iterate hash fields and associated values.

      Redis command HSCAN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hset

          public RedisAPI hset(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Set the string value of a hash field.

      Redis command HSET.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hset

          public RedisAPI hset(List<String> args)

      Set the string value of a hash field.

      Redis command HSET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHset

          public Single<Response> rxHset(List<String> args)

      Set the string value of a hash field.

      Redis command HSET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hsetnx

          public RedisAPI hsetnx(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

      Set the value of a hash field, only if the field does not exist.

      Redis command HSETNX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### hsetnx

          public RedisAPI hsetnx(String arg0,
                                 String arg1,
                                 String arg2)

      Set the value of a hash field, only if the field does not exist.

      Redis command HSETNX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxHsetnx

          public Single<Response> rxHsetnx(String arg0,
                                           String arg1,
                                           String arg2)

      Set the value of a hash field, only if the field does not exist.

      Redis command HSETNX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### hstrlen

          public RedisAPI hstrlen(String arg0,
                                  String arg1,
                                  Handler<AsyncResult<Response>> handler)

      Get the length of the value of a hash field.

      Redis command HSTRLEN.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### hstrlen

          public RedisAPI hstrlen(String arg0,
                                  String arg1)

      Get the length of the value of a hash field.

      Redis command HSTRLEN.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxHstrlen

          public Single<Response> rxHstrlen(String arg0,
                                            String arg1)

      Get the length of the value of a hash field.

      Redis command HSTRLEN.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### hvals

          public RedisAPI hvals(String arg0,
                                Handler<AsyncResult<Response>> handler)

      Get all the values in a hash.

      Redis command HVALS.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hvals

          public RedisAPI hvals(String arg0)

      Get all the values in a hash.

      Redis command HVALS.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHvals

          public Single<Response> rxHvals(String arg0)

      Get all the values in a hash.

      Redis command HVALS.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### incr

          public RedisAPI incr(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Increment the integer value of a key by one.

      Redis command INCR.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### incr

          public RedisAPI incr(String arg0)

      Increment the integer value of a key by one.

      Redis command INCR.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxIncr

          public Single<Response> rxIncr(String arg0)

      Increment the integer value of a key by one.

      Redis command INCR.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### incrby

          public RedisAPI incrby(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Increment the integer value of a key by the given amount.

      Redis command INCRBY.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### incrby

          public RedisAPI incrby(String arg0,
                                 String arg1)

      Increment the integer value of a key by the given amount.

      Redis command INCRBY.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxIncrby

          public Single<Response> rxIncrby(String arg0,
                                           String arg1)

      Increment the integer value of a key by the given amount.

      Redis command INCRBY.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### incrbyfloat

          public RedisAPI incrbyfloat(String arg0,
                                      String arg1,
                                      Handler<AsyncResult<Response>> handler)

      Increment the float value of a key by the given amount.

      Redis command INCRBYFLOAT.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### incrbyfloat

          public RedisAPI incrbyfloat(String arg0,
                                      String arg1)

      Increment the float value of a key by the given amount.

      Redis command INCRBYFLOAT.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxIncrbyfloat

          public Single<Response> rxIncrbyfloat(String arg0,
                                                String arg1)

      Increment the float value of a key by the given amount.

      Redis command INCRBYFLOAT.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### info

          public RedisAPI info(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Get information and statistics about the server.

      Redis command INFO.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### info

          public RedisAPI info(List<String> args)

      Get information and statistics about the server.

      Redis command INFO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxInfo

          public Single<Response> rxInfo(List<String> args)

      Get information and statistics about the server.

      Redis command INFO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonArrappend

          public RedisAPI jsonArrappend(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command JSON.ARRAPPEND.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonArrappend

          public RedisAPI jsonArrappend(List<String> args)

      Redis command JSON.ARRAPPEND.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonArrappend

          public Single<Response> rxJsonArrappend(List<String> args)

      Redis command JSON.ARRAPPEND.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonArrindex

          public RedisAPI jsonArrindex(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command JSON.ARRINDEX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonArrindex

          public RedisAPI jsonArrindex(List<String> args)

      Redis command JSON.ARRINDEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonArrindex

          public Single<Response> rxJsonArrindex(List<String> args)

      Redis command JSON.ARRINDEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonArrinsert

          public RedisAPI jsonArrinsert(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command JSON.ARRINSERT.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonArrinsert

          public RedisAPI jsonArrinsert(List<String> args)

      Redis command JSON.ARRINSERT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonArrinsert

          public Single<Response> rxJsonArrinsert(List<String> args)

      Redis command JSON.ARRINSERT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonArrlen

          public RedisAPI jsonArrlen(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command JSON.ARRLEN.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonArrlen

          public RedisAPI jsonArrlen(List<String> args)

      Redis command JSON.ARRLEN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonArrlen

          public Single<Response> rxJsonArrlen(List<String> args)

      Redis command JSON.ARRLEN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonArrpop

          public RedisAPI jsonArrpop(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command JSON.ARRPOP.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonArrpop

          public RedisAPI jsonArrpop(List<String> args)

      Redis command JSON.ARRPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonArrpop

          public Single<Response> rxJsonArrpop(List<String> args)

      Redis command JSON.ARRPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonArrtrim

          public RedisAPI jsonArrtrim(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command JSON.ARRTRIM.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonArrtrim

          public RedisAPI jsonArrtrim(List<String> args)

      Redis command JSON.ARRTRIM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonArrtrim

          public Single<Response> rxJsonArrtrim(List<String> args)

      Redis command JSON.ARRTRIM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonClear

          public RedisAPI jsonClear(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command JSON.CLEAR.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonClear

          public RedisAPI jsonClear(List<String> args)

      Redis command JSON.CLEAR.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonClear

          public Single<Response> rxJsonClear(List<String> args)

      Redis command JSON.CLEAR.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonDebug

          public RedisAPI jsonDebug(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command JSON.DEBUG.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonDebug

          public RedisAPI jsonDebug(List<String> args)

      Redis command JSON.DEBUG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonDebug

          public Single<Response> rxJsonDebug(List<String> args)

      Redis command JSON.DEBUG.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonDel

          public RedisAPI jsonDel(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command JSON.DEL.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonDel

          public RedisAPI jsonDel(List<String> args)

      Redis command JSON.DEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonDel

          public Single<Response> rxJsonDel(List<String> args)

      Redis command JSON.DEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonForget

          public RedisAPI jsonForget(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command JSON.FORGET.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonForget

          public RedisAPI jsonForget(List<String> args)

      Redis command JSON.FORGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonForget

          public Single<Response> rxJsonForget(List<String> args)

      Redis command JSON.FORGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonGet

          public RedisAPI jsonGet(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command JSON.GET.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonGet

          public RedisAPI jsonGet(List<String> args)

      Redis command JSON.GET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonGet

          public Single<Response> rxJsonGet(List<String> args)

      Redis command JSON.GET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonMget

          public RedisAPI jsonMget(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command JSON.MGET.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonMget

          public RedisAPI jsonMget(List<String> args)

      Redis command JSON.MGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonMget

          public Single<Response> rxJsonMget(List<String> args)

      Redis command JSON.MGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonNumincrby

          public RedisAPI jsonNumincrby(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command JSON.NUMINCRBY.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonNumincrby

          public RedisAPI jsonNumincrby(List<String> args)

      Redis command JSON.NUMINCRBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonNumincrby

          public Single<Response> rxJsonNumincrby(List<String> args)

      Redis command JSON.NUMINCRBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonNummultby

          public RedisAPI jsonNummultby(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command JSON.NUMMULTBY.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonNummultby

          public RedisAPI jsonNummultby(List<String> args)

      Redis command JSON.NUMMULTBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonNummultby

          public Single<Response> rxJsonNummultby(List<String> args)

      Redis command JSON.NUMMULTBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonNumpowby

          public RedisAPI jsonNumpowby(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command JSON.NUMPOWBY.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonNumpowby

          public RedisAPI jsonNumpowby(List<String> args)

      Redis command JSON.NUMPOWBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonNumpowby

          public Single<Response> rxJsonNumpowby(List<String> args)

      Redis command JSON.NUMPOWBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonObjkeys

          public RedisAPI jsonObjkeys(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command JSON.OBJKEYS.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonObjkeys

          public RedisAPI jsonObjkeys(List<String> args)

      Redis command JSON.OBJKEYS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonObjkeys

          public Single<Response> rxJsonObjkeys(List<String> args)

      Redis command JSON.OBJKEYS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonObjlen

          public RedisAPI jsonObjlen(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command JSON.OBJLEN.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonObjlen

          public RedisAPI jsonObjlen(List<String> args)

      Redis command JSON.OBJLEN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonObjlen

          public Single<Response> rxJsonObjlen(List<String> args)

      Redis command JSON.OBJLEN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonResp

          public RedisAPI jsonResp(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command JSON.RESP.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonResp

          public RedisAPI jsonResp(List<String> args)

      Redis command JSON.RESP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonResp

          public Single<Response> rxJsonResp(List<String> args)

      Redis command JSON.RESP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonSet

          public RedisAPI jsonSet(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command JSON.SET.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonSet

          public RedisAPI jsonSet(List<String> args)

      Redis command JSON.SET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonSet

          public Single<Response> rxJsonSet(List<String> args)

      Redis command JSON.SET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonStrappend

          public RedisAPI jsonStrappend(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command JSON.STRAPPEND.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonStrappend

          public RedisAPI jsonStrappend(List<String> args)

      Redis command JSON.STRAPPEND.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonStrappend

          public Single<Response> rxJsonStrappend(List<String> args)

      Redis command JSON.STRAPPEND.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonStrlen

          public RedisAPI jsonStrlen(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command JSON.STRLEN.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonStrlen

          public RedisAPI jsonStrlen(List<String> args)

      Redis command JSON.STRLEN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonStrlen

          public Single<Response> rxJsonStrlen(List<String> args)

      Redis command JSON.STRLEN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonToggle

          public RedisAPI jsonToggle(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command JSON.TOGGLE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonToggle

          public RedisAPI jsonToggle(List<String> args)

      Redis command JSON.TOGGLE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonToggle

          public Single<Response> rxJsonToggle(List<String> args)

      Redis command JSON.TOGGLE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### jsonType

          public RedisAPI jsonType(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command JSON.TYPE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### jsonType

          public RedisAPI jsonType(List<String> args)

      Redis command JSON.TYPE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxJsonType

          public Single<Response> rxJsonType(List<String> args)

      Redis command JSON.TYPE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### keys

          public RedisAPI keys(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Find all keys matching the given pattern.

      Redis command KEYS.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### keys

          public RedisAPI keys(String arg0)

      Find all keys matching the given pattern.

      Redis command KEYS.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxKeys

          public Single<Response> rxKeys(String arg0)

      Find all keys matching the given pattern.

      Redis command KEYS.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### lastsave

          public RedisAPI lastsave(Handler<AsyncResult<Response>> handler)

      Get the UNIX time stamp of the last successful save to disk.

      Redis command LASTSAVE.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### lastsave

          public RedisAPI lastsave()

      Get the UNIX time stamp of the last successful save to disk.

      Redis command LASTSAVE.

      Returns:
        fluent self

    - #### rxLastsave

          public Single<Response> rxLastsave()

      Get the UNIX time stamp of the last successful save to disk.

      Redis command LASTSAVE.

      Returns:
        fluent self

    - #### latency

          public RedisAPI latency(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      A container for latency diagnostics commands.

      Redis command LATENCY.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### latency

          public RedisAPI latency(List<String> args)

      A container for latency diagnostics commands.

      Redis command LATENCY.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLatency

          public Single<Response> rxLatency(List<String> args)

      A container for latency diagnostics commands.

      Redis command LATENCY.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lcs

          public RedisAPI lcs(List<String> args,
                              Handler<AsyncResult<Response>> handler)

      Find longest common substring.

      Redis command LCS.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### lcs

          public RedisAPI lcs(List<String> args)

      Find longest common substring.

      Redis command LCS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLcs

          public Single<Response> rxLcs(List<String> args)

      Find longest common substring.

      Redis command LCS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lindex

          public RedisAPI lindex(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Get an element from a list by its index.

      Redis command LINDEX.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### lindex

          public RedisAPI lindex(String arg0,
                                 String arg1)

      Get an element from a list by its index.

      Redis command LINDEX.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxLindex

          public Single<Response> rxLindex(String arg0,
                                           String arg1)

      Get an element from a list by its index.

      Redis command LINDEX.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### linsert

          public RedisAPI linsert(String arg0,
                                  String arg1,
                                  String arg2,
                                  String arg3,
                                  Handler<AsyncResult<Response>> handler)

      Insert an element before or after another element in a list.

      Redis command LINSERT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
        `handler` -
      Returns:
        fluent self

    - #### linsert

          public RedisAPI linsert(String arg0,
                                  String arg1,
                                  String arg2,
                                  String arg3)

      Insert an element before or after another element in a list.

      Redis command LINSERT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
      Returns:
        fluent self

    - #### rxLinsert

          public Single<Response> rxLinsert(String arg0,
                                            String arg1,
                                            String arg2,
                                            String arg3)

      Insert an element before or after another element in a list.

      Redis command LINSERT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
      Returns:
        fluent self

    - #### llen

          public RedisAPI llen(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Get the length of a list.

      Redis command LLEN.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### llen

          public RedisAPI llen(String arg0)

      Get the length of a list.

      Redis command LLEN.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxLlen

          public Single<Response> rxLlen(String arg0)

      Get the length of a list.

      Redis command LLEN.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### lmove

          public RedisAPI lmove(String arg0,
                                String arg1,
                                String arg2,
                                String arg3,
                                Handler<AsyncResult<Response>> handler)

      Pop an element from a list, push it to another list and return it.

      Redis command LMOVE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
        `handler` -
      Returns:
        fluent self

    - #### lmove

          public RedisAPI lmove(String arg0,
                                String arg1,
                                String arg2,
                                String arg3)

      Pop an element from a list, push it to another list and return it.

      Redis command LMOVE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
      Returns:
        fluent self

    - #### rxLmove

          public Single<Response> rxLmove(String arg0,
                                          String arg1,
                                          String arg2,
                                          String arg3)

      Pop an element from a list, push it to another list and return it.

      Redis command LMOVE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
      Returns:
        fluent self

    - #### lmpop

          public RedisAPI lmpop(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Pop elements from a list.

      Redis command LMPOP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### lmpop

          public RedisAPI lmpop(List<String> args)

      Pop elements from a list.

      Redis command LMPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLmpop

          public Single<Response> rxLmpop(List<String> args)

      Pop elements from a list.

      Redis command LMPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lolwut

          public RedisAPI lolwut(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Display some computer art and the Redis version.

      Redis command LOLWUT.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### lolwut

          public RedisAPI lolwut(List<String> args)

      Display some computer art and the Redis version.

      Redis command LOLWUT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLolwut

          public Single<Response> rxLolwut(List<String> args)

      Display some computer art and the Redis version.

      Redis command LOLWUT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lpop

          public RedisAPI lpop(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Remove and get the first elements in a list.

      Redis command LPOP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### lpop

          public RedisAPI lpop(List<String> args)

      Remove and get the first elements in a list.

      Redis command LPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLpop

          public Single<Response> rxLpop(List<String> args)

      Remove and get the first elements in a list.

      Redis command LPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lpos

          public RedisAPI lpos(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Return the index of matching elements on a list.

      Redis command LPOS.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### lpos

          public RedisAPI lpos(List<String> args)

      Return the index of matching elements on a list.

      Redis command LPOS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLpos

          public Single<Response> rxLpos(List<String> args)

      Return the index of matching elements on a list.

      Redis command LPOS.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lpush

          public RedisAPI lpush(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Prepend one or multiple elements to a list.

      Redis command LPUSH.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### lpush

          public RedisAPI lpush(List<String> args)

      Prepend one or multiple elements to a list.

      Redis command LPUSH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLpush

          public Single<Response> rxLpush(List<String> args)

      Prepend one or multiple elements to a list.

      Redis command LPUSH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lpushx

          public RedisAPI lpushx(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Prepend an element to a list, only if the list exists.

      Redis command LPUSHX.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### lpushx

          public RedisAPI lpushx(List<String> args)

      Prepend an element to a list, only if the list exists.

      Redis command LPUSHX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLpushx

          public Single<Response> rxLpushx(List<String> args)

      Prepend an element to a list, only if the list exists.

      Redis command LPUSHX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lrange

          public RedisAPI lrange(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

      Get a range of elements from a list.

      Redis command LRANGE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### lrange

          public RedisAPI lrange(String arg0,
                                 String arg1,
                                 String arg2)

      Get a range of elements from a list.

      Redis command LRANGE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLrange

          public Single<Response> rxLrange(String arg0,
                                           String arg1,
                                           String arg2)

      Get a range of elements from a list.

      Redis command LRANGE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### lrem

          public RedisAPI lrem(String arg0,
                               String arg1,
                               String arg2,
                               Handler<AsyncResult<Response>> handler)

      Remove elements from a list.

      Redis command LREM.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### lrem

          public RedisAPI lrem(String arg0,
                               String arg1,
                               String arg2)

      Remove elements from a list.

      Redis command LREM.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLrem

          public Single<Response> rxLrem(String arg0,
                                         String arg1,
                                         String arg2)

      Remove elements from a list.

      Redis command LREM.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### lset

          public RedisAPI lset(String arg0,
                               String arg1,
                               String arg2,
                               Handler<AsyncResult<Response>> handler)

      Set the value of an element in a list by its index.

      Redis command LSET.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### lset

          public RedisAPI lset(String arg0,
                               String arg1,
                               String arg2)

      Set the value of an element in a list by its index.

      Redis command LSET.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLset

          public Single<Response> rxLset(String arg0,
                                         String arg1,
                                         String arg2)

      Set the value of an element in a list by its index.

      Redis command LSET.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### ltrim

          public RedisAPI ltrim(String arg0,
                                String arg1,
                                String arg2,
                                Handler<AsyncResult<Response>> handler)

      Trim a list to the specified range.

      Redis command LTRIM.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### ltrim

          public RedisAPI ltrim(String arg0,
                                String arg1,
                                String arg2)

      Trim a list to the specified range.

      Redis command LTRIM.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLtrim

          public Single<Response> rxLtrim(String arg0,
                                          String arg1,
                                          String arg2)

      Trim a list to the specified range.

      Redis command LTRIM.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### memory

          public RedisAPI memory(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      A container for memory diagnostics commands.

      Redis command MEMORY.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### memory

          public RedisAPI memory(List<String> args)

      A container for memory diagnostics commands.

      Redis command MEMORY.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMemory

          public Single<Response> rxMemory(List<String> args)

      A container for memory diagnostics commands.

      Redis command MEMORY.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### mget

          public RedisAPI mget(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Get the values of all the given keys.

      Redis command MGET.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### mget

          public RedisAPI mget(List<String> args)

      Get the values of all the given keys.

      Redis command MGET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMget

          public Single<Response> rxMget(List<String> args)

      Get the values of all the given keys.

      Redis command MGET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### migrate

          public RedisAPI migrate(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Atomically transfer a key from a Redis instance to another one.

      Redis command MIGRATE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### migrate

          public RedisAPI migrate(List<String> args)

      Atomically transfer a key from a Redis instance to another one.

      Redis command MIGRATE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMigrate

          public Single<Response> rxMigrate(List<String> args)

      Atomically transfer a key from a Redis instance to another one.

      Redis command MIGRATE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### module

          public RedisAPI module(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      A container for module commands.

      Redis command MODULE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### module

          public RedisAPI module(List<String> args)

      A container for module commands.

      Redis command MODULE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxModule

          public Single<Response> rxModule(List<String> args)

      A container for module commands.

      Redis command MODULE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### monitor

          public RedisAPI monitor(Handler<AsyncResult<Response>> handler)

      Listen for all requests received by the server in real time.

      Redis command MONITOR.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### monitor

          public RedisAPI monitor()

      Listen for all requests received by the server in real time.

      Redis command MONITOR.

      Returns:
        fluent self

    - #### rxMonitor

          public Single<Response> rxMonitor()

      Listen for all requests received by the server in real time.

      Redis command MONITOR.

      Returns:
        fluent self

    - #### move

          public RedisAPI move(String arg0,
                               String arg1,
                               Handler<AsyncResult<Response>> handler)

      Move a key to another database.

      Redis command MOVE.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### move

          public RedisAPI move(String arg0,
                               String arg1)

      Move a key to another database.

      Redis command MOVE.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxMove

          public Single<Response> rxMove(String arg0,
                                         String arg1)

      Move a key to another database.

      Redis command MOVE.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### mset

          public RedisAPI mset(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Set multiple keys to multiple values.

      Redis command MSET.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### mset

          public RedisAPI mset(List<String> args)

      Set multiple keys to multiple values.

      Redis command MSET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMset

          public Single<Response> rxMset(List<String> args)

      Set multiple keys to multiple values.

      Redis command MSET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### msetnx

          public RedisAPI msetnx(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Set multiple keys to multiple values, only if none of the keys exist.

      Redis command MSETNX.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### msetnx

          public RedisAPI msetnx(List<String> args)

      Set multiple keys to multiple values, only if none of the keys exist.

      Redis command MSETNX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMsetnx

          public Single<Response> rxMsetnx(List<String> args)

      Set multiple keys to multiple values, only if none of the keys exist.

      Redis command MSETNX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### multi

          public RedisAPI multi(Handler<AsyncResult<Response>> handler)

      Mark the start of a transaction block.

      Redis command MULTI.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### multi

          public RedisAPI multi()

      Mark the start of a transaction block.

      Redis command MULTI.

      Returns:
        fluent self

    - #### rxMulti

          public Single<Response> rxMulti()

      Mark the start of a transaction block.

      Redis command MULTI.

      Returns:
        fluent self

    - #### object

          public RedisAPI object(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      A container for object introspection commands.

      Redis command OBJECT.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### object

          public RedisAPI object(List<String> args)

      A container for object introspection commands.

      Redis command OBJECT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxObject

          public Single<Response> rxObject(List<String> args)

      A container for object introspection commands.

      Redis command OBJECT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### persist

          public RedisAPI persist(String arg0,
                                  Handler<AsyncResult<Response>> handler)

      Remove the expiration from a key.

      Redis command PERSIST.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### persist

          public RedisAPI persist(String arg0)

      Remove the expiration from a key.

      Redis command PERSIST.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxPersist

          public Single<Response> rxPersist(String arg0)

      Remove the expiration from a key.

      Redis command PERSIST.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### pexpire

          public RedisAPI pexpire(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Set a key's time to live in milliseconds.

      Redis command PEXPIRE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pexpire

          public RedisAPI pexpire(List<String> args)

      Set a key's time to live in milliseconds.

      Redis command PEXPIRE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPexpire

          public Single<Response> rxPexpire(List<String> args)

      Set a key's time to live in milliseconds.

      Redis command PEXPIRE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pexpireat

          public RedisAPI pexpireat(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Set the expiration for a key as a UNIX timestamp specified in milliseconds.

      Redis command PEXPIREAT.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pexpireat

          public RedisAPI pexpireat(List<String> args)

      Set the expiration for a key as a UNIX timestamp specified in milliseconds.

      Redis command PEXPIREAT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPexpireat

          public Single<Response> rxPexpireat(List<String> args)

      Set the expiration for a key as a UNIX timestamp specified in milliseconds.

      Redis command PEXPIREAT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pexpiretime

          public RedisAPI pexpiretime(String arg0,
                                      Handler<AsyncResult<Response>> handler)

      Get the expiration Unix timestamp for a key in milliseconds.

      Redis command PEXPIRETIME.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### pexpiretime

          public RedisAPI pexpiretime(String arg0)

      Get the expiration Unix timestamp for a key in milliseconds.

      Redis command PEXPIRETIME.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxPexpiretime

          public Single<Response> rxPexpiretime(String arg0)

      Get the expiration Unix timestamp for a key in milliseconds.

      Redis command PEXPIRETIME.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### pfadd

          public RedisAPI pfadd(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Adds the specified elements to the specified HyperLogLog.

      Redis command PFADD.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pfadd

          public RedisAPI pfadd(List<String> args)

      Adds the specified elements to the specified HyperLogLog.

      Redis command PFADD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPfadd

          public Single<Response> rxPfadd(List<String> args)

      Adds the specified elements to the specified HyperLogLog.

      Redis command PFADD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pfcount

          public RedisAPI pfcount(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

      Redis command PFCOUNT.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pfcount

          public RedisAPI pfcount(List<String> args)

      Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

      Redis command PFCOUNT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPfcount

          public Single<Response> rxPfcount(List<String> args)

      Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

      Redis command PFCOUNT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pfdebug

          public RedisAPI pfdebug(String arg0,
                                  String arg1,
                                  Handler<AsyncResult<Response>> handler)

      Internal commands for debugging HyperLogLog values.

      Redis command PFDEBUG.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### pfdebug

          public RedisAPI pfdebug(String arg0,
                                  String arg1)

      Internal commands for debugging HyperLogLog values.

      Redis command PFDEBUG.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxPfdebug

          public Single<Response> rxPfdebug(String arg0,
                                            String arg1)

      Internal commands for debugging HyperLogLog values.

      Redis command PFDEBUG.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### pfmerge

          public RedisAPI pfmerge(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Merge N different HyperLogLogs into a single one.

      Redis command PFMERGE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pfmerge

          public RedisAPI pfmerge(List<String> args)

      Merge N different HyperLogLogs into a single one.

      Redis command PFMERGE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPfmerge

          public Single<Response> rxPfmerge(List<String> args)

      Merge N different HyperLogLogs into a single one.

      Redis command PFMERGE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pfselftest

          public RedisAPI pfselftest(Handler<AsyncResult<Response>> handler)

      An internal command for testing HyperLogLog values.

      Redis command PFSELFTEST.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### pfselftest

          public RedisAPI pfselftest()

      An internal command for testing HyperLogLog values.

      Redis command PFSELFTEST.

      Returns:
        fluent self

    - #### rxPfselftest

          public Single<Response> rxPfselftest()

      An internal command for testing HyperLogLog values.

      Redis command PFSELFTEST.

      Returns:
        fluent self

    - #### ping

          public RedisAPI ping(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Ping the server.

      Redis command PING.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ping

          public RedisAPI ping(List<String> args)

      Ping the server.

      Redis command PING.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPing

          public Single<Response> rxPing(List<String> args)

      Ping the server.

      Redis command PING.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### psetex

          public RedisAPI psetex(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

      Set the value and expiration in milliseconds of a key.

      Redis command PSETEX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### psetex

          public RedisAPI psetex(String arg0,
                                 String arg1,
                                 String arg2)

      Set the value and expiration in milliseconds of a key.

      Redis command PSETEX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxPsetex

          public Single<Response> rxPsetex(String arg0,
                                           String arg1,
                                           String arg2)

      Set the value and expiration in milliseconds of a key.

      Redis command PSETEX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### psubscribe

          public RedisAPI psubscribe(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Listen for messages published to channels matching the given patterns.

      Redis command PSUBSCRIBE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### psubscribe

          public RedisAPI psubscribe(List<String> args)

      Listen for messages published to channels matching the given patterns.

      Redis command PSUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPsubscribe

          public Single<Response> rxPsubscribe(List<String> args)

      Listen for messages published to channels matching the given patterns.

      Redis command PSUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### psync

          public RedisAPI psync(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Internal command used for replication.

      Redis command PSYNC.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### psync

          public RedisAPI psync(List<String> args)

      Internal command used for replication.

      Redis command PSYNC.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPsync

          public Single<Response> rxPsync(List<String> args)

      Internal command used for replication.

      Redis command PSYNC.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pttl

          public RedisAPI pttl(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Get the time to live for a key in milliseconds.

      Redis command PTTL.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### pttl

          public RedisAPI pttl(String arg0)

      Get the time to live for a key in milliseconds.

      Redis command PTTL.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxPttl

          public Single<Response> rxPttl(String arg0)

      Get the time to live for a key in milliseconds.

      Redis command PTTL.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### publish

          public RedisAPI publish(String arg0,
                                  String arg1,
                                  Handler<AsyncResult<Response>> handler)

      Post a message to a channel.

      Redis command PUBLISH.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### publish

          public RedisAPI publish(String arg0,
                                  String arg1)

      Post a message to a channel.

      Redis command PUBLISH.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxPublish

          public Single<Response> rxPublish(String arg0,
                                            String arg1)

      Post a message to a channel.

      Redis command PUBLISH.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### pubsub

          public RedisAPI pubsub(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      A container for Pub/Sub commands.

      Redis command PUBSUB.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pubsub

          public RedisAPI pubsub(List<String> args)

      A container for Pub/Sub commands.

      Redis command PUBSUB.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPubsub

          public Single<Response> rxPubsub(List<String> args)

      A container for Pub/Sub commands.

      Redis command PUBSUB.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### punsubscribe

          public RedisAPI punsubscribe(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Stop listening for messages posted to channels matching the given patterns.

      Redis command PUNSUBSCRIBE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### punsubscribe

          public RedisAPI punsubscribe(List<String> args)

      Stop listening for messages posted to channels matching the given patterns.

      Redis command PUNSUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPunsubscribe

          public Single<Response> rxPunsubscribe(List<String> args)

      Stop listening for messages posted to channels matching the given patterns.

      Redis command PUNSUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### quit

          public RedisAPI quit(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Close the connection.

      Redis command QUIT.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### quit

          public RedisAPI quit(List<String> args)

      Close the connection.

      Redis command QUIT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxQuit

          public Single<Response> rxQuit(List<String> args)

      Close the connection.

      Redis command QUIT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### randomkey

          public RedisAPI randomkey(Handler<AsyncResult<Response>> handler)

      Return a random key from the keyspace.

      Redis command RANDOMKEY.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### randomkey

          public RedisAPI randomkey()

      Return a random key from the keyspace.

      Redis command RANDOMKEY.

      Returns:
        fluent self

    - #### rxRandomkey

          public Single<Response> rxRandomkey()

      Return a random key from the keyspace.

      Redis command RANDOMKEY.

      Returns:
        fluent self

    - #### readonly

          public RedisAPI readonly(Handler<AsyncResult<Response>> handler)

      Enables read queries for a connection to a cluster replica node.

      Redis command READONLY.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### readonly

          public RedisAPI readonly()

      Enables read queries for a connection to a cluster replica node.

      Redis command READONLY.

      Returns:
        fluent self

    - #### rxReadonly

          public Single<Response> rxReadonly()

      Enables read queries for a connection to a cluster replica node.

      Redis command READONLY.

      Returns:
        fluent self

    - #### readwrite

          public RedisAPI readwrite(Handler<AsyncResult<Response>> handler)

      Disables read queries for a connection to a cluster replica node.

      Redis command READWRITE.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### readwrite

          public RedisAPI readwrite()

      Disables read queries for a connection to a cluster replica node.

      Redis command READWRITE.

      Returns:
        fluent self

    - #### rxReadwrite

          public Single<Response> rxReadwrite()

      Disables read queries for a connection to a cluster replica node.

      Redis command READWRITE.

      Returns:
        fluent self

    - #### rename

          public RedisAPI rename(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Rename a key.

      Redis command RENAME.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### rename

          public RedisAPI rename(String arg0,
                                 String arg1)

      Rename a key.

      Redis command RENAME.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxRename

          public Single<Response> rxRename(String arg0,
                                           String arg1)

      Rename a key.

      Redis command RENAME.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### renamenx

          public RedisAPI renamenx(String arg0,
                                   String arg1,
                                   Handler<AsyncResult<Response>> handler)

      Rename a key, only if the new key does not exist.

      Redis command RENAMENX.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### renamenx

          public RedisAPI renamenx(String arg0,
                                   String arg1)

      Rename a key, only if the new key does not exist.

      Redis command RENAMENX.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxRenamenx

          public Single<Response> rxRenamenx(String arg0,
                                             String arg1)

      Rename a key, only if the new key does not exist.

      Redis command RENAMENX.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### replconf

          public RedisAPI replconf(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      An internal command for configuring the replication stream.

      Redis command REPLCONF.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### replconf

          public RedisAPI replconf(List<String> args)

      An internal command for configuring the replication stream.

      Redis command REPLCONF.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxReplconf

          public Single<Response> rxReplconf(List<String> args)

      An internal command for configuring the replication stream.

      Redis command REPLCONF.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### replicaof

          public RedisAPI replicaof(String arg0,
                                    String arg1,
                                    Handler<AsyncResult<Response>> handler)

      Make the server a replica of another instance, or promote it as master.

      Redis command REPLICAOF.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### replicaof

          public RedisAPI replicaof(String arg0,
                                    String arg1)

      Make the server a replica of another instance, or promote it as master.

      Redis command REPLICAOF.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxReplicaof

          public Single<Response> rxReplicaof(String arg0,
                                              String arg1)

      Make the server a replica of another instance, or promote it as master.

      Redis command REPLICAOF.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### reset

          public RedisAPI reset(Handler<AsyncResult<Response>> handler)

      Reset the connection.

      Redis command RESET.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### reset

          public RedisAPI reset()

      Reset the connection.

      Redis command RESET.

      Returns:
        fluent self

    - #### rxReset

          public Single<Response> rxReset()

      Reset the connection.

      Redis command RESET.

      Returns:
        fluent self

    - #### restore

          public RedisAPI restore(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Create a key using the provided serialized value, previously obtained using DUMP.

      Redis command RESTORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### restore

          public RedisAPI restore(List<String> args)

      Create a key using the provided serialized value, previously obtained using DUMP.

      Redis command RESTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRestore

          public Single<Response> rxRestore(List<String> args)

      Create a key using the provided serialized value, previously obtained using DUMP.

      Redis command RESTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### restoreAsking

          public RedisAPI restoreAsking(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      An internal command for migrating keys in a cluster.

      Redis command RESTORE-ASKING.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### restoreAsking

          public RedisAPI restoreAsking(List<String> args)

      An internal command for migrating keys in a cluster.

      Redis command RESTORE-ASKING.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRestoreAsking

          public Single<Response> rxRestoreAsking(List<String> args)

      An internal command for migrating keys in a cluster.

      Redis command RESTORE-ASKING.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### role

          public RedisAPI role(Handler<AsyncResult<Response>> handler)

      Return the role of the instance in the context of replication.

      Redis command ROLE.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### role

          public RedisAPI role()

      Return the role of the instance in the context of replication.

      Redis command ROLE.

      Returns:
        fluent self

    - #### rxRole

          public Single<Response> rxRole()

      Return the role of the instance in the context of replication.

      Redis command ROLE.

      Returns:
        fluent self

    - #### rpop

          public RedisAPI rpop(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Remove and get the last elements in a list.

      Redis command RPOP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### rpop

          public RedisAPI rpop(List<String> args)

      Remove and get the last elements in a list.

      Redis command RPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRpop

          public Single<Response> rxRpop(List<String> args)

      Remove and get the last elements in a list.

      Redis command RPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rpoplpush

          public RedisAPI rpoplpush(String arg0,
                                    String arg1,
                                    Handler<AsyncResult<Response>> handler)

      Remove the last element in a list, prepend it to another list and return it.

      Redis command RPOPLPUSH.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### rpoplpush

          public RedisAPI rpoplpush(String arg0,
                                    String arg1)

      Remove the last element in a list, prepend it to another list and return it.

      Redis command RPOPLPUSH.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxRpoplpush

          public Single<Response> rxRpoplpush(String arg0,
                                              String arg1)

      Remove the last element in a list, prepend it to another list and return it.

      Redis command RPOPLPUSH.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rpush

          public RedisAPI rpush(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Append one or multiple elements to a list.

      Redis command RPUSH.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### rpush

          public RedisAPI rpush(List<String> args)

      Append one or multiple elements to a list.

      Redis command RPUSH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRpush

          public Single<Response> rxRpush(List<String> args)

      Append one or multiple elements to a list.

      Redis command RPUSH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rpushx

          public RedisAPI rpushx(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Append an element to a list, only if the list exists.

      Redis command RPUSHX.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### rpushx

          public RedisAPI rpushx(List<String> args)

      Append an element to a list, only if the list exists.

      Redis command RPUSHX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRpushx

          public Single<Response> rxRpushx(List<String> args)

      Append an element to a list, only if the list exists.

      Redis command RPUSHX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sadd

          public RedisAPI sadd(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Add one or more members to a set.

      Redis command SADD.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sadd

          public RedisAPI sadd(List<String> args)

      Add one or more members to a set.

      Redis command SADD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSadd

          public Single<Response> rxSadd(List<String> args)

      Add one or more members to a set.

      Redis command SADD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### save

          public RedisAPI save(Handler<AsyncResult<Response>> handler)

      Synchronously save the dataset to disk.

      Redis command SAVE.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### save

          public RedisAPI save()

      Synchronously save the dataset to disk.

      Redis command SAVE.

      Returns:
        fluent self

    - #### rxSave

          public Single<Response> rxSave()

      Synchronously save the dataset to disk.

      Redis command SAVE.

      Returns:
        fluent self

    - #### scan

          public RedisAPI scan(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Incrementally iterate the keys space.

      Redis command SCAN.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### scan

          public RedisAPI scan(List<String> args)

      Incrementally iterate the keys space.

      Redis command SCAN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxScan

          public Single<Response> rxScan(List<String> args)

      Incrementally iterate the keys space.

      Redis command SCAN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### scard

          public RedisAPI scard(String arg0,
                                Handler<AsyncResult<Response>> handler)

      Get the number of members in a set.

      Redis command SCARD.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### scard

          public RedisAPI scard(String arg0)

      Get the number of members in a set.

      Redis command SCARD.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxScard

          public Single<Response> rxScard(String arg0)

      Get the number of members in a set.

      Redis command SCARD.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### script

          public RedisAPI script(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      A container for Lua scripts management commands.

      Redis command SCRIPT.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### script

          public RedisAPI script(List<String> args)

      A container for Lua scripts management commands.

      Redis command SCRIPT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxScript

          public Single<Response> rxScript(List<String> args)

      A container for Lua scripts management commands.

      Redis command SCRIPT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sdiff

          public RedisAPI sdiff(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Subtract multiple sets.

      Redis command SDIFF.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sdiff

          public RedisAPI sdiff(List<String> args)

      Subtract multiple sets.

      Redis command SDIFF.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSdiff

          public Single<Response> rxSdiff(List<String> args)

      Subtract multiple sets.

      Redis command SDIFF.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sdiffstore

          public RedisAPI sdiffstore(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Subtract multiple sets and store the resulting set in a key.

      Redis command SDIFFSTORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sdiffstore

          public RedisAPI sdiffstore(List<String> args)

      Subtract multiple sets and store the resulting set in a key.

      Redis command SDIFFSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSdiffstore

          public Single<Response> rxSdiffstore(List<String> args)

      Subtract multiple sets and store the resulting set in a key.

      Redis command SDIFFSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### select

          public RedisAPI select(String arg0,
                                 Handler<AsyncResult<Response>> handler)

      Change the selected database for the current connection.

      Redis command SELECT.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### select

          public RedisAPI select(String arg0)

      Change the selected database for the current connection.

      Redis command SELECT.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxSelect

          public Single<Response> rxSelect(String arg0)

      Change the selected database for the current connection.

      Redis command SELECT.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### set

          public RedisAPI set(List<String> args,
                              Handler<AsyncResult<Response>> handler)

      Set the string value of a key.

      Redis command SET.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### set

          public RedisAPI set(List<String> args)

      Set the string value of a key.

      Redis command SET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSet

          public Single<Response> rxSet(List<String> args)

      Set the string value of a key.

      Redis command SET.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### setbit

          public RedisAPI setbit(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

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

      Redis command SETBIT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### setbit

          public RedisAPI setbit(String arg0,
                                 String arg1,
                                 String arg2)

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

      Redis command SETBIT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSetbit

          public Single<Response> rxSetbit(String arg0,
                                           String arg1,
                                           String arg2)

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

      Redis command SETBIT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### setex

          public RedisAPI setex(String arg0,
                                String arg1,
                                String arg2,
                                Handler<AsyncResult<Response>> handler)

      Set the value and expiration of a key.

      Redis command SETEX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### setex

          public RedisAPI setex(String arg0,
                                String arg1,
                                String arg2)

      Set the value and expiration of a key.

      Redis command SETEX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSetex

          public Single<Response> rxSetex(String arg0,
                                          String arg1,
                                          String arg2)

      Set the value and expiration of a key.

      Redis command SETEX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### setnx

          public RedisAPI setnx(String arg0,
                                String arg1,
                                Handler<AsyncResult<Response>> handler)

      Set the value of a key, only if the key does not exist.

      Redis command SETNX.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### setnx

          public RedisAPI setnx(String arg0,
                                String arg1)

      Set the value of a key, only if the key does not exist.

      Redis command SETNX.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSetnx

          public Single<Response> rxSetnx(String arg0,
                                          String arg1)

      Set the value of a key, only if the key does not exist.

      Redis command SETNX.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### setrange

          public RedisAPI setrange(String arg0,
                                   String arg1,
                                   String arg2,
                                   Handler<AsyncResult<Response>> handler)

      Overwrite part of a string at key starting at the specified offset.

      Redis command SETRANGE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### setrange

          public RedisAPI setrange(String arg0,
                                   String arg1,
                                   String arg2)

      Overwrite part of a string at key starting at the specified offset.

      Redis command SETRANGE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSetrange

          public Single<Response> rxSetrange(String arg0,
                                             String arg1,
                                             String arg2)

      Overwrite part of a string at key starting at the specified offset.

      Redis command SETRANGE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### shutdown

          public RedisAPI shutdown(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Synchronously save the dataset to disk and then shut down the server.

      Redis command SHUTDOWN.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### shutdown

          public RedisAPI shutdown(List<String> args)

      Synchronously save the dataset to disk and then shut down the server.

      Redis command SHUTDOWN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxShutdown

          public Single<Response> rxShutdown(List<String> args)

      Synchronously save the dataset to disk and then shut down the server.

      Redis command SHUTDOWN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sinter

          public RedisAPI sinter(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Intersect multiple sets.

      Redis command SINTER.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sinter

          public RedisAPI sinter(List<String> args)

      Intersect multiple sets.

      Redis command SINTER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSinter

          public Single<Response> rxSinter(List<String> args)

      Intersect multiple sets.

      Redis command SINTER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sintercard

          public RedisAPI sintercard(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Intersect multiple sets and return the cardinality of the result.

      Redis command SINTERCARD.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sintercard

          public RedisAPI sintercard(List<String> args)

      Intersect multiple sets and return the cardinality of the result.

      Redis command SINTERCARD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSintercard

          public Single<Response> rxSintercard(List<String> args)

      Intersect multiple sets and return the cardinality of the result.

      Redis command SINTERCARD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sinterstore

          public RedisAPI sinterstore(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Intersect multiple sets and store the resulting set in a key.

      Redis command SINTERSTORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sinterstore

          public RedisAPI sinterstore(List<String> args)

      Intersect multiple sets and store the resulting set in a key.

      Redis command SINTERSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSinterstore

          public Single<Response> rxSinterstore(List<String> args)

      Intersect multiple sets and store the resulting set in a key.

      Redis command SINTERSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sismember

          public RedisAPI sismember(String arg0,
                                    String arg1,
                                    Handler<AsyncResult<Response>> handler)

      Determine if a given value is a member of a set.

      Redis command SISMEMBER.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### sismember

          public RedisAPI sismember(String arg0,
                                    String arg1)

      Determine if a given value is a member of a set.

      Redis command SISMEMBER.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSismember

          public Single<Response> rxSismember(String arg0,
                                              String arg1)

      Determine if a given value is a member of a set.

      Redis command SISMEMBER.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### slaveof

          public RedisAPI slaveof(String arg0,
                                  String arg1,
                                  Handler<AsyncResult<Response>> handler)

      Make the server a replica of another instance, or promote it as master.

      Redis command SLAVEOF.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### slaveof

          public RedisAPI slaveof(String arg0,
                                  String arg1)

      Make the server a replica of another instance, or promote it as master.

      Redis command SLAVEOF.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSlaveof

          public Single<Response> rxSlaveof(String arg0,
                                            String arg1)

      Make the server a replica of another instance, or promote it as master.

      Redis command SLAVEOF.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### slowlog

          public RedisAPI slowlog(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      A container for slow log commands.

      Redis command SLOWLOG.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### slowlog

          public RedisAPI slowlog(List<String> args)

      A container for slow log commands.

      Redis command SLOWLOG.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSlowlog

          public Single<Response> rxSlowlog(List<String> args)

      A container for slow log commands.

      Redis command SLOWLOG.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### smembers

          public RedisAPI smembers(String arg0,
                                   Handler<AsyncResult<Response>> handler)

      Get all the members in a set.

      Redis command SMEMBERS.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### smembers

          public RedisAPI smembers(String arg0)

      Get all the members in a set.

      Redis command SMEMBERS.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxSmembers

          public Single<Response> rxSmembers(String arg0)

      Get all the members in a set.

      Redis command SMEMBERS.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### smismember

          public RedisAPI smismember(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Returns the membership associated with the given elements for a set.

      Redis command SMISMEMBER.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### smismember

          public RedisAPI smismember(List<String> args)

      Returns the membership associated with the given elements for a set.

      Redis command SMISMEMBER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSmismember

          public Single<Response> rxSmismember(List<String> args)

      Returns the membership associated with the given elements for a set.

      Redis command SMISMEMBER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### smove

          public RedisAPI smove(String arg0,
                                String arg1,
                                String arg2,
                                Handler<AsyncResult<Response>> handler)

      Move a member from one set to another.

      Redis command SMOVE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### smove

          public RedisAPI smove(String arg0,
                                String arg1,
                                String arg2)

      Move a member from one set to another.

      Redis command SMOVE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSmove

          public Single<Response> rxSmove(String arg0,
                                          String arg1,
                                          String arg2)

      Move a member from one set to another.

      Redis command SMOVE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### sort

          public RedisAPI sort(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Sort the elements in a list, set or sorted set.

      Redis command SORT.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sort

          public RedisAPI sort(List<String> args)

      Sort the elements in a list, set or sorted set.

      Redis command SORT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSort

          public Single<Response> rxSort(List<String> args)

      Sort the elements in a list, set or sorted set.

      Redis command SORT.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sortRo

          public RedisAPI sortRo(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Sort the elements in a list, set or sorted set. Read-only variant of SORT.

      Redis command SORT_RO.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sortRo

          public RedisAPI sortRo(List<String> args)

      Sort the elements in a list, set or sorted set. Read-only variant of SORT.

      Redis command SORT_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSortRo

          public Single<Response> rxSortRo(List<String> args)

      Sort the elements in a list, set or sorted set. Read-only variant of SORT.

      Redis command SORT_RO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### spop

          public RedisAPI spop(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Remove and return one or multiple random members from a set.

      Redis command SPOP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### spop

          public RedisAPI spop(List<String> args)

      Remove and return one or multiple random members from a set.

      Redis command SPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSpop

          public Single<Response> rxSpop(List<String> args)

      Remove and return one or multiple random members from a set.

      Redis command SPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### spublish

          public RedisAPI spublish(String arg0,
                                   String arg1,
                                   Handler<AsyncResult<Response>> handler)

      Post a message to a shard channel.

      Redis command SPUBLISH.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### spublish

          public RedisAPI spublish(String arg0,
                                   String arg1)

      Post a message to a shard channel.

      Redis command SPUBLISH.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSpublish

          public Single<Response> rxSpublish(String arg0,
                                             String arg1)

      Post a message to a shard channel.

      Redis command SPUBLISH.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### srandmember

          public RedisAPI srandmember(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Get one or multiple random members from a set.

      Redis command SRANDMEMBER.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### srandmember

          public RedisAPI srandmember(List<String> args)

      Get one or multiple random members from a set.

      Redis command SRANDMEMBER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSrandmember

          public Single<Response> rxSrandmember(List<String> args)

      Get one or multiple random members from a set.

      Redis command SRANDMEMBER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### srem

          public RedisAPI srem(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Remove one or more members from a set.

      Redis command SREM.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### srem

          public RedisAPI srem(List<String> args)

      Remove one or more members from a set.

      Redis command SREM.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSrem

          public Single<Response> rxSrem(List<String> args)

      Remove one or more members from a set.

      Redis command SREM.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sscan

          public RedisAPI sscan(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Incrementally iterate Set elements.

      Redis command SSCAN.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sscan

          public RedisAPI sscan(List<String> args)

      Incrementally iterate Set elements.

      Redis command SSCAN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSscan

          public Single<Response> rxSscan(List<String> args)

      Incrementally iterate Set elements.

      Redis command SSCAN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ssubscribe

          public RedisAPI ssubscribe(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Listen for messages published to the given shard channels.

      Redis command SSUBSCRIBE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### ssubscribe

          public RedisAPI ssubscribe(List<String> args)

      Listen for messages published to the given shard channels.

      Redis command SSUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSsubscribe

          public Single<Response> rxSsubscribe(List<String> args)

      Listen for messages published to the given shard channels.

      Redis command SSUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### strlen

          public RedisAPI strlen(String arg0,
                                 Handler<AsyncResult<Response>> handler)

      Get the length of the value stored in a key.

      Redis command STRLEN.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### strlen

          public RedisAPI strlen(String arg0)

      Get the length of the value stored in a key.

      Redis command STRLEN.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxStrlen

          public Single<Response> rxStrlen(String arg0)

      Get the length of the value stored in a key.

      Redis command STRLEN.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### subscribe

          public RedisAPI subscribe(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Listen for messages published to the given channels.

      Redis command SUBSCRIBE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### subscribe

          public RedisAPI subscribe(List<String> args)

      Listen for messages published to the given channels.

      Redis command SUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSubscribe

          public Single<Response> rxSubscribe(List<String> args)

      Listen for messages published to the given channels.

      Redis command SUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### substr

          public RedisAPI substr(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

      Get a substring of the string stored at a key.

      Redis command SUBSTR.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### substr

          public RedisAPI substr(String arg0,
                                 String arg1,
                                 String arg2)

      Get a substring of the string stored at a key.

      Redis command SUBSTR.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSubstr

          public Single<Response> rxSubstr(String arg0,
                                           String arg1,
                                           String arg2)

      Get a substring of the string stored at a key.

      Redis command SUBSTR.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### sunion

          public RedisAPI sunion(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Add multiple sets.

      Redis command SUNION.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sunion

          public RedisAPI sunion(List<String> args)

      Add multiple sets.

      Redis command SUNION.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSunion

          public Single<Response> rxSunion(List<String> args)

      Add multiple sets.

      Redis command SUNION.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sunionstore

          public RedisAPI sunionstore(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Add multiple sets and store the resulting set in a key.

      Redis command SUNIONSTORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sunionstore

          public RedisAPI sunionstore(List<String> args)

      Add multiple sets and store the resulting set in a key.

      Redis command SUNIONSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSunionstore

          public Single<Response> rxSunionstore(List<String> args)

      Add multiple sets and store the resulting set in a key.

      Redis command SUNIONSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sunsubscribe

          public RedisAPI sunsubscribe(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Stop listening for messages posted to the given shard channels.

      Redis command SUNSUBSCRIBE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sunsubscribe

          public RedisAPI sunsubscribe(List<String> args)

      Stop listening for messages posted to the given shard channels.

      Redis command SUNSUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSunsubscribe

          public Single<Response> rxSunsubscribe(List<String> args)

      Stop listening for messages posted to the given shard channels.

      Redis command SUNSUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### swapdb

          public RedisAPI swapdb(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Swaps two Redis databases.

      Redis command SWAPDB.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### swapdb

          public RedisAPI swapdb(String arg0,
                                 String arg1)

      Swaps two Redis databases.

      Redis command SWAPDB.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSwapdb

          public Single<Response> rxSwapdb(String arg0,
                                           String arg1)

      Swaps two Redis databases.

      Redis command SWAPDB.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### sync

          public RedisAPI sync(Handler<AsyncResult<Response>> handler)

      Internal command used for replication.

      Redis command SYNC.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### sync

          public RedisAPI sync()

      Internal command used for replication.

      Redis command SYNC.

      Returns:
        fluent self

    - #### rxSync

          public Single<Response> rxSync()

      Internal command used for replication.

      Redis command SYNC.

      Returns:
        fluent self

    - #### tdigestAdd

          public RedisAPI tdigestAdd(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.ADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestAdd

          public RedisAPI tdigestAdd(List<String> args)

      Redis command TDIGEST.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestAdd

          public Single<Response> rxTdigestAdd(List<String> args)

      Redis command TDIGEST.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestByrank

          public RedisAPI tdigestByrank(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.BYRANK.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestByrank

          public RedisAPI tdigestByrank(List<String> args)

      Redis command TDIGEST.BYRANK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestByrank

          public Single<Response> rxTdigestByrank(List<String> args)

      Redis command TDIGEST.BYRANK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestByrevrank

          public RedisAPI tdigestByrevrank(List<String> args,
                                           Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.BYREVRANK.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestByrevrank

          public RedisAPI tdigestByrevrank(List<String> args)

      Redis command TDIGEST.BYREVRANK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestByrevrank

          public Single<Response> rxTdigestByrevrank(List<String> args)

      Redis command TDIGEST.BYREVRANK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestCdf

          public RedisAPI tdigestCdf(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.CDF.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestCdf

          public RedisAPI tdigestCdf(List<String> args)

      Redis command TDIGEST.CDF.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestCdf

          public Single<Response> rxTdigestCdf(List<String> args)

      Redis command TDIGEST.CDF.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestCreate

          public RedisAPI tdigestCreate(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.CREATE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestCreate

          public RedisAPI tdigestCreate(List<String> args)

      Redis command TDIGEST.CREATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestCreate

          public Single<Response> rxTdigestCreate(List<String> args)

      Redis command TDIGEST.CREATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestInfo

          public RedisAPI tdigestInfo(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.INFO.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestInfo

          public RedisAPI tdigestInfo(List<String> args)

      Redis command TDIGEST.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestInfo

          public Single<Response> rxTdigestInfo(List<String> args)

      Redis command TDIGEST.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestMax

          public RedisAPI tdigestMax(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.MAX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestMax

          public RedisAPI tdigestMax(List<String> args)

      Redis command TDIGEST.MAX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestMax

          public Single<Response> rxTdigestMax(List<String> args)

      Redis command TDIGEST.MAX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestMerge

          public RedisAPI tdigestMerge(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.MERGE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestMerge

          public RedisAPI tdigestMerge(List<String> args)

      Redis command TDIGEST.MERGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestMerge

          public Single<Response> rxTdigestMerge(List<String> args)

      Redis command TDIGEST.MERGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestMin

          public RedisAPI tdigestMin(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.MIN.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestMin

          public RedisAPI tdigestMin(List<String> args)

      Redis command TDIGEST.MIN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestMin

          public Single<Response> rxTdigestMin(List<String> args)

      Redis command TDIGEST.MIN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestQuantile

          public RedisAPI tdigestQuantile(List<String> args,
                                          Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.QUANTILE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestQuantile

          public RedisAPI tdigestQuantile(List<String> args)

      Redis command TDIGEST.QUANTILE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestQuantile

          public Single<Response> rxTdigestQuantile(List<String> args)

      Redis command TDIGEST.QUANTILE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestRank

          public RedisAPI tdigestRank(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.RANK.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestRank

          public RedisAPI tdigestRank(List<String> args)

      Redis command TDIGEST.RANK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestRank

          public Single<Response> rxTdigestRank(List<String> args)

      Redis command TDIGEST.RANK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestReset

          public RedisAPI tdigestReset(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.RESET.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestReset

          public RedisAPI tdigestReset(List<String> args)

      Redis command TDIGEST.RESET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestReset

          public Single<Response> rxTdigestReset(List<String> args)

      Redis command TDIGEST.RESET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestRevrank

          public RedisAPI tdigestRevrank(List<String> args,
                                         Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.REVRANK.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestRevrank

          public RedisAPI tdigestRevrank(List<String> args)

      Redis command TDIGEST.REVRANK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestRevrank

          public Single<Response> rxTdigestRevrank(List<String> args)

      Redis command TDIGEST.REVRANK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tdigestTrimmedMean

          public RedisAPI tdigestTrimmedMean(List<String> args,
                                             Handler<AsyncResult<Response>> handler)

      Redis command TDIGEST.TRIMMED_MEAN.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tdigestTrimmedMean

          public RedisAPI tdigestTrimmedMean(List<String> args)

      Redis command TDIGEST.TRIMMED_MEAN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTdigestTrimmedMean

          public Single<Response> rxTdigestTrimmedMean(List<String> args)

      Redis command TDIGEST.TRIMMED_MEAN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### time

          public RedisAPI time(Handler<AsyncResult<Response>> handler)

      Return the current server time.

      Redis command TIME.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### time

          public RedisAPI time()

      Return the current server time.

      Redis command TIME.

      Returns:
        fluent self

    - #### rxTime

          public Single<Response> rxTime()

      Return the current server time.

      Redis command TIME.

      Returns:
        fluent self

    - #### timeseriesClusterset

          public RedisAPI timeseriesClusterset(List<String> args,
                                               Handler<AsyncResult<Response>> handler)

      Redis command TIMESERIES.CLUSTERSET.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### timeseriesClusterset

          public RedisAPI timeseriesClusterset(List<String> args)

      Redis command TIMESERIES.CLUSTERSET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTimeseriesClusterset

          public Single<Response> rxTimeseriesClusterset(List<String> args)

      Redis command TIMESERIES.CLUSTERSET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### timeseriesClustersetfromshard

          public RedisAPI timeseriesClustersetfromshard(List<String> args,
                                                        Handler<AsyncResult<Response>> handler)

      Redis command TIMESERIES.CLUSTERSETFROMSHARD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### timeseriesClustersetfromshard

          public RedisAPI timeseriesClustersetfromshard(List<String> args)

      Redis command TIMESERIES.CLUSTERSETFROMSHARD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTimeseriesClustersetfromshard

          public Single<Response> rxTimeseriesClustersetfromshard(List<String> args)

      Redis command TIMESERIES.CLUSTERSETFROMSHARD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### timeseriesHello

          public RedisAPI timeseriesHello(List<String> args,
                                          Handler<AsyncResult<Response>> handler)

      Redis command TIMESERIES.HELLO.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### timeseriesHello

          public RedisAPI timeseriesHello(List<String> args)

      Redis command TIMESERIES.HELLO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTimeseriesHello

          public Single<Response> rxTimeseriesHello(List<String> args)

      Redis command TIMESERIES.HELLO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### timeseriesInfocluster

          public RedisAPI timeseriesInfocluster(List<String> args,
                                                Handler<AsyncResult<Response>> handler)

      Redis command TIMESERIES.INFOCLUSTER.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### timeseriesInfocluster

          public RedisAPI timeseriesInfocluster(List<String> args)

      Redis command TIMESERIES.INFOCLUSTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTimeseriesInfocluster

          public Single<Response> rxTimeseriesInfocluster(List<String> args)

      Redis command TIMESERIES.INFOCLUSTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### timeseriesInnercommunication

          public RedisAPI timeseriesInnercommunication(List<String> args,
                                                       Handler<AsyncResult<Response>> handler)

      Redis command TIMESERIES.INNERCOMMUNICATION.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### timeseriesInnercommunication

          public RedisAPI timeseriesInnercommunication(List<String> args)

      Redis command TIMESERIES.INNERCOMMUNICATION.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTimeseriesInnercommunication

          public Single<Response> rxTimeseriesInnercommunication(List<String> args)

      Redis command TIMESERIES.INNERCOMMUNICATION.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### timeseriesNetworktest

          public RedisAPI timeseriesNetworktest(List<String> args,
                                                Handler<AsyncResult<Response>> handler)

      Redis command TIMESERIES.NETWORKTEST.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### timeseriesNetworktest

          public RedisAPI timeseriesNetworktest(List<String> args)

      Redis command TIMESERIES.NETWORKTEST.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTimeseriesNetworktest

          public Single<Response> rxTimeseriesNetworktest(List<String> args)

      Redis command TIMESERIES.NETWORKTEST.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### timeseriesRefreshcluster

          public RedisAPI timeseriesRefreshcluster(List<String> args,
                                                   Handler<AsyncResult<Response>> handler)

      Redis command TIMESERIES.REFRESHCLUSTER.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### timeseriesRefreshcluster

          public RedisAPI timeseriesRefreshcluster(List<String> args)

      Redis command TIMESERIES.REFRESHCLUSTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTimeseriesRefreshcluster

          public Single<Response> rxTimeseriesRefreshcluster(List<String> args)

      Redis command TIMESERIES.REFRESHCLUSTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### topkAdd

          public RedisAPI topkAdd(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command TOPK.ADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### topkAdd

          public RedisAPI topkAdd(List<String> args)

      Redis command TOPK.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTopkAdd

          public Single<Response> rxTopkAdd(List<String> args)

      Redis command TOPK.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### topkCount

          public RedisAPI topkCount(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command TOPK.COUNT.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### topkCount

          public RedisAPI topkCount(List<String> args)

      Redis command TOPK.COUNT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTopkCount

          public Single<Response> rxTopkCount(List<String> args)

      Redis command TOPK.COUNT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### topkIncrby

          public RedisAPI topkIncrby(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command TOPK.INCRBY.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### topkIncrby

          public RedisAPI topkIncrby(List<String> args)

      Redis command TOPK.INCRBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTopkIncrby

          public Single<Response> rxTopkIncrby(List<String> args)

      Redis command TOPK.INCRBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### topkInfo

          public RedisAPI topkInfo(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command TOPK.INFO.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### topkInfo

          public RedisAPI topkInfo(List<String> args)

      Redis command TOPK.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTopkInfo

          public Single<Response> rxTopkInfo(List<String> args)

      Redis command TOPK.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### topkList

          public RedisAPI topkList(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command TOPK.LIST.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### topkList

          public RedisAPI topkList(List<String> args)

      Redis command TOPK.LIST.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTopkList

          public Single<Response> rxTopkList(List<String> args)

      Redis command TOPK.LIST.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### topkQuery

          public RedisAPI topkQuery(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command TOPK.QUERY.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### topkQuery

          public RedisAPI topkQuery(List<String> args)

      Redis command TOPK.QUERY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTopkQuery

          public Single<Response> rxTopkQuery(List<String> args)

      Redis command TOPK.QUERY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### topkReserve

          public RedisAPI topkReserve(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command TOPK.RESERVE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### topkReserve

          public RedisAPI topkReserve(List<String> args)

      Redis command TOPK.RESERVE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTopkReserve

          public Single<Response> rxTopkReserve(List<String> args)

      Redis command TOPK.RESERVE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### touch

          public RedisAPI touch(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Alters the last access time of a key(s). Returns the number of existing keys specified.

      Redis command TOUCH.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### touch

          public RedisAPI touch(List<String> args)

      Alters the last access time of a key(s). Returns the number of existing keys specified.

      Redis command TOUCH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTouch

          public Single<Response> rxTouch(List<String> args)

      Alters the last access time of a key(s). Returns the number of existing keys specified.

      Redis command TOUCH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsAdd

          public RedisAPI tsAdd(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command TS.ADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsAdd

          public RedisAPI tsAdd(List<String> args)

      Redis command TS.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsAdd

          public Single<Response> rxTsAdd(List<String> args)

      Redis command TS.ADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsAlter

          public RedisAPI tsAlter(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command TS.ALTER.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsAlter

          public RedisAPI tsAlter(List<String> args)

      Redis command TS.ALTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsAlter

          public Single<Response> rxTsAlter(List<String> args)

      Redis command TS.ALTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsCreate

          public RedisAPI tsCreate(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command TS.CREATE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsCreate

          public RedisAPI tsCreate(List<String> args)

      Redis command TS.CREATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsCreate

          public Single<Response> rxTsCreate(List<String> args)

      Redis command TS.CREATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsCreaterule

          public RedisAPI tsCreaterule(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command TS.CREATERULE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsCreaterule

          public RedisAPI tsCreaterule(List<String> args)

      Redis command TS.CREATERULE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsCreaterule

          public Single<Response> rxTsCreaterule(List<String> args)

      Redis command TS.CREATERULE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsDecrby

          public RedisAPI tsDecrby(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command TS.DECRBY.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsDecrby

          public RedisAPI tsDecrby(List<String> args)

      Redis command TS.DECRBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsDecrby

          public Single<Response> rxTsDecrby(List<String> args)

      Redis command TS.DECRBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsDel

          public RedisAPI tsDel(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command TS.DEL.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsDel

          public RedisAPI tsDel(List<String> args)

      Redis command TS.DEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsDel

          public Single<Response> rxTsDel(List<String> args)

      Redis command TS.DEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsDeleterule

          public RedisAPI tsDeleterule(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command TS.DELETERULE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsDeleterule

          public RedisAPI tsDeleterule(List<String> args)

      Redis command TS.DELETERULE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsDeleterule

          public Single<Response> rxTsDeleterule(List<String> args)

      Redis command TS.DELETERULE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsGet

          public RedisAPI tsGet(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command TS.GET.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsGet

          public RedisAPI tsGet(List<String> args)

      Redis command TS.GET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsGet

          public Single<Response> rxTsGet(List<String> args)

      Redis command TS.GET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsIncrby

          public RedisAPI tsIncrby(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command TS.INCRBY.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsIncrby

          public RedisAPI tsIncrby(List<String> args)

      Redis command TS.INCRBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsIncrby

          public Single<Response> rxTsIncrby(List<String> args)

      Redis command TS.INCRBY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsInfo

          public RedisAPI tsInfo(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command TS.INFO.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsInfo

          public RedisAPI tsInfo(List<String> args)

      Redis command TS.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsInfo

          public Single<Response> rxTsInfo(List<String> args)

      Redis command TS.INFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsMadd

          public RedisAPI tsMadd(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command TS.MADD.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsMadd

          public RedisAPI tsMadd(List<String> args)

      Redis command TS.MADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsMadd

          public Single<Response> rxTsMadd(List<String> args)

      Redis command TS.MADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsMget

          public RedisAPI tsMget(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command TS.MGET.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsMget

          public RedisAPI tsMget(List<String> args)

      Redis command TS.MGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsMget

          public Single<Response> rxTsMget(List<String> args)

      Redis command TS.MGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsMrange

          public RedisAPI tsMrange(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command TS.MRANGE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsMrange

          public RedisAPI tsMrange(List<String> args)

      Redis command TS.MRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsMrange

          public Single<Response> rxTsMrange(List<String> args)

      Redis command TS.MRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsMrevrange

          public RedisAPI tsMrevrange(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command TS.MREVRANGE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsMrevrange

          public RedisAPI tsMrevrange(List<String> args)

      Redis command TS.MREVRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsMrevrange

          public Single<Response> rxTsMrevrange(List<String> args)

      Redis command TS.MREVRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsQueryindex

          public RedisAPI tsQueryindex(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command TS.QUERYINDEX.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsQueryindex

          public RedisAPI tsQueryindex(List<String> args)

      Redis command TS.QUERYINDEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsQueryindex

          public Single<Response> rxTsQueryindex(List<String> args)

      Redis command TS.QUERYINDEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsRange

          public RedisAPI tsRange(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command TS.RANGE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsRange

          public RedisAPI tsRange(List<String> args)

      Redis command TS.RANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsRange

          public Single<Response> rxTsRange(List<String> args)

      Redis command TS.RANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsRevrange

          public RedisAPI tsRevrange(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command TS.REVRANGE.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### tsRevrange

          public RedisAPI tsRevrange(List<String> args)

      Redis command TS.REVRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsRevrange

          public Single<Response> rxTsRevrange(List<String> args)

      Redis command TS.REVRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ttl

          public RedisAPI ttl(String arg0,
                              Handler<AsyncResult<Response>> handler)

      Get the time to live for a key in seconds.

      Redis command TTL.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### ttl

          public RedisAPI ttl(String arg0)

      Get the time to live for a key in seconds.

      Redis command TTL.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxTtl

          public Single<Response> rxTtl(String arg0)

      Get the time to live for a key in seconds.

      Redis command TTL.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### type

          public RedisAPI type(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Determine the type stored at key.

      Redis command TYPE.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### type

          public RedisAPI type(String arg0)

      Determine the type stored at key.

      Redis command TYPE.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxType

          public Single<Response> rxType(String arg0)

      Determine the type stored at key.

      Redis command TYPE.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### unlink

          public RedisAPI unlink(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

      Redis command UNLINK.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### unlink

          public RedisAPI unlink(List<String> args)

      Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

      Redis command UNLINK.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxUnlink

          public Single<Response> rxUnlink(List<String> args)

      Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

      Redis command UNLINK.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### unsubscribe

          public RedisAPI unsubscribe(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Stop listening for messages posted to the given channels.

      Redis command UNSUBSCRIBE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### unsubscribe

          public RedisAPI unsubscribe(List<String> args)

      Stop listening for messages posted to the given channels.

      Redis command UNSUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxUnsubscribe

          public Single<Response> rxUnsubscribe(List<String> args)

      Stop listening for messages posted to the given channels.

      Redis command UNSUBSCRIBE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### unwatch

          public RedisAPI unwatch(Handler<AsyncResult<Response>> handler)

      Forget about all watched keys.

      Redis command UNWATCH.

      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### unwatch

          public RedisAPI unwatch()

      Forget about all watched keys.

      Redis command UNWATCH.

      Returns:
        fluent self

    - #### rxUnwatch

          public Single<Response> rxUnwatch()

      Forget about all watched keys.

      Redis command UNWATCH.

      Returns:
        fluent self

    - #### wait

          public RedisAPI wait(String arg0,
                               String arg1,
                               Handler<AsyncResult<Response>> handler)

      Wait for the synchronous replication of all the write commands sent in the context of the current connection.

      Redis command WAIT.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### wait

          public RedisAPI wait(String arg0,
                               String arg1)

      Wait for the synchronous replication of all the write commands sent in the context of the current connection.

      Redis command WAIT.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxWait

          public Single<Response> rxWait(String arg0,
                                         String arg1)

      Wait for the synchronous replication of all the write commands sent in the context of the current connection.

      Redis command WAIT.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### watch

          public RedisAPI watch(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Watch the given keys to determine execution of the MULTI/EXEC block.

      Redis command WATCH.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### watch

          public RedisAPI watch(List<String> args)

      Watch the given keys to determine execution of the MULTI/EXEC block.

      Redis command WATCH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxWatch

          public Single<Response> rxWatch(List<String> args)

      Watch the given keys to determine execution of the MULTI/EXEC block.

      Redis command WATCH.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xack

          public RedisAPI xack(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.

      Redis command XACK.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xack

          public RedisAPI xack(List<String> args)

      Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.

      Redis command XACK.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXack

          public Single<Response> rxXack(List<String> args)

      Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.

      Redis command XACK.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xadd

          public RedisAPI xadd(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Appends a new entry to a stream.

      Redis command XADD.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xadd

          public RedisAPI xadd(List<String> args)

      Appends a new entry to a stream.

      Redis command XADD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXadd

          public Single<Response> rxXadd(List<String> args)

      Appends a new entry to a stream.

      Redis command XADD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xautoclaim

          public RedisAPI xautoclaim(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.

      Redis command XAUTOCLAIM.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xautoclaim

          public RedisAPI xautoclaim(List<String> args)

      Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.

      Redis command XAUTOCLAIM.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXautoclaim

          public Single<Response> rxXautoclaim(List<String> args)

      Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.

      Redis command XAUTOCLAIM.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xclaim

          public RedisAPI xclaim(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.

      Redis command XCLAIM.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xclaim

          public RedisAPI xclaim(List<String> args)

      Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.

      Redis command XCLAIM.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXclaim

          public Single<Response> rxXclaim(List<String> args)

      Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.

      Redis command XCLAIM.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xdel

          public RedisAPI xdel(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.

      Redis command XDEL.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xdel

          public RedisAPI xdel(List<String> args)

      Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.

      Redis command XDEL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXdel

          public Single<Response> rxXdel(List<String> args)

      Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.

      Redis command XDEL.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xgroup

          public RedisAPI xgroup(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      A container for consumer groups commands.

      Redis command XGROUP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xgroup

          public RedisAPI xgroup(List<String> args)

      A container for consumer groups commands.

      Redis command XGROUP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXgroup

          public Single<Response> rxXgroup(List<String> args)

      A container for consumer groups commands.

      Redis command XGROUP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xinfo

          public RedisAPI xinfo(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      A container for stream introspection commands.

      Redis command XINFO.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xinfo

          public RedisAPI xinfo(List<String> args)

      A container for stream introspection commands.

      Redis command XINFO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXinfo

          public Single<Response> rxXinfo(List<String> args)

      A container for stream introspection commands.

      Redis command XINFO.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xlen

          public RedisAPI xlen(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Return the number of entries in a stream.

      Redis command XLEN.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### xlen

          public RedisAPI xlen(String arg0)

      Return the number of entries in a stream.

      Redis command XLEN.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxXlen

          public Single<Response> rxXlen(String arg0)

      Return the number of entries in a stream.

      Redis command XLEN.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### xpending

          public RedisAPI xpending(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.

      Redis command XPENDING.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xpending

          public RedisAPI xpending(List<String> args)

      Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.

      Redis command XPENDING.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXpending

          public Single<Response> rxXpending(List<String> args)

      Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.

      Redis command XPENDING.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xrange

          public RedisAPI xrange(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Return a range of elements in a stream, with IDs matching the specified IDs interval.

      Redis command XRANGE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xrange

          public RedisAPI xrange(List<String> args)

      Return a range of elements in a stream, with IDs matching the specified IDs interval.

      Redis command XRANGE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXrange

          public Single<Response> rxXrange(List<String> args)

      Return a range of elements in a stream, with IDs matching the specified IDs interval.

      Redis command XRANGE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xread

          public RedisAPI xread(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.

      Redis command XREAD.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xread

          public RedisAPI xread(List<String> args)

      Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.

      Redis command XREAD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXread

          public Single<Response> rxXread(List<String> args)

      Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.

      Redis command XREAD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xreadgroup

          public RedisAPI xreadgroup(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.

      Redis command XREADGROUP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xreadgroup

          public RedisAPI xreadgroup(List<String> args)

      Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.

      Redis command XREADGROUP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXreadgroup

          public Single<Response> rxXreadgroup(List<String> args)

      Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.

      Redis command XREADGROUP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xrevrange

          public RedisAPI xrevrange(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.

      Redis command XREVRANGE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xrevrange

          public RedisAPI xrevrange(List<String> args)

      Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.

      Redis command XREVRANGE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXrevrange

          public Single<Response> rxXrevrange(List<String> args)

      Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.

      Redis command XREVRANGE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xsetid

          public RedisAPI xsetid(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      An internal command for replicating stream values.

      Redis command XSETID.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xsetid

          public RedisAPI xsetid(List<String> args)

      An internal command for replicating stream values.

      Redis command XSETID.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXsetid

          public Single<Response> rxXsetid(List<String> args)

      An internal command for replicating stream values.

      Redis command XSETID.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xtrim

          public RedisAPI xtrim(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Trims the stream to (approximately if '~' is passed) a certain size.

      Redis command XTRIM.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xtrim

          public RedisAPI xtrim(List<String> args)

      Trims the stream to (approximately if '~' is passed) a certain size.

      Redis command XTRIM.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXtrim

          public Single<Response> rxXtrim(List<String> args)

      Trims the stream to (approximately if '~' is passed) a certain size.

      Redis command XTRIM.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zadd

          public RedisAPI zadd(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Add one or more members to a sorted set, or update its score if it already exists.

      Redis command ZADD.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zadd

          public RedisAPI zadd(List<String> args)

      Add one or more members to a sorted set, or update its score if it already exists.

      Redis command ZADD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZadd

          public Single<Response> rxZadd(List<String> args)

      Add one or more members to a sorted set, or update its score if it already exists.

      Redis command ZADD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zcard

          public RedisAPI zcard(String arg0,
                                Handler<AsyncResult<Response>> handler)

      Get the number of members in a sorted set.

      Redis command ZCARD.

      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### zcard

          public RedisAPI zcard(String arg0)

      Get the number of members in a sorted set.

      Redis command ZCARD.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxZcard

          public Single<Response> rxZcard(String arg0)

      Get the number of members in a sorted set.

      Redis command ZCARD.

      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### zcount

          public RedisAPI zcount(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

      Count the members in a sorted set with scores within the given values.

      Redis command ZCOUNT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zcount

          public RedisAPI zcount(String arg0,
                                 String arg1,
                                 String arg2)

      Count the members in a sorted set with scores within the given values.

      Redis command ZCOUNT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZcount

          public Single<Response> rxZcount(String arg0,
                                           String arg1,
                                           String arg2)

      Count the members in a sorted set with scores within the given values.

      Redis command ZCOUNT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zdiff

          public RedisAPI zdiff(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Subtract multiple sorted sets.

      Redis command ZDIFF.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zdiff

          public RedisAPI zdiff(List<String> args)

      Subtract multiple sorted sets.

      Redis command ZDIFF.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZdiff

          public Single<Response> rxZdiff(List<String> args)

      Subtract multiple sorted sets.

      Redis command ZDIFF.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zdiffstore

          public RedisAPI zdiffstore(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Subtract multiple sorted sets and store the resulting sorted set in a new key.

      Redis command ZDIFFSTORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zdiffstore

          public RedisAPI zdiffstore(List<String> args)

      Subtract multiple sorted sets and store the resulting sorted set in a new key.

      Redis command ZDIFFSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZdiffstore

          public Single<Response> rxZdiffstore(List<String> args)

      Subtract multiple sorted sets and store the resulting sorted set in a new key.

      Redis command ZDIFFSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zincrby

          public RedisAPI zincrby(String arg0,
                                  String arg1,
                                  String arg2,
                                  Handler<AsyncResult<Response>> handler)

      Increment the score of a member in a sorted set.

      Redis command ZINCRBY.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zincrby

          public RedisAPI zincrby(String arg0,
                                  String arg1,
                                  String arg2)

      Increment the score of a member in a sorted set.

      Redis command ZINCRBY.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZincrby

          public Single<Response> rxZincrby(String arg0,
                                            String arg1,
                                            String arg2)

      Increment the score of a member in a sorted set.

      Redis command ZINCRBY.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zinter

          public RedisAPI zinter(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Intersect multiple sorted sets.

      Redis command ZINTER.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zinter

          public RedisAPI zinter(List<String> args)

      Intersect multiple sorted sets.

      Redis command ZINTER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZinter

          public Single<Response> rxZinter(List<String> args)

      Intersect multiple sorted sets.

      Redis command ZINTER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zintercard

          public RedisAPI zintercard(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Intersect multiple sorted sets and return the cardinality of the result.

      Redis command ZINTERCARD.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zintercard

          public RedisAPI zintercard(List<String> args)

      Intersect multiple sorted sets and return the cardinality of the result.

      Redis command ZINTERCARD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZintercard

          public Single<Response> rxZintercard(List<String> args)

      Intersect multiple sorted sets and return the cardinality of the result.

      Redis command ZINTERCARD.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zinterstore

          public RedisAPI zinterstore(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Intersect multiple sorted sets and store the resulting sorted set in a new key.

      Redis command ZINTERSTORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zinterstore

          public RedisAPI zinterstore(List<String> args)

      Intersect multiple sorted sets and store the resulting sorted set in a new key.

      Redis command ZINTERSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZinterstore

          public Single<Response> rxZinterstore(List<String> args)

      Intersect multiple sorted sets and store the resulting sorted set in a new key.

      Redis command ZINTERSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zlexcount

          public RedisAPI zlexcount(String arg0,
                                    String arg1,
                                    String arg2,
                                    Handler<AsyncResult<Response>> handler)

      Count the number of members in a sorted set between a given lexicographical range.

      Redis command ZLEXCOUNT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zlexcount

          public RedisAPI zlexcount(String arg0,
                                    String arg1,
                                    String arg2)

      Count the number of members in a sorted set between a given lexicographical range.

      Redis command ZLEXCOUNT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZlexcount

          public Single<Response> rxZlexcount(String arg0,
                                              String arg1,
                                              String arg2)

      Count the number of members in a sorted set between a given lexicographical range.

      Redis command ZLEXCOUNT.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zmpop

          public RedisAPI zmpop(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Remove and return members with scores in a sorted set.

      Redis command ZMPOP.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zmpop

          public RedisAPI zmpop(List<String> args)

      Remove and return members with scores in a sorted set.

      Redis command ZMPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZmpop

          public Single<Response> rxZmpop(List<String> args)

      Remove and return members with scores in a sorted set.

      Redis command ZMPOP.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zmscore

          public RedisAPI zmscore(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Get the score associated with the given members in a sorted set.

      Redis command ZMSCORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zmscore

          public RedisAPI zmscore(List<String> args)

      Get the score associated with the given members in a sorted set.

      Redis command ZMSCORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZmscore

          public Single<Response> rxZmscore(List<String> args)

      Get the score associated with the given members in a sorted set.

      Redis command ZMSCORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zpopmax

          public RedisAPI zpopmax(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Remove and return members with the highest scores in a sorted set.

      Redis command ZPOPMAX.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zpopmax

          public RedisAPI zpopmax(List<String> args)

      Remove and return members with the highest scores in a sorted set.

      Redis command ZPOPMAX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZpopmax

          public Single<Response> rxZpopmax(List<String> args)

      Remove and return members with the highest scores in a sorted set.

      Redis command ZPOPMAX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zpopmin

          public RedisAPI zpopmin(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Remove and return members with the lowest scores in a sorted set.

      Redis command ZPOPMIN.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zpopmin

          public RedisAPI zpopmin(List<String> args)

      Remove and return members with the lowest scores in a sorted set.

      Redis command ZPOPMIN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZpopmin

          public Single<Response> rxZpopmin(List<String> args)

      Remove and return members with the lowest scores in a sorted set.

      Redis command ZPOPMIN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrandmember

          public RedisAPI zrandmember(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Get one or multiple random elements from a sorted set.

      Redis command ZRANDMEMBER.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrandmember

          public RedisAPI zrandmember(List<String> args)

      Get one or multiple random elements from a sorted set.

      Redis command ZRANDMEMBER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrandmember

          public Single<Response> rxZrandmember(List<String> args)

      Get one or multiple random elements from a sorted set.

      Redis command ZRANDMEMBER.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrange

          public RedisAPI zrange(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Return a range of members in a sorted set.

      Redis command ZRANGE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrange

          public RedisAPI zrange(List<String> args)

      Return a range of members in a sorted set.

      Redis command ZRANGE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrange

          public Single<Response> rxZrange(List<String> args)

      Return a range of members in a sorted set.

      Redis command ZRANGE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrangebylex

          public RedisAPI zrangebylex(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Return a range of members in a sorted set, by lexicographical range.

      Redis command ZRANGEBYLEX.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrangebylex

          public RedisAPI zrangebylex(List<String> args)

      Return a range of members in a sorted set, by lexicographical range.

      Redis command ZRANGEBYLEX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrangebylex

          public Single<Response> rxZrangebylex(List<String> args)

      Return a range of members in a sorted set, by lexicographical range.

      Redis command ZRANGEBYLEX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrangebyscore

          public RedisAPI zrangebyscore(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Return a range of members in a sorted set, by score.

      Redis command ZRANGEBYSCORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrangebyscore

          public RedisAPI zrangebyscore(List<String> args)

      Return a range of members in a sorted set, by score.

      Redis command ZRANGEBYSCORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrangebyscore

          public Single<Response> rxZrangebyscore(List<String> args)

      Return a range of members in a sorted set, by score.

      Redis command ZRANGEBYSCORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrangestore

          public RedisAPI zrangestore(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Store a range of members from sorted set into another key.

      Redis command ZRANGESTORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrangestore

          public RedisAPI zrangestore(List<String> args)

      Store a range of members from sorted set into another key.

      Redis command ZRANGESTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrangestore

          public Single<Response> rxZrangestore(List<String> args)

      Store a range of members from sorted set into another key.

      Redis command ZRANGESTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrank

          public RedisAPI zrank(String arg0,
                                String arg1,
                                Handler<AsyncResult<Response>> handler)

      Determine the index of a member in a sorted set.

      Redis command ZRANK.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### zrank

          public RedisAPI zrank(String arg0,
                                String arg1)

      Determine the index of a member in a sorted set.

      Redis command ZRANK.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZrank

          public Single<Response> rxZrank(String arg0,
                                          String arg1)

      Determine the index of a member in a sorted set.

      Redis command ZRANK.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zrem

          public RedisAPI zrem(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Remove one or more members from a sorted set.

      Redis command ZREM.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrem

          public RedisAPI zrem(List<String> args)

      Remove one or more members from a sorted set.

      Redis command ZREM.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrem

          public Single<Response> rxZrem(List<String> args)

      Remove one or more members from a sorted set.

      Redis command ZREM.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zremrangebylex

          public RedisAPI zremrangebylex(String arg0,
                                         String arg1,
                                         String arg2,
                                         Handler<AsyncResult<Response>> handler)

      Remove all members in a sorted set between the given lexicographical range.

      Redis command ZREMRANGEBYLEX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zremrangebylex

          public RedisAPI zremrangebylex(String arg0,
                                         String arg1,
                                         String arg2)

      Remove all members in a sorted set between the given lexicographical range.

      Redis command ZREMRANGEBYLEX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebylex

          public Single<Response> rxZremrangebylex(String arg0,
                                                   String arg1,
                                                   String arg2)

      Remove all members in a sorted set between the given lexicographical range.

      Redis command ZREMRANGEBYLEX.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zremrangebyrank

          public RedisAPI zremrangebyrank(String arg0,
                                          String arg1,
                                          String arg2,
                                          Handler<AsyncResult<Response>> handler)

      Remove all members in a sorted set within the given indexes.

      Redis command ZREMRANGEBYRANK.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zremrangebyrank

          public RedisAPI zremrangebyrank(String arg0,
                                          String arg1,
                                          String arg2)

      Remove all members in a sorted set within the given indexes.

      Redis command ZREMRANGEBYRANK.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebyrank

          public Single<Response> rxZremrangebyrank(String arg0,
                                                    String arg1,
                                                    String arg2)

      Remove all members in a sorted set within the given indexes.

      Redis command ZREMRANGEBYRANK.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zremrangebyscore

          public RedisAPI zremrangebyscore(String arg0,
                                           String arg1,
                                           String arg2,
                                           Handler<AsyncResult<Response>> handler)

      Remove all members in a sorted set within the given scores.

      Redis command ZREMRANGEBYSCORE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zremrangebyscore

          public RedisAPI zremrangebyscore(String arg0,
                                           String arg1,
                                           String arg2)

      Remove all members in a sorted set within the given scores.

      Redis command ZREMRANGEBYSCORE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebyscore

          public Single<Response> rxZremrangebyscore(String arg0,
                                                     String arg1,
                                                     String arg2)

      Remove all members in a sorted set within the given scores.

      Redis command ZREMRANGEBYSCORE.

      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zrevrange

          public RedisAPI zrevrange(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Return a range of members in a sorted set, by index, with scores ordered from high to low.

      Redis command ZREVRANGE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrevrange

          public RedisAPI zrevrange(List<String> args)

      Return a range of members in a sorted set, by index, with scores ordered from high to low.

      Redis command ZREVRANGE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrange

          public Single<Response> rxZrevrange(List<String> args)

      Return a range of members in a sorted set, by index, with scores ordered from high to low.

      Redis command ZREVRANGE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrangebylex

          public RedisAPI zrevrangebylex(List<String> args,
                                         Handler<AsyncResult<Response>> handler)

      Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.

      Redis command ZREVRANGEBYLEX.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrevrangebylex

          public RedisAPI zrevrangebylex(List<String> args)

      Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.

      Redis command ZREVRANGEBYLEX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrangebylex

          public Single<Response> rxZrevrangebylex(List<String> args)

      Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.

      Redis command ZREVRANGEBYLEX.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrangebyscore

          public RedisAPI zrevrangebyscore(List<String> args,
                                           Handler<AsyncResult<Response>> handler)

      Return a range of members in a sorted set, by score, with scores ordered from high to low.

      Redis command ZREVRANGEBYSCORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrevrangebyscore

          public RedisAPI zrevrangebyscore(List<String> args)

      Return a range of members in a sorted set, by score, with scores ordered from high to low.

      Redis command ZREVRANGEBYSCORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrangebyscore

          public Single<Response> rxZrevrangebyscore(List<String> args)

      Return a range of members in a sorted set, by score, with scores ordered from high to low.

      Redis command ZREVRANGEBYSCORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrank

          public RedisAPI zrevrank(String arg0,
                                   String arg1,
                                   Handler<AsyncResult<Response>> handler)

      Determine the index of a member in a sorted set, with scores ordered from high to low.

      Redis command ZREVRANK.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### zrevrank

          public RedisAPI zrevrank(String arg0,
                                   String arg1)

      Determine the index of a member in a sorted set, with scores ordered from high to low.

      Redis command ZREVRANK.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZrevrank

          public Single<Response> rxZrevrank(String arg0,
                                             String arg1)

      Determine the index of a member in a sorted set, with scores ordered from high to low.

      Redis command ZREVRANK.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zscan

          public RedisAPI zscan(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Incrementally iterate sorted sets elements and associated scores.

      Redis command ZSCAN.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zscan

          public RedisAPI zscan(List<String> args)

      Incrementally iterate sorted sets elements and associated scores.

      Redis command ZSCAN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZscan

          public Single<Response> rxZscan(List<String> args)

      Incrementally iterate sorted sets elements and associated scores.

      Redis command ZSCAN.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zscore

          public RedisAPI zscore(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Get the score associated with the given member in a sorted set.

      Redis command ZSCORE.

      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### zscore

          public RedisAPI zscore(String arg0,
                                 String arg1)

      Get the score associated with the given member in a sorted set.

      Redis command ZSCORE.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZscore

          public Single<Response> rxZscore(String arg0,
                                           String arg1)

      Get the score associated with the given member in a sorted set.

      Redis command ZSCORE.

      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zunion

          public RedisAPI zunion(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Add multiple sorted sets.

      Redis command ZUNION.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zunion

          public RedisAPI zunion(List<String> args)

      Add multiple sorted sets.

      Redis command ZUNION.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZunion

          public Single<Response> rxZunion(List<String> args)

      Add multiple sorted sets.

      Redis command ZUNION.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zunionstore

          public RedisAPI zunionstore(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Add multiple sorted sets and store the resulting sorted set in a new key.

      Redis command ZUNIONSTORE.

      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zunionstore

          public RedisAPI zunionstore(List<String> args)

      Add multiple sorted sets and store the resulting sorted set in a new key.

      Redis command ZUNIONSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZunionstore

          public Single<Response> rxZunionstore(List<String> args)

      Add multiple sorted sets and store the resulting sorted set in a new key.

      Redis command ZUNIONSTORE.

      Parameters:
        `args` -
      Returns:
        fluent self

    - #### api

          public static RedisAPI api(Redis client)

    - #### api

          public static RedisAPI api(RedisConnection connection)

    - #### newInstance

          public static RedisAPI newInstance(RedisAPI arg)

Copyright © 2025 Eclipse. All rights reserved.