io.vertx.rxjava.redis.client

## Class RedisAPI

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

-     public class RedisAPI
      extends Object

  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)` Redis command ACL.
    `RedisAPI` | `acl(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ACL.
    `static RedisAPI` | `api(Redis client)`
    `static RedisAPI` | `api(RedisConnection connection)`
    `RedisAPI` | `append(String arg0, String arg1)` Redis command APPEND.
    `RedisAPI` | `append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command APPEND.
    `RedisAPI` | `asking()` Redis command ASKING.
    `RedisAPI` | `asking(Handler<AsyncResult<Response>> handler)` Redis command ASKING.
    `RedisAPI` | `auth(List<String> args)` Redis command AUTH.
    `RedisAPI` | `auth(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command AUTH.
    `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()` Redis command BGREWRITEAOF.
    `RedisAPI` | `bgrewriteaof(Handler<AsyncResult<Response>> handler)` Redis command BGREWRITEAOF.
    `RedisAPI` | `bgsave(List<String> args)` Redis command BGSAVE.
    `RedisAPI` | `bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BGSAVE.
    `RedisAPI` | `bitcount(List<String> args)` Redis command BITCOUNT.
    `RedisAPI` | `bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITCOUNT.
    `RedisAPI` | `bitfield(List<String> args)` Redis command BITFIELD.
    `RedisAPI` | `bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITFIELD.
    `RedisAPI` | `bitfieldRo(List<String> args)` Redis command BITFIELD_RO.
    `RedisAPI` | `bitfieldRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITFIELD_RO.
    `RedisAPI` | `bitop(List<String> args)` Redis command BITOP.
    `RedisAPI` | `bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITOP.
    `RedisAPI` | `bitpos(List<String> args)` Redis command BITPOS.
    `RedisAPI` | `bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BITPOS.
    `RedisAPI` | `blmove(String arg0, String arg1, String arg2, String arg3, String arg4)` Redis command BLMOVE.
    `RedisAPI` | `blmove(String arg0, String arg1, String arg2, String arg3, String arg4, Handler<AsyncResult<Response>> handler)` Redis command BLMOVE.
    `RedisAPI` | `blmpop(List<String> args)` Redis command BLMPOP.
    `RedisAPI` | `blmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BLMPOP.
    `RedisAPI` | `blpop(List<String> args)` Redis command BLPOP.
    `RedisAPI` | `blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BLPOP.
    `RedisAPI` | `brpop(List<String> args)` Redis command BRPOP.
    `RedisAPI` | `brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BRPOP.
    `RedisAPI` | `brpoplpush(String arg0, String arg1, String arg2)` Redis command BRPOPLPUSH.
    `RedisAPI` | `brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command BRPOPLPUSH.
    `RedisAPI` | `bzmpop(List<String> args)` Redis command BZMPOP.
    `RedisAPI` | `bzmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZMPOP.
    `RedisAPI` | `bzpopmax(List<String> args)` Redis command BZPOPMAX.
    `RedisAPI` | `bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZPOPMAX.
    `RedisAPI` | `bzpopmin(List<String> args)` Redis command BZPOPMIN.
    `RedisAPI` | `bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command BZPOPMIN.
    `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)` Redis command CLIENT.
    `RedisAPI` | `client(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CLIENT.
    `void` | `close()`
    `RedisAPI` | `cluster(List<String> args)` Redis command CLUSTER.
    `RedisAPI` | `cluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CLUSTER.
    `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)` Redis command COMMAND.
    `RedisAPI` | `command(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command COMMAND.
    `RedisAPI` | `config(List<String> args)` Redis command CONFIG.
    `RedisAPI` | `config(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command CONFIG.
    `RedisAPI` | `copy(List<String> args)` Redis command COPY.
    `RedisAPI` | `copy(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command COPY.
    `RedisAPI` | `dbsize()` Redis command DBSIZE.
    `RedisAPI` | `dbsize(Handler<AsyncResult<Response>> handler)` Redis command DBSIZE.
    `RedisAPI` | `debug(List<String> args)` Redis command DEBUG.
    `RedisAPI` | `debug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command DEBUG.
    `RedisAPI` | `decr(String arg0)` Redis command DECR.
    `RedisAPI` | `decr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command DECR.
    `RedisAPI` | `decrby(String arg0, String arg1)` Redis command DECRBY.
    `RedisAPI` | `decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command DECRBY.
    `RedisAPI` | `del(List<String> args)` Redis command DEL.
    `RedisAPI` | `del(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command DEL.
    `RedisAPI` | `discard()` Redis command DISCARD.
    `RedisAPI` | `discard(Handler<AsyncResult<Response>> handler)` Redis command DISCARD.
    `RedisAPI` | `dump(String arg0)` Redis command DUMP.
    `RedisAPI` | `dump(String arg0, Handler<AsyncResult<Response>> handler)` Redis command DUMP.
    `RedisAPI` | `echo(String arg0)` Redis command ECHO.
    `RedisAPI` | `echo(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ECHO.
    `boolean` | `equals(Object o)`
    `RedisAPI` | `eval(List<String> args)` Redis command EVAL.
    `RedisAPI` | `eval(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVAL.
    `RedisAPI` | `evalRo(List<String> args)` Redis command EVAL_RO.
    `RedisAPI` | `evalRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVAL_RO.
    `RedisAPI` | `evalsha(List<String> args)` Redis command EVALSHA.
    `RedisAPI` | `evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVALSHA.
    `RedisAPI` | `evalshaRo(List<String> args)` Redis command EVALSHA_RO.
    `RedisAPI` | `evalshaRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EVALSHA_RO.
    `RedisAPI` | `exec()` Redis command EXEC.
    `RedisAPI` | `exec(Handler<AsyncResult<Response>> handler)` Redis command EXEC.
    `RedisAPI` | `exists(List<String> args)` Redis command EXISTS.
    `RedisAPI` | `exists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXISTS.
    `RedisAPI` | `expire(List<String> args)` Redis command EXPIRE.
    `RedisAPI` | `expire(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXPIRE.
    `RedisAPI` | `expireat(List<String> args)` Redis command EXPIREAT.
    `RedisAPI` | `expireat(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command EXPIREAT.
    `RedisAPI` | `expiretime(String arg0)` Redis command EXPIRETIME.
    `RedisAPI` | `expiretime(String arg0, Handler<AsyncResult<Response>> handler)` Redis command EXPIRETIME.
    `RedisAPI` | `failover(List<String> args)` Redis command FAILOVER.
    `RedisAPI` | `failover(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FAILOVER.
    `RedisAPI` | `fcall(List<String> args)` Redis command FCALL.
    `RedisAPI` | `fcall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FCALL.
    `RedisAPI` | `fcallRo(List<String> args)` Redis command FCALL_RO.
    `RedisAPI` | `fcallRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FCALL_RO.
    `RedisAPI` | `flushall(List<String> args)` Redis command FLUSHALL.
    `RedisAPI` | `flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FLUSHALL.
    `RedisAPI` | `flushdb(List<String> args)` Redis command FLUSHDB.
    `RedisAPI` | `flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FLUSHDB.
    `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)` Redis command FUNCTION.
    `RedisAPI` | `function(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command FUNCTION.
    `RedisAPI` | `geoadd(List<String> args)` Redis command GEOADD.
    `RedisAPI` | `geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOADD.
    `RedisAPI` | `geodist(List<String> args)` Redis command GEODIST.
    `RedisAPI` | `geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEODIST.
    `RedisAPI` | `geohash(List<String> args)` Redis command GEOHASH.
    `RedisAPI` | `geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOHASH.
    `RedisAPI` | `geopos(List<String> args)` Redis command GEOPOS.
    `RedisAPI` | `geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOPOS.
    `RedisAPI` | `georadius(List<String> args)` Redis command GEORADIUS.
    `RedisAPI` | `georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUS.
    `RedisAPI` | `georadiusbymember(List<String> args)` Redis command GEORADIUSBYMEMBER.
    `RedisAPI` | `georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUSBYMEMBER.
    `RedisAPI` | `georadiusbymemberRo(List<String> args)` Redis command GEORADIUSBYMEMBER_RO.
    `RedisAPI` | `georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUSBYMEMBER_RO.
    `RedisAPI` | `georadiusRo(List<String> args)` Redis command GEORADIUS_RO.
    `RedisAPI` | `georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEORADIUS_RO.
    `RedisAPI` | `geosearch(List<String> args)` Redis command GEOSEARCH.
    `RedisAPI` | `geosearch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOSEARCH.
    `RedisAPI` | `geosearchstore(List<String> args)` Redis command GEOSEARCHSTORE.
    `RedisAPI` | `geosearchstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GEOSEARCHSTORE.
    `RedisAPI` | `get(String arg0)` Redis command GET.
    `RedisAPI` | `get(String arg0, Handler<AsyncResult<Response>> handler)` Redis command GET.
    `RedisAPI` | `getbit(String arg0, String arg1)` Redis command GETBIT.
    `RedisAPI` | `getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command GETBIT.
    `RedisAPI` | `getdel(String arg0)` Redis command GETDEL.
    `RedisAPI` | `getdel(String arg0, Handler<AsyncResult<Response>> handler)` Redis command GETDEL.
    `RedisAPI` | `getDelegate()`
    `RedisAPI` | `getex(List<String> args)` Redis command GETEX.
    `RedisAPI` | `getex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command GETEX.
    `RedisAPI` | `getrange(String arg0, String arg1, String arg2)` Redis command GETRANGE.
    `RedisAPI` | `getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command GETRANGE.
    `RedisAPI` | `getset(String arg0, String arg1)` Redis command GETSET.
    `RedisAPI` | `getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command GETSET.
    `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)` Redis command HDEL.
    `RedisAPI` | `hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HDEL.
    `RedisAPI` | `hello(List<String> args)` Redis command HELLO.
    `RedisAPI` | `hello(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HELLO.
    `RedisAPI` | `hexists(String arg0, String arg1)` Redis command HEXISTS.
    `RedisAPI` | `hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HEXISTS.
    `RedisAPI` | `hget(String arg0, String arg1)` Redis command HGET.
    `RedisAPI` | `hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HGET.
    `RedisAPI` | `hgetall(String arg0)` Redis command HGETALL.
    `RedisAPI` | `hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HGETALL.
    `RedisAPI` | `hincrby(String arg0, String arg1, String arg2)` Redis command HINCRBY.
    `RedisAPI` | `hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HINCRBY.
    `RedisAPI` | `hincrbyfloat(String arg0, String arg1, String arg2)` Redis command HINCRBYFLOAT.
    `RedisAPI` | `hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HINCRBYFLOAT.
    `RedisAPI` | `hkeys(String arg0)` Redis command HKEYS.
    `RedisAPI` | `hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HKEYS.
    `RedisAPI` | `hlen(String arg0)` Redis command HLEN.
    `RedisAPI` | `hlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HLEN.
    `RedisAPI` | `hmget(List<String> args)` Redis command HMGET.
    `RedisAPI` | `hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HMGET.
    `RedisAPI` | `hmset(List<String> args)` Redis command HMSET.
    `RedisAPI` | `hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HMSET.
    `RedisAPI` | `hrandfield(List<String> args)` Redis command HRANDFIELD.
    `RedisAPI` | `hrandfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HRANDFIELD.
    `RedisAPI` | `hscan(List<String> args)` Redis command HSCAN.
    `RedisAPI` | `hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HSCAN.
    `RedisAPI` | `hset(List<String> args)` Redis command HSET.
    `RedisAPI` | `hset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command HSET.
    `RedisAPI` | `hsetnx(String arg0, String arg1, String arg2)` Redis command HSETNX.
    `RedisAPI` | `hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command HSETNX.
    `RedisAPI` | `hstrlen(String arg0, String arg1)` Redis command HSTRLEN.
    `RedisAPI` | `hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command HSTRLEN.
    `RedisAPI` | `hvals(String arg0)` Redis command HVALS.
    `RedisAPI` | `hvals(String arg0, Handler<AsyncResult<Response>> handler)` Redis command HVALS.
    `RedisAPI` | `incr(String arg0)` Redis command INCR.
    `RedisAPI` | `incr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command INCR.
    `RedisAPI` | `incrby(String arg0, String arg1)` Redis command INCRBY.
    `RedisAPI` | `incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command INCRBY.
    `RedisAPI` | `incrbyfloat(String arg0, String arg1)` Redis command INCRBYFLOAT.
    `RedisAPI` | `incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command INCRBYFLOAT.
    `RedisAPI` | `info(List<String> args)` Redis command INFO.
    `RedisAPI` | `info(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command INFO.
    `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)` Redis command KEYS.
    `RedisAPI` | `keys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command KEYS.
    `RedisAPI` | `lastsave()` Redis command LASTSAVE.
    `RedisAPI` | `lastsave(Handler<AsyncResult<Response>> handler)` Redis command LASTSAVE.
    `RedisAPI` | `latency(List<String> args)` Redis command LATENCY.
    `RedisAPI` | `latency(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LATENCY.
    `RedisAPI` | `lcs(List<String> args)` Redis command LCS.
    `RedisAPI` | `lcs(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LCS.
    `RedisAPI` | `lindex(String arg0, String arg1)` Redis command LINDEX.
    `RedisAPI` | `lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command LINDEX.
    `RedisAPI` | `linsert(String arg0, String arg1, String arg2, String arg3)` Redis command LINSERT.
    `RedisAPI` | `linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command LINSERT.
    `RedisAPI` | `llen(String arg0)` Redis command LLEN.
    `RedisAPI` | `llen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command LLEN.
    `RedisAPI` | `lmove(String arg0, String arg1, String arg2, String arg3)` Redis command LMOVE.
    `RedisAPI` | `lmove(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command LMOVE.
    `RedisAPI` | `lmpop(List<String> args)` Redis command LMPOP.
    `RedisAPI` | `lmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LMPOP.
    `RedisAPI` | `lolwut(List<String> args)` Redis command LOLWUT.
    `RedisAPI` | `lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LOLWUT.
    `RedisAPI` | `lpop(List<String> args)` Redis command LPOP.
    `RedisAPI` | `lpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPOP.
    `RedisAPI` | `lpos(List<String> args)` Redis command LPOS.
    `RedisAPI` | `lpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPOS.
    `RedisAPI` | `lpush(List<String> args)` Redis command LPUSH.
    `RedisAPI` | `lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPUSH.
    `RedisAPI` | `lpushx(List<String> args)` Redis command LPUSHX.
    `RedisAPI` | `lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command LPUSHX.
    `RedisAPI` | `lrange(String arg0, String arg1, String arg2)` Redis command LRANGE.
    `RedisAPI` | `lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LRANGE.
    `RedisAPI` | `lrem(String arg0, String arg1, String arg2)` Redis command LREM.
    `RedisAPI` | `lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LREM.
    `RedisAPI` | `lset(String arg0, String arg1, String arg2)` Redis command LSET.
    `RedisAPI` | `lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LSET.
    `RedisAPI` | `ltrim(String arg0, String arg1, String arg2)` Redis command LTRIM.
    `RedisAPI` | `ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command LTRIM.
    `RedisAPI` | `memory(List<String> args)` Redis command MEMORY.
    `RedisAPI` | `memory(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MEMORY.
    `RedisAPI` | `mget(List<String> args)` Redis command MGET.
    `RedisAPI` | `mget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MGET.
    `RedisAPI` | `migrate(List<String> args)` Redis command MIGRATE.
    `RedisAPI` | `migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MIGRATE.
    `RedisAPI` | `module(List<String> args)` Redis command MODULE.
    `RedisAPI` | `module(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MODULE.
    `RedisAPI` | `monitor()` Redis command MONITOR.
    `RedisAPI` | `monitor(Handler<AsyncResult<Response>> handler)` Redis command MONITOR.
    `RedisAPI` | `move(String arg0, String arg1)` Redis command MOVE.
    `RedisAPI` | `move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command MOVE.
    `RedisAPI` | `mset(List<String> args)` Redis command MSET.
    `RedisAPI` | `mset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MSET.
    `RedisAPI` | `msetnx(List<String> args)` Redis command MSETNX.
    `RedisAPI` | `msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command MSETNX.
    `RedisAPI` | `multi()` Redis command MULTI.
    `RedisAPI` | `multi(Handler<AsyncResult<Response>> handler)` Redis command MULTI.
    `static RedisAPI` | `newInstance(RedisAPI arg)`
    `RedisAPI` | `object(List<String> args)` Redis command OBJECT.
    `RedisAPI` | `object(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command OBJECT.
    `RedisAPI` | `persist(String arg0)` Redis command PERSIST.
    `RedisAPI` | `persist(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PERSIST.
    `RedisAPI` | `pexpire(List<String> args)` Redis command PEXPIRE.
    `RedisAPI` | `pexpire(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PEXPIRE.
    `RedisAPI` | `pexpireat(List<String> args)` Redis command PEXPIREAT.
    `RedisAPI` | `pexpireat(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PEXPIREAT.
    `RedisAPI` | `pexpiretime(String arg0)` Redis command PEXPIRETIME.
    `RedisAPI` | `pexpiretime(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PEXPIRETIME.
    `RedisAPI` | `pfadd(List<String> args)` Redis command PFADD.
    `RedisAPI` | `pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFADD.
    `RedisAPI` | `pfcount(List<String> args)` Redis command PFCOUNT.
    `RedisAPI` | `pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFCOUNT.
    `RedisAPI` | `pfdebug(String arg0, String arg1)` Redis command PFDEBUG.
    `RedisAPI` | `pfdebug(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command PFDEBUG.
    `RedisAPI` | `pfmerge(List<String> args)` Redis command PFMERGE.
    `RedisAPI` | `pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PFMERGE.
    `RedisAPI` | `pfselftest()` Redis command PFSELFTEST.
    `RedisAPI` | `pfselftest(Handler<AsyncResult<Response>> handler)` Redis command PFSELFTEST.
    `RedisAPI` | `ping(List<String> args)` Redis command PING.
    `RedisAPI` | `ping(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PING.
    `RedisAPI` | `psetex(String arg0, String arg1, String arg2)` Redis command PSETEX.
    `RedisAPI` | `psetex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command PSETEX.
    `RedisAPI` | `psubscribe(List<String> args)` Redis command PSUBSCRIBE.
    `RedisAPI` | `psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PSUBSCRIBE.
    `RedisAPI` | `psync(List<String> args)` Redis command PSYNC.
    `RedisAPI` | `psync(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PSYNC.
    `RedisAPI` | `pttl(String arg0)` Redis command PTTL.
    `RedisAPI` | `pttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command PTTL.
    `RedisAPI` | `publish(String arg0, String arg1)` Redis command PUBLISH.
    `RedisAPI` | `publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command PUBLISH.
    `RedisAPI` | `pubsub(List<String> args)` Redis command PUBSUB.
    `RedisAPI` | `pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PUBSUB.
    `RedisAPI` | `punsubscribe(List<String> args)` Redis command PUNSUBSCRIBE.
    `RedisAPI` | `punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command PUNSUBSCRIBE.
    `RedisAPI` | `quit(List<String> args)` Redis command QUIT.
    `RedisAPI` | `quit(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command QUIT.
    `RedisAPI` | `randomkey()` Redis command RANDOMKEY.
    `RedisAPI` | `randomkey(Handler<AsyncResult<Response>> handler)` Redis command RANDOMKEY.
    `RedisAPI` | `readonly()` Redis command READONLY.
    `RedisAPI` | `readonly(Handler<AsyncResult<Response>> handler)` Redis command READONLY.
    `RedisAPI` | `readwrite()` Redis command READWRITE.
    `RedisAPI` | `readwrite(Handler<AsyncResult<Response>> handler)` Redis command READWRITE.
    `RedisAPI` | `rename(String arg0, String arg1)` Redis command RENAME.
    `RedisAPI` | `rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RENAME.
    `RedisAPI` | `renamenx(String arg0, String arg1)` Redis command RENAMENX.
    `RedisAPI` | `renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RENAMENX.
    `RedisAPI` | `replconf(List<String> args)` Redis command REPLCONF.
    `RedisAPI` | `replconf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command REPLCONF.
    `RedisAPI` | `replicaof(String arg0, String arg1)` Redis command REPLICAOF.
    `RedisAPI` | `replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command REPLICAOF.
    `RedisAPI` | `reset()` Redis command RESET.
    `RedisAPI` | `reset(Handler<AsyncResult<Response>> handler)` Redis command RESET.
    `RedisAPI` | `restore(List<String> args)` Redis command RESTORE.
    `RedisAPI` | `restore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RESTORE.
    `RedisAPI` | `restoreAsking(List<String> args)` Redis command RESTORE-ASKING.
    `RedisAPI` | `restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RESTORE-ASKING.
    `RedisAPI` | `role()` Redis command ROLE.
    `RedisAPI` | `role(Handler<AsyncResult<Response>> handler)` Redis command ROLE.
    `RedisAPI` | `rpop(List<String> args)` Redis command RPOP.
    `RedisAPI` | `rpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPOP.
    `RedisAPI` | `rpoplpush(String arg0, String arg1)` Redis command RPOPLPUSH.
    `RedisAPI` | `rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command RPOPLPUSH.
    `RedisAPI` | `rpush(List<String> args)` Redis command RPUSH.
    `RedisAPI` | `rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPUSH.
    `RedisAPI` | `rpushx(List<String> args)` Redis command RPUSHX.
    `RedisAPI` | `rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command RPUSHX.
    `Single<Response>` | `rxAcl(List<String> args)` Redis command ACL.
    `Single<Response>` | `rxAppend(String arg0, String arg1)` Redis command APPEND.
    `Single<Response>` | `rxAsking()` Redis command ASKING.
    `Single<Response>` | `rxAuth(List<String> args)` Redis command AUTH.
    `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()` Redis command BGREWRITEAOF.
    `Single<Response>` | `rxBgsave(List<String> args)` Redis command BGSAVE.
    `Single<Response>` | `rxBitcount(List<String> args)` Redis command BITCOUNT.
    `Single<Response>` | `rxBitfield(List<String> args)` Redis command BITFIELD.
    `Single<Response>` | `rxBitfieldRo(List<String> args)` Redis command BITFIELD_RO.
    `Single<Response>` | `rxBitop(List<String> args)` Redis command BITOP.
    `Single<Response>` | `rxBitpos(List<String> args)` Redis command BITPOS.
    `Single<Response>` | `rxBlmove(String arg0, String arg1, String arg2, String arg3, String arg4)` Redis command BLMOVE.
    `Single<Response>` | `rxBlmpop(List<String> args)` Redis command BLMPOP.
    `Single<Response>` | `rxBlpop(List<String> args)` Redis command BLPOP.
    `Single<Response>` | `rxBrpop(List<String> args)` Redis command BRPOP.
    `Single<Response>` | `rxBrpoplpush(String arg0, String arg1, String arg2)` Redis command BRPOPLPUSH.
    `Single<Response>` | `rxBzmpop(List<String> args)` Redis command BZMPOP.
    `Single<Response>` | `rxBzpopmax(List<String> args)` Redis command BZPOPMAX.
    `Single<Response>` | `rxBzpopmin(List<String> args)` Redis command BZPOPMIN.
    `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)` Redis command CLIENT.
    `Single<Response>` | `rxCluster(List<String> args)` Redis command CLUSTER.
    `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)` Redis command COMMAND.
    `Single<Response>` | `rxConfig(List<String> args)` Redis command CONFIG.
    `Single<Response>` | `rxCopy(List<String> args)` Redis command COPY.
    `Single<Response>` | `rxDbsize()` Redis command DBSIZE.
    `Single<Response>` | `rxDebug(List<String> args)` Redis command DEBUG.
    `Single<Response>` | `rxDecr(String arg0)` Redis command DECR.
    `Single<Response>` | `rxDecrby(String arg0, String arg1)` Redis command DECRBY.
    `Single<Response>` | `rxDel(List<String> args)` Redis command DEL.
    `Single<Response>` | `rxDiscard()` Redis command DISCARD.
    `Single<Response>` | `rxDump(String arg0)` Redis command DUMP.
    `Single<Response>` | `rxEcho(String arg0)` Redis command ECHO.
    `Single<Response>` | `rxEval(List<String> args)` Redis command EVAL.
    `Single<Response>` | `rxEvalRo(List<String> args)` Redis command EVAL_RO.
    `Single<Response>` | `rxEvalsha(List<String> args)` Redis command EVALSHA.
    `Single<Response>` | `rxEvalshaRo(List<String> args)` Redis command EVALSHA_RO.
    `Single<Response>` | `rxExec()` Redis command EXEC.
    `Single<Response>` | `rxExists(List<String> args)` Redis command EXISTS.
    `Single<Response>` | `rxExpire(List<String> args)` Redis command EXPIRE.
    `Single<Response>` | `rxExpireat(List<String> args)` Redis command EXPIREAT.
    `Single<Response>` | `rxExpiretime(String arg0)` Redis command EXPIRETIME.
    `Single<Response>` | `rxFailover(List<String> args)` Redis command FAILOVER.
    `Single<Response>` | `rxFcall(List<String> args)` Redis command FCALL.
    `Single<Response>` | `rxFcallRo(List<String> args)` Redis command FCALL_RO.
    `Single<Response>` | `rxFlushall(List<String> args)` Redis command FLUSHALL.
    `Single<Response>` | `rxFlushdb(List<String> args)` Redis command FLUSHDB.
    `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)` Redis command FUNCTION.
    `Single<Response>` | `rxGeoadd(List<String> args)` Redis command GEOADD.
    `Single<Response>` | `rxGeodist(List<String> args)` Redis command GEODIST.
    `Single<Response>` | `rxGeohash(List<String> args)` Redis command GEOHASH.
    `Single<Response>` | `rxGeopos(List<String> args)` Redis command GEOPOS.
    `Single<Response>` | `rxGeoradius(List<String> args)` Redis command GEORADIUS.
    `Single<Response>` | `rxGeoradiusbymember(List<String> args)` Redis command GEORADIUSBYMEMBER.
    `Single<Response>` | `rxGeoradiusbymemberRo(List<String> args)` Redis command GEORADIUSBYMEMBER_RO.
    `Single<Response>` | `rxGeoradiusRo(List<String> args)` Redis command GEORADIUS_RO.
    `Single<Response>` | `rxGeosearch(List<String> args)` Redis command GEOSEARCH.
    `Single<Response>` | `rxGeosearchstore(List<String> args)` Redis command GEOSEARCHSTORE.
    `Single<Response>` | `rxGet(String arg0)` Redis command GET.
    `Single<Response>` | `rxGetbit(String arg0, String arg1)` Redis command GETBIT.
    `Single<Response>` | `rxGetdel(String arg0)` Redis command GETDEL.
    `Single<Response>` | `rxGetex(List<String> args)` Redis command GETEX.
    `Single<Response>` | `rxGetrange(String arg0, String arg1, String arg2)` Redis command GETRANGE.
    `Single<Response>` | `rxGetset(String arg0, String arg1)` Redis command GETSET.
    `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)` Redis command HDEL.
    `Single<Response>` | `rxHello(List<String> args)` Redis command HELLO.
    `Single<Response>` | `rxHexists(String arg0, String arg1)` Redis command HEXISTS.
    `Single<Response>` | `rxHget(String arg0, String arg1)` Redis command HGET.
    `Single<Response>` | `rxHgetall(String arg0)` Redis command HGETALL.
    `Single<Response>` | `rxHincrby(String arg0, String arg1, String arg2)` Redis command HINCRBY.
    `Single<Response>` | `rxHincrbyfloat(String arg0, String arg1, String arg2)` Redis command HINCRBYFLOAT.
    `Single<Response>` | `rxHkeys(String arg0)` Redis command HKEYS.
    `Single<Response>` | `rxHlen(String arg0)` Redis command HLEN.
    `Single<Response>` | `rxHmget(List<String> args)` Redis command HMGET.
    `Single<Response>` | `rxHmset(List<String> args)` Redis command HMSET.
    `Single<Response>` | `rxHrandfield(List<String> args)` Redis command HRANDFIELD.
    `Single<Response>` | `rxHscan(List<String> args)` Redis command HSCAN.
    `Single<Response>` | `rxHset(List<String> args)` Redis command HSET.
    `Single<Response>` | `rxHsetnx(String arg0, String arg1, String arg2)` Redis command HSETNX.
    `Single<Response>` | `rxHstrlen(String arg0, String arg1)` Redis command HSTRLEN.
    `Single<Response>` | `rxHvals(String arg0)` Redis command HVALS.
    `Single<Response>` | `rxIncr(String arg0)` Redis command INCR.
    `Single<Response>` | `rxIncrby(String arg0, String arg1)` Redis command INCRBY.
    `Single<Response>` | `rxIncrbyfloat(String arg0, String arg1)` Redis command INCRBYFLOAT.
    `Single<Response>` | `rxInfo(List<String> args)` Redis command INFO.
    `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)` Redis command KEYS.
    `Single<Response>` | `rxLastsave()` Redis command LASTSAVE.
    `Single<Response>` | `rxLatency(List<String> args)` Redis command LATENCY.
    `Single<Response>` | `rxLcs(List<String> args)` Redis command LCS.
    `Single<Response>` | `rxLindex(String arg0, String arg1)` Redis command LINDEX.
    `Single<Response>` | `rxLinsert(String arg0, String arg1, String arg2, String arg3)` Redis command LINSERT.
    `Single<Response>` | `rxLlen(String arg0)` Redis command LLEN.
    `Single<Response>` | `rxLmove(String arg0, String arg1, String arg2, String arg3)` Redis command LMOVE.
    `Single<Response>` | `rxLmpop(List<String> args)` Redis command LMPOP.
    `Single<Response>` | `rxLolwut(List<String> args)` Redis command LOLWUT.
    `Single<Response>` | `rxLpop(List<String> args)` Redis command LPOP.
    `Single<Response>` | `rxLpos(List<String> args)` Redis command LPOS.
    `Single<Response>` | `rxLpush(List<String> args)` Redis command LPUSH.
    `Single<Response>` | `rxLpushx(List<String> args)` Redis command LPUSHX.
    `Single<Response>` | `rxLrange(String arg0, String arg1, String arg2)` Redis command LRANGE.
    `Single<Response>` | `rxLrem(String arg0, String arg1, String arg2)` Redis command LREM.
    `Single<Response>` | `rxLset(String arg0, String arg1, String arg2)` Redis command LSET.
    `Single<Response>` | `rxLtrim(String arg0, String arg1, String arg2)` Redis command LTRIM.
    `Single<Response>` | `rxMemory(List<String> args)` Redis command MEMORY.
    `Single<Response>` | `rxMget(List<String> args)` Redis command MGET.
    `Single<Response>` | `rxMigrate(List<String> args)` Redis command MIGRATE.
    `Single<Response>` | `rxModule(List<String> args)` Redis command MODULE.
    `Single<Response>` | `rxMonitor()` Redis command MONITOR.
    `Single<Response>` | `rxMove(String arg0, String arg1)` Redis command MOVE.
    `Single<Response>` | `rxMset(List<String> args)` Redis command MSET.
    `Single<Response>` | `rxMsetnx(List<String> args)` Redis command MSETNX.
    `Single<Response>` | `rxMulti()` Redis command MULTI.
    `Single<Response>` | `rxObject(List<String> args)` Redis command OBJECT.
    `Single<Response>` | `rxPersist(String arg0)` Redis command PERSIST.
    `Single<Response>` | `rxPexpire(List<String> args)` Redis command PEXPIRE.
    `Single<Response>` | `rxPexpireat(List<String> args)` Redis command PEXPIREAT.
    `Single<Response>` | `rxPexpiretime(String arg0)` Redis command PEXPIRETIME.
    `Single<Response>` | `rxPfadd(List<String> args)` Redis command PFADD.
    `Single<Response>` | `rxPfcount(List<String> args)` Redis command PFCOUNT.
    `Single<Response>` | `rxPfdebug(String arg0, String arg1)` Redis command PFDEBUG.
    `Single<Response>` | `rxPfmerge(List<String> args)` Redis command PFMERGE.
    `Single<Response>` | `rxPfselftest()` Redis command PFSELFTEST.
    `Single<Response>` | `rxPing(List<String> args)` Redis command PING.
    `Single<Response>` | `rxPsetex(String arg0, String arg1, String arg2)` Redis command PSETEX.
    `Single<Response>` | `rxPsubscribe(List<String> args)` Redis command PSUBSCRIBE.
    `Single<Response>` | `rxPsync(List<String> args)` Redis command PSYNC.
    `Single<Response>` | `rxPttl(String arg0)` Redis command PTTL.
    `Single<Response>` | `rxPublish(String arg0, String arg1)` Redis command PUBLISH.
    `Single<Response>` | `rxPubsub(List<String> args)` Redis command PUBSUB.
    `Single<Response>` | `rxPunsubscribe(List<String> args)` Redis command PUNSUBSCRIBE.
    `Single<Response>` | `rxQuit(List<String> args)` Redis command QUIT.
    `Single<Response>` | `rxRandomkey()` Redis command RANDOMKEY.
    `Single<Response>` | `rxReadonly()` Redis command READONLY.
    `Single<Response>` | `rxReadwrite()` Redis command READWRITE.
    `Single<Response>` | `rxRename(String arg0, String arg1)` Redis command RENAME.
    `Single<Response>` | `rxRenamenx(String arg0, String arg1)` Redis command RENAMENX.
    `Single<Response>` | `rxReplconf(List<String> args)` Redis command REPLCONF.
    `Single<Response>` | `rxReplicaof(String arg0, String arg1)` Redis command REPLICAOF.
    `Single<Response>` | `rxReset()` Redis command RESET.
    `Single<Response>` | `rxRestore(List<String> args)` Redis command RESTORE.
    `Single<Response>` | `rxRestoreAsking(List<String> args)` Redis command RESTORE-ASKING.
    `Single<Response>` | `rxRole()` Redis command ROLE.
    `Single<Response>` | `rxRpop(List<String> args)` Redis command RPOP.
    `Single<Response>` | `rxRpoplpush(String arg0, String arg1)` Redis command RPOPLPUSH.
    `Single<Response>` | `rxRpush(List<String> args)` Redis command RPUSH.
    `Single<Response>` | `rxRpushx(List<String> args)` Redis command RPUSHX.
    `Single<Response>` | `rxSadd(List<String> args)` Redis command SADD.
    `Single<Response>` | `rxSave()` Redis command SAVE.
    `Single<Response>` | `rxScan(List<String> args)` Redis command SCAN.
    `Single<Response>` | `rxScard(String arg0)` Redis command SCARD.
    `Single<Response>` | `rxScript(List<String> args)` Redis command SCRIPT.
    `Single<Response>` | `rxSdiff(List<String> args)` Redis command SDIFF.
    `Single<Response>` | `rxSdiffstore(List<String> args)` Redis command SDIFFSTORE.
    `Single<Response>` | `rxSelect(String arg0)` Redis command SELECT.
    `Single<Response>` | `rxSet(List<String> args)` Redis command SET.
    `Single<Response>` | `rxSetbit(String arg0, String arg1, String arg2)` Redis command SETBIT.
    `Single<Response>` | `rxSetex(String arg0, String arg1, String arg2)` Redis command SETEX.
    `Single<Response>` | `rxSetnx(String arg0, String arg1)` Redis command SETNX.
    `Single<Response>` | `rxSetrange(String arg0, String arg1, String arg2)` Redis command SETRANGE.
    `Single<Response>` | `rxShutdown(List<String> args)` Redis command SHUTDOWN.
    `Single<Response>` | `rxSinter(List<String> args)` Redis command SINTER.
    `Single<Response>` | `rxSintercard(List<String> args)` Redis command SINTERCARD.
    `Single<Response>` | `rxSinterstore(List<String> args)` Redis command SINTERSTORE.
    `Single<Response>` | `rxSismember(String arg0, String arg1)` Redis command SISMEMBER.
    `Single<Response>` | `rxSlaveof(String arg0, String arg1)` Redis command SLAVEOF.
    `Single<Response>` | `rxSlowlog(List<String> args)` Redis command SLOWLOG.
    `Single<Response>` | `rxSmembers(String arg0)` Redis command SMEMBERS.
    `Single<Response>` | `rxSmismember(List<String> args)` Redis command SMISMEMBER.
    `Single<Response>` | `rxSmove(String arg0, String arg1, String arg2)` Redis command SMOVE.
    `Single<Response>` | `rxSort(List<String> args)` Redis command SORT.
    `Single<Response>` | `rxSortRo(List<String> args)` Redis command SORT_RO.
    `Single<Response>` | `rxSpop(List<String> args)` Redis command SPOP.
    `Single<Response>` | `rxSpublish(String arg0, String arg1)` Redis command SPUBLISH.
    `Single<Response>` | `rxSrandmember(List<String> args)` Redis command SRANDMEMBER.
    `Single<Response>` | `rxSrem(List<String> args)` Redis command SREM.
    `Single<Response>` | `rxSscan(List<String> args)` Redis command SSCAN.
    `Single<Response>` | `rxSsubscribe(List<String> args)` Redis command SSUBSCRIBE.
    `Single<Response>` | `rxStrlen(String arg0)` Redis command STRLEN.
    `Single<Response>` | `rxSubscribe(List<String> args)` Redis command SUBSCRIBE.
    `Single<Response>` | `rxSubstr(String arg0, String arg1, String arg2)` Redis command SUBSTR.
    `Single<Response>` | `rxSunion(List<String> args)` Redis command SUNION.
    `Single<Response>` | `rxSunionstore(List<String> args)` Redis command SUNIONSTORE.
    `Single<Response>` | `rxSunsubscribe(List<String> args)` Redis command SUNSUBSCRIBE.
    `Single<Response>` | `rxSwapdb(String arg0, String arg1)` Redis command SWAPDB.
    `Single<Response>` | `rxSync()` Redis command SYNC.
    `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()` Redis command 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)` Redis command TOUCH.
    `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)` Redis command TTL.
    `Single<Response>` | `rxType(String arg0)` Redis command TYPE.
    `Single<Response>` | `rxUnlink(List<String> args)` Redis command UNLINK.
    `Single<Response>` | `rxUnsubscribe(List<String> args)` Redis command UNSUBSCRIBE.
    `Single<Response>` | `rxUnwatch()` Redis command UNWATCH.
    `Single<Response>` | `rxWait(String arg0, String arg1)` Redis command WAIT.
    `Single<Response>` | `rxWatch(List<String> args)` Redis command WATCH.
    `Single<Response>` | `rxXack(List<String> args)` Redis command XACK.
    `Single<Response>` | `rxXadd(List<String> args)` Redis command XADD.
    `Single<Response>` | `rxXautoclaim(List<String> args)` Redis command XAUTOCLAIM.
    `Single<Response>` | `rxXclaim(List<String> args)` Redis command XCLAIM.
    `Single<Response>` | `rxXdel(List<String> args)` Redis command XDEL.
    `Single<Response>` | `rxXgroup(List<String> args)` Redis command XGROUP.
    `Single<Response>` | `rxXinfo(List<String> args)` Redis command XINFO.
    `Single<Response>` | `rxXlen(String arg0)` Redis command XLEN.
    `Single<Response>` | `rxXpending(List<String> args)` Redis command XPENDING.
    `Single<Response>` | `rxXrange(List<String> args)` Redis command XRANGE.
    `Single<Response>` | `rxXread(List<String> args)` Redis command XREAD.
    `Single<Response>` | `rxXreadgroup(List<String> args)` Redis command XREADGROUP.
    `Single<Response>` | `rxXrevrange(List<String> args)` Redis command XREVRANGE.
    `Single<Response>` | `rxXsetid(List<String> args)` Redis command XSETID.
    `Single<Response>` | `rxXtrim(List<String> args)` Redis command XTRIM.
    `Single<Response>` | `rxZadd(List<String> args)` Redis command ZADD.
    `Single<Response>` | `rxZcard(String arg0)` Redis command ZCARD.
    `Single<Response>` | `rxZcount(String arg0, String arg1, String arg2)` Redis command ZCOUNT.
    `Single<Response>` | `rxZdiff(List<String> args)` Redis command ZDIFF.
    `Single<Response>` | `rxZdiffstore(List<String> args)` Redis command ZDIFFSTORE.
    `Single<Response>` | `rxZincrby(String arg0, String arg1, String arg2)` Redis command ZINCRBY.
    `Single<Response>` | `rxZinter(List<String> args)` Redis command ZINTER.
    `Single<Response>` | `rxZintercard(List<String> args)` Redis command ZINTERCARD.
    `Single<Response>` | `rxZinterstore(List<String> args)` Redis command ZINTERSTORE.
    `Single<Response>` | `rxZlexcount(String arg0, String arg1, String arg2)` Redis command ZLEXCOUNT.
    `Single<Response>` | `rxZmpop(List<String> args)` Redis command ZMPOP.
    `Single<Response>` | `rxZmscore(List<String> args)` Redis command ZMSCORE.
    `Single<Response>` | `rxZpopmax(List<String> args)` Redis command ZPOPMAX.
    `Single<Response>` | `rxZpopmin(List<String> args)` Redis command ZPOPMIN.
    `Single<Response>` | `rxZrandmember(List<String> args)` Redis command ZRANDMEMBER.
    `Single<Response>` | `rxZrange(List<String> args)` Redis command ZRANGE.
    `Single<Response>` | `rxZrangebylex(List<String> args)` Redis command ZRANGEBYLEX.
    `Single<Response>` | `rxZrangebyscore(List<String> args)` Redis command ZRANGEBYSCORE.
    `Single<Response>` | `rxZrangestore(List<String> args)` Redis command ZRANGESTORE.
    `Single<Response>` | `rxZrank(String arg0, String arg1)` Redis command ZRANK.
    `Single<Response>` | `rxZrem(List<String> args)` Redis command ZREM.
    `Single<Response>` | `rxZremrangebylex(String arg0, String arg1, String arg2)` Redis command ZREMRANGEBYLEX.
    `Single<Response>` | `rxZremrangebyrank(String arg0, String arg1, String arg2)` Redis command ZREMRANGEBYRANK.
    `Single<Response>` | `rxZremrangebyscore(String arg0, String arg1, String arg2)` Redis command ZREMRANGEBYSCORE.
    `Single<Response>` | `rxZrevrange(List<String> args)` Redis command ZREVRANGE.
    `Single<Response>` | `rxZrevrangebylex(List<String> args)` Redis command ZREVRANGEBYLEX.
    `Single<Response>` | `rxZrevrangebyscore(List<String> args)` Redis command ZREVRANGEBYSCORE.
    `Single<Response>` | `rxZrevrank(String arg0, String arg1)` Redis command ZREVRANK.
    `Single<Response>` | `rxZscan(List<String> args)` Redis command ZSCAN.
    `Single<Response>` | `rxZscore(String arg0, String arg1)` Redis command ZSCORE.
    `Single<Response>` | `rxZunion(List<String> args)` Redis command ZUNION.
    `Single<Response>` | `rxZunionstore(List<String> args)` Redis command ZUNIONSTORE.
    `RedisAPI` | `sadd(List<String> args)` Redis command SADD.
    `RedisAPI` | `sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SADD.
    `RedisAPI` | `save()` Redis command SAVE.
    `RedisAPI` | `save(Handler<AsyncResult<Response>> handler)` Redis command SAVE.
    `RedisAPI` | `scan(List<String> args)` Redis command SCAN.
    `RedisAPI` | `scan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SCAN.
    `RedisAPI` | `scard(String arg0)` Redis command SCARD.
    `RedisAPI` | `scard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SCARD.
    `RedisAPI` | `script(List<String> args)` Redis command SCRIPT.
    `RedisAPI` | `script(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SCRIPT.
    `RedisAPI` | `sdiff(List<String> args)` Redis command SDIFF.
    `RedisAPI` | `sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SDIFF.
    `RedisAPI` | `sdiffstore(List<String> args)` Redis command SDIFFSTORE.
    `RedisAPI` | `sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SDIFFSTORE.
    `RedisAPI` | `select(String arg0)` Redis command SELECT.
    `RedisAPI` | `select(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SELECT.
    `RedisAPI` | `set(List<String> args)` Redis command SET.
    `RedisAPI` | `set(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SET.
    `RedisAPI` | `setbit(String arg0, String arg1, String arg2)` Redis command SETBIT.
    `RedisAPI` | `setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETBIT.
    `RedisAPI` | `setex(String arg0, String arg1, String arg2)` Redis command SETEX.
    `RedisAPI` | `setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETEX.
    `RedisAPI` | `setnx(String arg0, String arg1)` Redis command SETNX.
    `RedisAPI` | `setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SETNX.
    `RedisAPI` | `setrange(String arg0, String arg1, String arg2)` Redis command SETRANGE.
    `RedisAPI` | `setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SETRANGE.
    `RedisAPI` | `shutdown(List<String> args)` Redis command SHUTDOWN.
    `RedisAPI` | `shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SHUTDOWN.
    `RedisAPI` | `sinter(List<String> args)` Redis command SINTER.
    `RedisAPI` | `sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTER.
    `RedisAPI` | `sintercard(List<String> args)` Redis command SINTERCARD.
    `RedisAPI` | `sintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTERCARD.
    `RedisAPI` | `sinterstore(List<String> args)` Redis command SINTERSTORE.
    `RedisAPI` | `sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SINTERSTORE.
    `RedisAPI` | `sismember(String arg0, String arg1)` Redis command SISMEMBER.
    `RedisAPI` | `sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SISMEMBER.
    `RedisAPI` | `slaveof(String arg0, String arg1)` Redis command SLAVEOF.
    `RedisAPI` | `slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SLAVEOF.
    `RedisAPI` | `slowlog(List<String> args)` Redis command SLOWLOG.
    `RedisAPI` | `slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SLOWLOG.
    `RedisAPI` | `smembers(String arg0)` Redis command SMEMBERS.
    `RedisAPI` | `smembers(String arg0, Handler<AsyncResult<Response>> handler)` Redis command SMEMBERS.
    `RedisAPI` | `smismember(List<String> args)` Redis command SMISMEMBER.
    `RedisAPI` | `smismember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SMISMEMBER.
    `RedisAPI` | `smove(String arg0, String arg1, String arg2)` Redis command SMOVE.
    `RedisAPI` | `smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SMOVE.
    `RedisAPI` | `sort(List<String> args)` Redis command SORT.
    `RedisAPI` | `sort(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SORT.
    `RedisAPI` | `sortRo(List<String> args)` Redis command SORT_RO.
    `RedisAPI` | `sortRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SORT_RO.
    `RedisAPI` | `spop(List<String> args)` Redis command SPOP.
    `RedisAPI` | `spop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SPOP.
    `RedisAPI` | `spublish(String arg0, String arg1)` Redis command SPUBLISH.
    `RedisAPI` | `spublish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SPUBLISH.
    `RedisAPI` | `srandmember(List<String> args)` Redis command SRANDMEMBER.
    `RedisAPI` | `srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SRANDMEMBER.
    `RedisAPI` | `srem(List<String> args)` Redis command SREM.
    `RedisAPI` | `srem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SREM.
    `RedisAPI` | `sscan(List<String> args)` Redis command SSCAN.
    `RedisAPI` | `sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SSCAN.
    `RedisAPI` | `ssubscribe(List<String> args)` Redis command SSUBSCRIBE.
    `RedisAPI` | `ssubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SSUBSCRIBE.
    `RedisAPI` | `strlen(String arg0)` Redis command STRLEN.
    `RedisAPI` | `strlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command STRLEN.
    `RedisAPI` | `subscribe(List<String> args)` Redis command SUBSCRIBE.
    `RedisAPI` | `subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUBSCRIBE.
    `RedisAPI` | `substr(String arg0, String arg1, String arg2)` Redis command SUBSTR.
    `RedisAPI` | `substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command SUBSTR.
    `RedisAPI` | `sunion(List<String> args)` Redis command SUNION.
    `RedisAPI` | `sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNION.
    `RedisAPI` | `sunionstore(List<String> args)` Redis command SUNIONSTORE.
    `RedisAPI` | `sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNIONSTORE.
    `RedisAPI` | `sunsubscribe(List<String> args)` Redis command SUNSUBSCRIBE.
    `RedisAPI` | `sunsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command SUNSUBSCRIBE.
    `RedisAPI` | `swapdb(String arg0, String arg1)` Redis command SWAPDB.
    `RedisAPI` | `swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command SWAPDB.
    `RedisAPI` | `sync()` Redis command SYNC.
    `RedisAPI` | `sync(Handler<AsyncResult<Response>> handler)` Redis command SYNC.
    `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()` Redis command TIME.
    `RedisAPI` | `time(Handler<AsyncResult<Response>> handler)` Redis command 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)` Redis command TOUCH.
    `RedisAPI` | `touch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command TOUCH.
    `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)` Redis command TTL.
    `RedisAPI` | `ttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command TTL.
    `RedisAPI` | `type(String arg0)` Redis command TYPE.
    `RedisAPI` | `type(String arg0, Handler<AsyncResult<Response>> handler)` Redis command TYPE.
    `RedisAPI` | `unlink(List<String> args)` Redis command UNLINK.
    `RedisAPI` | `unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command UNLINK.
    `RedisAPI` | `unsubscribe(List<String> args)` Redis command UNSUBSCRIBE.
    `RedisAPI` | `unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command UNSUBSCRIBE.
    `RedisAPI` | `unwatch()` Redis command UNWATCH.
    `RedisAPI` | `unwatch(Handler<AsyncResult<Response>> handler)` Redis command UNWATCH.
    `RedisAPI` | `wait(String arg0, String arg1)` Redis command WAIT.
    `RedisAPI` | `wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command WAIT.
    `RedisAPI` | `watch(List<String> args)` Redis command WATCH.
    `RedisAPI` | `watch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command WATCH.
    `RedisAPI` | `xack(List<String> args)` Redis command XACK.
    `RedisAPI` | `xack(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XACK.
    `RedisAPI` | `xadd(List<String> args)` Redis command XADD.
    `RedisAPI` | `xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XADD.
    `RedisAPI` | `xautoclaim(List<String> args)` Redis command XAUTOCLAIM.
    `RedisAPI` | `xautoclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XAUTOCLAIM.
    `RedisAPI` | `xclaim(List<String> args)` Redis command XCLAIM.
    `RedisAPI` | `xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XCLAIM.
    `RedisAPI` | `xdel(List<String> args)` Redis command XDEL.
    `RedisAPI` | `xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XDEL.
    `RedisAPI` | `xgroup(List<String> args)` Redis command XGROUP.
    `RedisAPI` | `xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XGROUP.
    `RedisAPI` | `xinfo(List<String> args)` Redis command XINFO.
    `RedisAPI` | `xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XINFO.
    `RedisAPI` | `xlen(String arg0)` Redis command XLEN.
    `RedisAPI` | `xlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command XLEN.
    `RedisAPI` | `xpending(List<String> args)` Redis command XPENDING.
    `RedisAPI` | `xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XPENDING.
    `RedisAPI` | `xrange(List<String> args)` Redis command XRANGE.
    `RedisAPI` | `xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XRANGE.
    `RedisAPI` | `xread(List<String> args)` Redis command XREAD.
    `RedisAPI` | `xread(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREAD.
    `RedisAPI` | `xreadgroup(List<String> args)` Redis command XREADGROUP.
    `RedisAPI` | `xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREADGROUP.
    `RedisAPI` | `xrevrange(List<String> args)` Redis command XREVRANGE.
    `RedisAPI` | `xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XREVRANGE.
    `RedisAPI` | `xsetid(List<String> args)` Redis command XSETID.
    `RedisAPI` | `xsetid(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XSETID.
    `RedisAPI` | `xtrim(List<String> args)` Redis command XTRIM.
    `RedisAPI` | `xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command XTRIM.
    `RedisAPI` | `zadd(List<String> args)` Redis command ZADD.
    `RedisAPI` | `zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZADD.
    `RedisAPI` | `zcard(String arg0)` Redis command ZCARD.
    `RedisAPI` | `zcard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ZCARD.
    `RedisAPI` | `zcount(String arg0, String arg1, String arg2)` Redis command ZCOUNT.
    `RedisAPI` | `zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZCOUNT.
    `RedisAPI` | `zdiff(List<String> args)` Redis command ZDIFF.
    `RedisAPI` | `zdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZDIFF.
    `RedisAPI` | `zdiffstore(List<String> args)` Redis command ZDIFFSTORE.
    `RedisAPI` | `zdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZDIFFSTORE.
    `RedisAPI` | `zincrby(String arg0, String arg1, String arg2)` Redis command ZINCRBY.
    `RedisAPI` | `zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZINCRBY.
    `RedisAPI` | `zinter(List<String> args)` Redis command ZINTER.
    `RedisAPI` | `zinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTER.
    `RedisAPI` | `zintercard(List<String> args)` Redis command ZINTERCARD.
    `RedisAPI` | `zintercard(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTERCARD.
    `RedisAPI` | `zinterstore(List<String> args)` Redis command ZINTERSTORE.
    `RedisAPI` | `zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZINTERSTORE.
    `RedisAPI` | `zlexcount(String arg0, String arg1, String arg2)` Redis command ZLEXCOUNT.
    `RedisAPI` | `zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZLEXCOUNT.
    `RedisAPI` | `zmpop(List<String> args)` Redis command ZMPOP.
    `RedisAPI` | `zmpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZMPOP.
    `RedisAPI` | `zmscore(List<String> args)` Redis command ZMSCORE.
    `RedisAPI` | `zmscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZMSCORE.
    `RedisAPI` | `zpopmax(List<String> args)` Redis command ZPOPMAX.
    `RedisAPI` | `zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZPOPMAX.
    `RedisAPI` | `zpopmin(List<String> args)` Redis command ZPOPMIN.
    `RedisAPI` | `zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZPOPMIN.
    `RedisAPI` | `zrandmember(List<String> args)` Redis command ZRANDMEMBER.
    `RedisAPI` | `zrandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANDMEMBER.
    `RedisAPI` | `zrange(List<String> args)` Redis command ZRANGE.
    `RedisAPI` | `zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGE.
    `RedisAPI` | `zrangebylex(List<String> args)` Redis command ZRANGEBYLEX.
    `RedisAPI` | `zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGEBYLEX.
    `RedisAPI` | `zrangebyscore(List<String> args)` Redis command ZRANGEBYSCORE.
    `RedisAPI` | `zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGEBYSCORE.
    `RedisAPI` | `zrangestore(List<String> args)` Redis command ZRANGESTORE.
    `RedisAPI` | `zrangestore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZRANGESTORE.
    `RedisAPI` | `zrank(String arg0, String arg1)` Redis command ZRANK.
    `RedisAPI` | `zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZRANK.
    `RedisAPI` | `zrem(List<String> args)` Redis command ZREM.
    `RedisAPI` | `zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREM.
    `RedisAPI` | `zremrangebylex(String arg0, String arg1, String arg2)` Redis command ZREMRANGEBYLEX.
    `RedisAPI` | `zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYLEX.
    `RedisAPI` | `zremrangebyrank(String arg0, String arg1, String arg2)` Redis command ZREMRANGEBYRANK.
    `RedisAPI` | `zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYRANK.
    `RedisAPI` | `zremrangebyscore(String arg0, String arg1, String arg2)` Redis command ZREMRANGEBYSCORE.
    `RedisAPI` | `zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ZREMRANGEBYSCORE.
    `RedisAPI` | `zrevrange(List<String> args)` Redis command ZREVRANGE.
    `RedisAPI` | `zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGE.
    `RedisAPI` | `zrevrangebylex(List<String> args)` Redis command ZREVRANGEBYLEX.
    `RedisAPI` | `zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGEBYLEX.
    `RedisAPI` | `zrevrangebyscore(List<String> args)` Redis command ZREVRANGEBYSCORE.
    `RedisAPI` | `zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANGEBYSCORE.
    `RedisAPI` | `zrevrank(String arg0, String arg1)` Redis command ZREVRANK.
    `RedisAPI` | `zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZREVRANK.
    `RedisAPI` | `zscan(List<String> args)` Redis command ZSCAN.
    `RedisAPI` | `zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZSCAN.
    `RedisAPI` | `zscore(String arg0, String arg1)` Redis command ZSCORE.
    `RedisAPI` | `zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command ZSCORE.
    `RedisAPI` | `zunion(List<String> args)` Redis command ZUNION.
    `RedisAPI` | `zunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZUNION.
    `RedisAPI` | `zunionstore(List<String> args)` Redis command ZUNIONSTORE.
    `RedisAPI` | `zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ZUNIONSTORE.

    - ### 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()

    - #### 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)

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

    - #### acl

          public RedisAPI acl(List<String> args)

      Redis command ACL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxAcl

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

      Redis command ACL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### append

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

      Redis command APPEND.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### append

          public RedisAPI append(String arg0,
                                 String arg1)

      Redis command APPEND.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxAppend

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

      Redis command APPEND.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### asking

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

      Redis command ASKING.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### asking

          public RedisAPI asking()

      Redis command ASKING.
      Returns:
        fluent self

    - #### rxAsking

          public Single<Response> rxAsking()

      Redis command ASKING.
      Returns:
        fluent self

    - #### auth

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

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

    - #### auth

          public RedisAPI auth(List<String> args)

      Redis command AUTH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxAuth

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

      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)

      Redis command BGREWRITEAOF.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### bgrewriteaof

          public RedisAPI bgrewriteaof()

      Redis command BGREWRITEAOF.
      Returns:
        fluent self

    - #### rxBgrewriteaof

          public Single<Response> rxBgrewriteaof()

      Redis command BGREWRITEAOF.
      Returns:
        fluent self

    - #### bgsave

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

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

    - #### bgsave

          public RedisAPI bgsave(List<String> args)

      Redis command BGSAVE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBgsave

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

      Redis command BGSAVE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitcount

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

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

    - #### bitcount

          public RedisAPI bitcount(List<String> args)

      Redis command BITCOUNT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitcount

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

      Redis command BITCOUNT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitfield

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

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

    - #### bitfield

          public RedisAPI bitfield(List<String> args)

      Redis command BITFIELD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitfield

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

      Redis command BITFIELD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitfieldRo

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

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

    - #### bitfieldRo

          public RedisAPI bitfieldRo(List<String> args)

      Redis command BITFIELD_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitfieldRo

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

      Redis command BITFIELD_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitop

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

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

    - #### bitop

          public RedisAPI bitop(List<String> args)

      Redis command BITOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitop

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

      Redis command BITOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitpos

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

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

    - #### bitpos

          public RedisAPI bitpos(List<String> args)

      Redis command BITPOS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitpos

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

      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)

      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)

      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)

      Redis command BLMOVE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
        `arg4` -
      Returns:
        fluent self

    - #### blmpop

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

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

    - #### blmpop

          public RedisAPI blmpop(List<String> args)

      Redis command BLMPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBlmpop

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

      Redis command BLMPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### blpop

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

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

    - #### blpop

          public RedisAPI blpop(List<String> args)

      Redis command BLPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBlpop

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

      Redis command BLPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### brpop

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

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

    - #### brpop

          public RedisAPI brpop(List<String> args)

      Redis command BRPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBrpop

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

      Redis command BRPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### brpoplpush

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

      Redis command BRPOPLPUSH.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### brpoplpush

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

      Redis command BRPOPLPUSH.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxBrpoplpush

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

      Redis command BRPOPLPUSH.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### bzmpop

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

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

    - #### bzmpop

          public RedisAPI bzmpop(List<String> args)

      Redis command BZMPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBzmpop

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

      Redis command BZMPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bzpopmax

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

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

    - #### bzpopmax

          public RedisAPI bzpopmax(List<String> args)

      Redis command BZPOPMAX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBzpopmax

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

      Redis command BZPOPMAX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bzpopmin

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

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

    - #### bzpopmin

          public RedisAPI bzpopmin(List<String> args)

      Redis command BZPOPMIN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBzpopmin

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

      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)

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

    - #### client

          public RedisAPI client(List<String> args)

      Redis command CLIENT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxClient

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

      Redis command CLIENT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cluster

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

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

    - #### cluster

          public RedisAPI cluster(List<String> args)

      Redis command CLUSTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCluster

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

      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)

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

    - #### command

          public RedisAPI command(List<String> args)

      Redis command COMMAND.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCommand

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

      Redis command COMMAND.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### config

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

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

    - #### config

          public RedisAPI config(List<String> args)

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

    - #### rxConfig

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

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

    - #### copy

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

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

    - #### copy

          public RedisAPI copy(List<String> args)

      Redis command COPY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCopy

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

      Redis command COPY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### dbsize

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

      Redis command DBSIZE.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### dbsize

          public RedisAPI dbsize()

      Redis command DBSIZE.
      Returns:
        fluent self

    - #### rxDbsize

          public Single<Response> rxDbsize()

      Redis command DBSIZE.
      Returns:
        fluent self

    - #### debug

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

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

    - #### debug

          public RedisAPI debug(List<String> args)

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

    - #### rxDebug

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

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

    - #### decr

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

      Redis command DECR.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### decr

          public RedisAPI decr(String arg0)

      Redis command DECR.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxDecr

          public Single<Response> rxDecr(String arg0)

      Redis command DECR.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### decrby

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

      Redis command DECRBY.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### decrby

          public RedisAPI decrby(String arg0,
                                 String arg1)

      Redis command DECRBY.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxDecrby

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

      Redis command DECRBY.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### del

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

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

    - #### del

          public RedisAPI del(List<String> args)

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

    - #### rxDel

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

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

    - #### discard

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

      Redis command DISCARD.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### discard

          public RedisAPI discard()

      Redis command DISCARD.
      Returns:
        fluent self

    - #### rxDiscard

          public Single<Response> rxDiscard()

      Redis command DISCARD.
      Returns:
        fluent self

    - #### dump

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

      Redis command DUMP.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### dump

          public RedisAPI dump(String arg0)

      Redis command DUMP.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxDump

          public Single<Response> rxDump(String arg0)

      Redis command DUMP.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### echo

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

      Redis command ECHO.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### echo

          public RedisAPI echo(String arg0)

      Redis command ECHO.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxEcho

          public Single<Response> rxEcho(String arg0)

      Redis command ECHO.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### eval

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

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

    - #### eval

          public RedisAPI eval(List<String> args)

      Redis command EVAL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxEval

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

      Redis command EVAL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### evalRo

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

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

    - #### evalRo

          public RedisAPI evalRo(List<String> args)

      Redis command EVAL_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxEvalRo

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

      Redis command EVAL_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### evalsha

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

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

    - #### evalsha

          public RedisAPI evalsha(List<String> args)

      Redis command EVALSHA.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxEvalsha

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

      Redis command EVALSHA.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### evalshaRo

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

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

    - #### evalshaRo

          public RedisAPI evalshaRo(List<String> args)

      Redis command EVALSHA_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxEvalshaRo

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

      Redis command EVALSHA_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### exec

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

      Redis command EXEC.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### exec

          public RedisAPI exec()

      Redis command EXEC.
      Returns:
        fluent self

    - #### rxExec

          public Single<Response> rxExec()

      Redis command EXEC.
      Returns:
        fluent self

    - #### exists

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

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

    - #### exists

          public RedisAPI exists(List<String> args)

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

    - #### rxExists

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

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

    - #### expire

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

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

    - #### expire

          public RedisAPI expire(List<String> args)

      Redis command EXPIRE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxExpire

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

      Redis command EXPIRE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### expireat

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

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

    - #### expireat

          public RedisAPI expireat(List<String> args)

      Redis command EXPIREAT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxExpireat

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

      Redis command EXPIREAT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### expiretime

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

      Redis command EXPIRETIME.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### expiretime

          public RedisAPI expiretime(String arg0)

      Redis command EXPIRETIME.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxExpiretime

          public Single<Response> rxExpiretime(String arg0)

      Redis command EXPIRETIME.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### failover

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

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

    - #### failover

          public RedisAPI failover(List<String> args)

      Redis command FAILOVER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFailover

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

      Redis command FAILOVER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### fcall

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

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

    - #### fcall

          public RedisAPI fcall(List<String> args)

      Redis command FCALL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFcall

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

      Redis command FCALL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### fcallRo

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

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

    - #### fcallRo

          public RedisAPI fcallRo(List<String> args)

      Redis command FCALL_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFcallRo

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

      Redis command FCALL_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### flushall

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

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

    - #### flushall

          public RedisAPI flushall(List<String> args)

      Redis command FLUSHALL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFlushall

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

      Redis command FLUSHALL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### flushdb

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

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

    - #### flushdb

          public RedisAPI flushdb(List<String> args)

      Redis command FLUSHDB.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFlushdb

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

      Redis command FLUSHDB.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### function

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

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

    - #### function

          public RedisAPI function(List<String> args)

      Redis command FUNCTION.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFunction

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

      Redis command FUNCTION.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geoadd

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

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

    - #### geoadd

          public RedisAPI geoadd(List<String> args)

      Redis command GEOADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoadd

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

      Redis command GEOADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geodist

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

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

    - #### geodist

          public RedisAPI geodist(List<String> args)

      Redis command GEODIST.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeodist

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

      Redis command GEODIST.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geohash

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

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

    - #### geohash

          public RedisAPI geohash(List<String> args)

      Redis command GEOHASH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeohash

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

      Redis command GEOHASH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geopos

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

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

    - #### geopos

          public RedisAPI geopos(List<String> args)

      Redis command GEOPOS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeopos

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

      Redis command GEOPOS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadius

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

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

    - #### georadius

          public RedisAPI georadius(List<String> args)

      Redis command GEORADIUS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradius

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

      Redis command GEORADIUS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadiusRo

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

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

    - #### georadiusRo

          public RedisAPI georadiusRo(List<String> args)

      Redis command GEORADIUS_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradiusRo

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

      Redis command GEORADIUS_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadiusbymember

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

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

    - #### georadiusbymember

          public RedisAPI georadiusbymember(List<String> args)

      Redis command GEORADIUSBYMEMBER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradiusbymember

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

      Redis command GEORADIUSBYMEMBER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadiusbymemberRo

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

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

    - #### georadiusbymemberRo

          public RedisAPI georadiusbymemberRo(List<String> args)

      Redis command GEORADIUSBYMEMBER_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradiusbymemberRo

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

      Redis command GEORADIUSBYMEMBER_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geosearch

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

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

    - #### geosearch

          public RedisAPI geosearch(List<String> args)

      Redis command GEOSEARCH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeosearch

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

      Redis command GEOSEARCH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geosearchstore

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

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

    - #### geosearchstore

          public RedisAPI geosearchstore(List<String> args)

      Redis command GEOSEARCHSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeosearchstore

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

      Redis command GEOSEARCHSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### get

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

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

    - #### get

          public RedisAPI get(String arg0)

      Redis command GET.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxGet

          public Single<Response> rxGet(String arg0)

      Redis command GET.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### getbit

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

      Redis command GETBIT.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### getbit

          public RedisAPI getbit(String arg0,
                                 String arg1)

      Redis command GETBIT.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxGetbit

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

      Redis command GETBIT.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### getdel

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

      Redis command GETDEL.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### getdel

          public RedisAPI getdel(String arg0)

      Redis command GETDEL.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxGetdel

          public Single<Response> rxGetdel(String arg0)

      Redis command GETDEL.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### getex

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

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

    - #### getex

          public RedisAPI getex(List<String> args)

      Redis command GETEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGetex

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

      Redis command GETEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### getrange

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

      Redis command GETRANGE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### getrange

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

      Redis command GETRANGE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxGetrange

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

      Redis command GETRANGE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### getset

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

      Redis command GETSET.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### getset

          public RedisAPI getset(String arg0,
                                 String arg1)

      Redis command GETSET.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxGetset

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

      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)

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

    - #### hdel

          public RedisAPI hdel(List<String> args)

      Redis command HDEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHdel

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

      Redis command HDEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hello

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

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

    - #### hello

          public RedisAPI hello(List<String> args)

      Redis command HELLO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHello

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

      Redis command HELLO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hexists

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

      Redis command HEXISTS.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### hexists

          public RedisAPI hexists(String arg0,
                                  String arg1)

      Redis command HEXISTS.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxHexists

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

      Redis command HEXISTS.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### hget

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

      Redis command HGET.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### hget

          public RedisAPI hget(String arg0,
                               String arg1)

      Redis command HGET.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxHget

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

      Redis command HGET.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### hgetall

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

      Redis command HGETALL.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hgetall

          public RedisAPI hgetall(String arg0)

      Redis command HGETALL.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHgetall

          public Single<Response> rxHgetall(String arg0)

      Redis command HGETALL.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### hincrby

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

      Redis command HINCRBY.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### hincrby

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

      Redis command HINCRBY.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxHincrby

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

      Redis command HINCRBY.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### hincrbyfloat

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

      Redis command HINCRBYFLOAT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### hincrbyfloat

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

      Redis command HINCRBYFLOAT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxHincrbyfloat

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

      Redis command HINCRBYFLOAT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### hkeys

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

      Redis command HKEYS.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hkeys

          public RedisAPI hkeys(String arg0)

      Redis command HKEYS.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHkeys

          public Single<Response> rxHkeys(String arg0)

      Redis command HKEYS.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### hlen

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

      Redis command HLEN.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hlen

          public RedisAPI hlen(String arg0)

      Redis command HLEN.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHlen

          public Single<Response> rxHlen(String arg0)

      Redis command HLEN.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### hmget

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

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

    - #### hmget

          public RedisAPI hmget(List<String> args)

      Redis command HMGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHmget

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

      Redis command HMGET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hmset

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

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

    - #### hmset

          public RedisAPI hmset(List<String> args)

      Redis command HMSET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHmset

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

      Redis command HMSET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hrandfield

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

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

    - #### hrandfield

          public RedisAPI hrandfield(List<String> args)

      Redis command HRANDFIELD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHrandfield

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

      Redis command HRANDFIELD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hscan

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

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

    - #### hscan

          public RedisAPI hscan(List<String> args)

      Redis command HSCAN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHscan

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

      Redis command HSCAN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hset

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

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

    - #### hset

          public RedisAPI hset(List<String> args)

      Redis command HSET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHset

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

      Redis command HSET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hsetnx

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

      Redis command HSETNX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### hsetnx

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

      Redis command HSETNX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxHsetnx

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

      Redis command HSETNX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### hstrlen

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

      Redis command HSTRLEN.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### hstrlen

          public RedisAPI hstrlen(String arg0,
                                  String arg1)

      Redis command HSTRLEN.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxHstrlen

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

      Redis command HSTRLEN.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### hvals

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

      Redis command HVALS.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hvals

          public RedisAPI hvals(String arg0)

      Redis command HVALS.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHvals

          public Single<Response> rxHvals(String arg0)

      Redis command HVALS.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### incr

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

      Redis command INCR.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### incr

          public RedisAPI incr(String arg0)

      Redis command INCR.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxIncr

          public Single<Response> rxIncr(String arg0)

      Redis command INCR.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### incrby

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

      Redis command INCRBY.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### incrby

          public RedisAPI incrby(String arg0,
                                 String arg1)

      Redis command INCRBY.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxIncrby

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

      Redis command INCRBY.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### incrbyfloat

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

      Redis command INCRBYFLOAT.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### incrbyfloat

          public RedisAPI incrbyfloat(String arg0,
                                      String arg1)

      Redis command INCRBYFLOAT.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxIncrbyfloat

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

      Redis command INCRBYFLOAT.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### info

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

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

    - #### info

          public RedisAPI info(List<String> args)

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

    - #### rxInfo

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

      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)

      Redis command KEYS.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### keys

          public RedisAPI keys(String arg0)

      Redis command KEYS.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxKeys

          public Single<Response> rxKeys(String arg0)

      Redis command KEYS.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### lastsave

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

      Redis command LASTSAVE.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### lastsave

          public RedisAPI lastsave()

      Redis command LASTSAVE.
      Returns:
        fluent self

    - #### rxLastsave

          public Single<Response> rxLastsave()

      Redis command LASTSAVE.
      Returns:
        fluent self

    - #### latency

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

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

    - #### latency

          public RedisAPI latency(List<String> args)

      Redis command LATENCY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLatency

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

      Redis command LATENCY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lcs

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

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

    - #### lcs

          public RedisAPI lcs(List<String> args)

      Redis command LCS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLcs

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

      Redis command LCS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lindex

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

      Redis command LINDEX.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### lindex

          public RedisAPI lindex(String arg0,
                                 String arg1)

      Redis command LINDEX.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxLindex

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

      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)

      Redis command LINSERT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
        `handler` -
      Returns:
        fluent self

    - #### linsert

          public RedisAPI linsert(String arg0,
                                  String arg1,
                                  String arg2,
                                  String arg3)

      Redis command LINSERT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
      Returns:
        fluent self

    - #### rxLinsert

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

      Redis command LINSERT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
      Returns:
        fluent self

    - #### llen

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

      Redis command LLEN.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### llen

          public RedisAPI llen(String arg0)

      Redis command LLEN.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxLlen

          public Single<Response> rxLlen(String arg0)

      Redis command LLEN.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### lmove

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

      Redis command LMOVE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
        `handler` -
      Returns:
        fluent self

    - #### lmove

          public RedisAPI lmove(String arg0,
                                String arg1,
                                String arg2,
                                String arg3)

      Redis command LMOVE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
      Returns:
        fluent self

    - #### rxLmove

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

      Redis command LMOVE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
      Returns:
        fluent self

    - #### lmpop

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

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

    - #### lmpop

          public RedisAPI lmpop(List<String> args)

      Redis command LMPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLmpop

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

      Redis command LMPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lolwut

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

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

    - #### lolwut

          public RedisAPI lolwut(List<String> args)

      Redis command LOLWUT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLolwut

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

      Redis command LOLWUT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lpop

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

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

    - #### lpop

          public RedisAPI lpop(List<String> args)

      Redis command LPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLpop

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

      Redis command LPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lpos

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

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

    - #### lpos

          public RedisAPI lpos(List<String> args)

      Redis command LPOS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLpos

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

      Redis command LPOS.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lpush

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

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

    - #### lpush

          public RedisAPI lpush(List<String> args)

      Redis command LPUSH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLpush

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

      Redis command LPUSH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lpushx

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

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

    - #### lpushx

          public RedisAPI lpushx(List<String> args)

      Redis command LPUSHX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLpushx

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

      Redis command LPUSHX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lrange

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

      Redis command LRANGE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### lrange

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

      Redis command LRANGE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLrange

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

      Redis command LRANGE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### lrem

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

      Redis command LREM.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### lrem

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

      Redis command LREM.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLrem

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

      Redis command LREM.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### lset

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

      Redis command LSET.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### lset

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

      Redis command LSET.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLset

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

      Redis command LSET.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### ltrim

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

      Redis command LTRIM.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### ltrim

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

      Redis command LTRIM.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLtrim

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

      Redis command LTRIM.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### memory

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

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

    - #### memory

          public RedisAPI memory(List<String> args)

      Redis command MEMORY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMemory

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

      Redis command MEMORY.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### mget

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

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

    - #### mget

          public RedisAPI mget(List<String> args)

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

    - #### rxMget

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

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

    - #### migrate

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

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

    - #### migrate

          public RedisAPI migrate(List<String> args)

      Redis command MIGRATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMigrate

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

      Redis command MIGRATE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### module

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

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

    - #### module

          public RedisAPI module(List<String> args)

      Redis command MODULE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxModule

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

      Redis command MODULE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### monitor

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

      Redis command MONITOR.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### monitor

          public RedisAPI monitor()

      Redis command MONITOR.
      Returns:
        fluent self

    - #### rxMonitor

          public Single<Response> rxMonitor()

      Redis command MONITOR.
      Returns:
        fluent self

    - #### move

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

      Redis command MOVE.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### move

          public RedisAPI move(String arg0,
                               String arg1)

      Redis command MOVE.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxMove

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

      Redis command MOVE.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### mset

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

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

    - #### mset

          public RedisAPI mset(List<String> args)

      Redis command MSET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMset

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

      Redis command MSET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### msetnx

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

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

    - #### msetnx

          public RedisAPI msetnx(List<String> args)

      Redis command MSETNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMsetnx

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

      Redis command MSETNX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### multi

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

      Redis command MULTI.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### multi

          public RedisAPI multi()

      Redis command MULTI.
      Returns:
        fluent self

    - #### rxMulti

          public Single<Response> rxMulti()

      Redis command MULTI.
      Returns:
        fluent self

    - #### object

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

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

    - #### object

          public RedisAPI object(List<String> args)

      Redis command OBJECT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxObject

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

      Redis command OBJECT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### persist

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

      Redis command PERSIST.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### persist

          public RedisAPI persist(String arg0)

      Redis command PERSIST.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxPersist

          public Single<Response> rxPersist(String arg0)

      Redis command PERSIST.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### pexpire

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

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

    - #### pexpire

          public RedisAPI pexpire(List<String> args)

      Redis command PEXPIRE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPexpire

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

      Redis command PEXPIRE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pexpireat

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

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

    - #### pexpireat

          public RedisAPI pexpireat(List<String> args)

      Redis command PEXPIREAT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPexpireat

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

      Redis command PEXPIREAT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pexpiretime

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

      Redis command PEXPIRETIME.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### pexpiretime

          public RedisAPI pexpiretime(String arg0)

      Redis command PEXPIRETIME.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxPexpiretime

          public Single<Response> rxPexpiretime(String arg0)

      Redis command PEXPIRETIME.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### pfadd

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

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

    - #### pfadd

          public RedisAPI pfadd(List<String> args)

      Redis command PFADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPfadd

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

      Redis command PFADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pfcount

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

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

    - #### pfcount

          public RedisAPI pfcount(List<String> args)

      Redis command PFCOUNT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPfcount

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

      Redis command PFCOUNT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pfdebug

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

      Redis command PFDEBUG.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### pfdebug

          public RedisAPI pfdebug(String arg0,
                                  String arg1)

      Redis command PFDEBUG.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxPfdebug

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

      Redis command PFDEBUG.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### pfmerge

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

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

    - #### pfmerge

          public RedisAPI pfmerge(List<String> args)

      Redis command PFMERGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPfmerge

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

      Redis command PFMERGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pfselftest

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

      Redis command PFSELFTEST.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### pfselftest

          public RedisAPI pfselftest()

      Redis command PFSELFTEST.
      Returns:
        fluent self

    - #### rxPfselftest

          public Single<Response> rxPfselftest()

      Redis command PFSELFTEST.
      Returns:
        fluent self

    - #### ping

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

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

    - #### ping

          public RedisAPI ping(List<String> args)

      Redis command PING.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPing

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

      Redis command PING.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### psetex

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

      Redis command PSETEX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### psetex

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

      Redis command PSETEX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxPsetex

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

      Redis command PSETEX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### psubscribe

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

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

    - #### psubscribe

          public RedisAPI psubscribe(List<String> args)

      Redis command PSUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPsubscribe

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

      Redis command PSUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### psync

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

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

    - #### psync

          public RedisAPI psync(List<String> args)

      Redis command PSYNC.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPsync

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

      Redis command PSYNC.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pttl

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

      Redis command PTTL.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### pttl

          public RedisAPI pttl(String arg0)

      Redis command PTTL.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxPttl

          public Single<Response> rxPttl(String arg0)

      Redis command PTTL.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### publish

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

      Redis command PUBLISH.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### publish

          public RedisAPI publish(String arg0,
                                  String arg1)

      Redis command PUBLISH.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxPublish

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

      Redis command PUBLISH.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### pubsub

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

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

    - #### pubsub

          public RedisAPI pubsub(List<String> args)

      Redis command PUBSUB.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPubsub

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

      Redis command PUBSUB.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### punsubscribe

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

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

    - #### punsubscribe

          public RedisAPI punsubscribe(List<String> args)

      Redis command PUNSUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPunsubscribe

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

      Redis command PUNSUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### quit

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

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

    - #### quit

          public RedisAPI quit(List<String> args)

      Redis command QUIT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxQuit

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

      Redis command QUIT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### randomkey

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

      Redis command RANDOMKEY.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### randomkey

          public RedisAPI randomkey()

      Redis command RANDOMKEY.
      Returns:
        fluent self

    - #### rxRandomkey

          public Single<Response> rxRandomkey()

      Redis command RANDOMKEY.
      Returns:
        fluent self

    - #### readonly

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

      Redis command READONLY.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### readonly

          public RedisAPI readonly()

      Redis command READONLY.
      Returns:
        fluent self

    - #### rxReadonly

          public Single<Response> rxReadonly()

      Redis command READONLY.
      Returns:
        fluent self

    - #### readwrite

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

      Redis command READWRITE.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### readwrite

          public RedisAPI readwrite()

      Redis command READWRITE.
      Returns:
        fluent self

    - #### rxReadwrite

          public Single<Response> rxReadwrite()

      Redis command READWRITE.
      Returns:
        fluent self

    - #### rename

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

      Redis command RENAME.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### rename

          public RedisAPI rename(String arg0,
                                 String arg1)

      Redis command RENAME.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxRename

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

      Redis command RENAME.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### renamenx

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

      Redis command RENAMENX.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### renamenx

          public RedisAPI renamenx(String arg0,
                                   String arg1)

      Redis command RENAMENX.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxRenamenx

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

      Redis command RENAMENX.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### replconf

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

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

    - #### replconf

          public RedisAPI replconf(List<String> args)

      Redis command REPLCONF.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxReplconf

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

      Redis command REPLCONF.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### replicaof

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

      Redis command REPLICAOF.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### replicaof

          public RedisAPI replicaof(String arg0,
                                    String arg1)

      Redis command REPLICAOF.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxReplicaof

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

      Redis command REPLICAOF.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### reset

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

      Redis command RESET.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### reset

          public RedisAPI reset()

      Redis command RESET.
      Returns:
        fluent self

    - #### rxReset

          public Single<Response> rxReset()

      Redis command RESET.
      Returns:
        fluent self

    - #### restore

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

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

    - #### restore

          public RedisAPI restore(List<String> args)

      Redis command RESTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRestore

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

      Redis command RESTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### restoreAsking

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

      Redis command RESTORE-ASKING.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### restoreAsking

          public RedisAPI restoreAsking(List<String> args)

      Redis command RESTORE-ASKING.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRestoreAsking

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

      Redis command RESTORE-ASKING.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### role

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

      Redis command ROLE.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### role

          public RedisAPI role()

      Redis command ROLE.
      Returns:
        fluent self

    - #### rxRole

          public Single<Response> rxRole()

      Redis command ROLE.
      Returns:
        fluent self

    - #### rpop

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

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

    - #### rpop

          public RedisAPI rpop(List<String> args)

      Redis command RPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRpop

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

      Redis command RPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rpoplpush

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

      Redis command RPOPLPUSH.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### rpoplpush

          public RedisAPI rpoplpush(String arg0,
                                    String arg1)

      Redis command RPOPLPUSH.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxRpoplpush

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

      Redis command RPOPLPUSH.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rpush

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

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

    - #### rpush

          public RedisAPI rpush(List<String> args)

      Redis command RPUSH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRpush

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

      Redis command RPUSH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rpushx

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

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

    - #### rpushx

          public RedisAPI rpushx(List<String> args)

      Redis command RPUSHX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRpushx

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

      Redis command RPUSHX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sadd

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

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

    - #### sadd

          public RedisAPI sadd(List<String> args)

      Redis command SADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSadd

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

      Redis command SADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### save

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

      Redis command SAVE.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### save

          public RedisAPI save()

      Redis command SAVE.
      Returns:
        fluent self

    - #### rxSave

          public Single<Response> rxSave()

      Redis command SAVE.
      Returns:
        fluent self

    - #### scan

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

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

    - #### scan

          public RedisAPI scan(List<String> args)

      Redis command SCAN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxScan

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

      Redis command SCAN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### scard

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

      Redis command SCARD.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### scard

          public RedisAPI scard(String arg0)

      Redis command SCARD.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxScard

          public Single<Response> rxScard(String arg0)

      Redis command SCARD.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### script

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

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

    - #### script

          public RedisAPI script(List<String> args)

      Redis command SCRIPT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxScript

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

      Redis command SCRIPT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sdiff

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

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

    - #### sdiff

          public RedisAPI sdiff(List<String> args)

      Redis command SDIFF.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSdiff

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

      Redis command SDIFF.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sdiffstore

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

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

    - #### sdiffstore

          public RedisAPI sdiffstore(List<String> args)

      Redis command SDIFFSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSdiffstore

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

      Redis command SDIFFSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### select

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

      Redis command SELECT.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### select

          public RedisAPI select(String arg0)

      Redis command SELECT.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxSelect

          public Single<Response> rxSelect(String arg0)

      Redis command SELECT.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### set

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

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

    - #### set

          public RedisAPI set(List<String> args)

      Redis command SET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSet

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

      Redis command SET.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### setbit

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

      Redis command SETBIT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### setbit

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

      Redis command SETBIT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSetbit

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

      Redis command SETBIT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### setex

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

      Redis command SETEX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### setex

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

      Redis command SETEX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSetex

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

      Redis command SETEX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### setnx

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

      Redis command SETNX.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### setnx

          public RedisAPI setnx(String arg0,
                                String arg1)

      Redis command SETNX.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSetnx

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

      Redis command SETNX.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### setrange

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

      Redis command SETRANGE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### setrange

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

      Redis command SETRANGE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSetrange

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

      Redis command SETRANGE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### shutdown

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

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

    - #### shutdown

          public RedisAPI shutdown(List<String> args)

      Redis command SHUTDOWN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxShutdown

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

      Redis command SHUTDOWN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sinter

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

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

    - #### sinter

          public RedisAPI sinter(List<String> args)

      Redis command SINTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSinter

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

      Redis command SINTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sintercard

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

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

    - #### sintercard

          public RedisAPI sintercard(List<String> args)

      Redis command SINTERCARD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSintercard

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

      Redis command SINTERCARD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sinterstore

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

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

    - #### sinterstore

          public RedisAPI sinterstore(List<String> args)

      Redis command SINTERSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSinterstore

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

      Redis command SINTERSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sismember

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

      Redis command SISMEMBER.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### sismember

          public RedisAPI sismember(String arg0,
                                    String arg1)

      Redis command SISMEMBER.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSismember

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

      Redis command SISMEMBER.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### slaveof

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

      Redis command SLAVEOF.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### slaveof

          public RedisAPI slaveof(String arg0,
                                  String arg1)

      Redis command SLAVEOF.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSlaveof

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

      Redis command SLAVEOF.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### slowlog

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

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

    - #### slowlog

          public RedisAPI slowlog(List<String> args)

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

    - #### rxSlowlog

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

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

    - #### smembers

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

      Redis command SMEMBERS.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### smembers

          public RedisAPI smembers(String arg0)

      Redis command SMEMBERS.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxSmembers

          public Single<Response> rxSmembers(String arg0)

      Redis command SMEMBERS.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### smismember

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

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

    - #### smismember

          public RedisAPI smismember(List<String> args)

      Redis command SMISMEMBER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSmismember

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

      Redis command SMISMEMBER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### smove

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

      Redis command SMOVE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### smove

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

      Redis command SMOVE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSmove

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

      Redis command SMOVE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### sort

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

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

    - #### sort

          public RedisAPI sort(List<String> args)

      Redis command SORT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSort

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

      Redis command SORT.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sortRo

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

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

    - #### sortRo

          public RedisAPI sortRo(List<String> args)

      Redis command SORT_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSortRo

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

      Redis command SORT_RO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### spop

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

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

    - #### spop

          public RedisAPI spop(List<String> args)

      Redis command SPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSpop

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

      Redis command SPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### spublish

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

      Redis command SPUBLISH.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### spublish

          public RedisAPI spublish(String arg0,
                                   String arg1)

      Redis command SPUBLISH.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSpublish

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

      Redis command SPUBLISH.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### srandmember

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

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

    - #### srandmember

          public RedisAPI srandmember(List<String> args)

      Redis command SRANDMEMBER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSrandmember

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

      Redis command SRANDMEMBER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### srem

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

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

    - #### srem

          public RedisAPI srem(List<String> args)

      Redis command SREM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSrem

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

      Redis command SREM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sscan

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

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

    - #### sscan

          public RedisAPI sscan(List<String> args)

      Redis command SSCAN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSscan

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

      Redis command SSCAN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ssubscribe

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

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

    - #### ssubscribe

          public RedisAPI ssubscribe(List<String> args)

      Redis command SSUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSsubscribe

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

      Redis command SSUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### strlen

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

      Redis command STRLEN.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### strlen

          public RedisAPI strlen(String arg0)

      Redis command STRLEN.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxStrlen

          public Single<Response> rxStrlen(String arg0)

      Redis command STRLEN.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### subscribe

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

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

    - #### subscribe

          public RedisAPI subscribe(List<String> args)

      Redis command SUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSubscribe

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

      Redis command SUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### substr

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

      Redis command SUBSTR.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### substr

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

      Redis command SUBSTR.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSubstr

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

      Redis command SUBSTR.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### sunion

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

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

    - #### sunion

          public RedisAPI sunion(List<String> args)

      Redis command SUNION.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSunion

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

      Redis command SUNION.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sunionstore

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

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

    - #### sunionstore

          public RedisAPI sunionstore(List<String> args)

      Redis command SUNIONSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSunionstore

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

      Redis command SUNIONSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sunsubscribe

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

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

    - #### sunsubscribe

          public RedisAPI sunsubscribe(List<String> args)

      Redis command SUNSUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSunsubscribe

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

      Redis command SUNSUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### swapdb

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

      Redis command SWAPDB.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### swapdb

          public RedisAPI swapdb(String arg0,
                                 String arg1)

      Redis command SWAPDB.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSwapdb

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

      Redis command SWAPDB.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### sync

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

      Redis command SYNC.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### sync

          public RedisAPI sync()

      Redis command SYNC.
      Returns:
        fluent self

    - #### rxSync

          public Single<Response> rxSync()

      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)

      Redis command TIME.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### time

          public RedisAPI time()

      Redis command TIME.
      Returns:
        fluent self

    - #### rxTime

          public Single<Response> rxTime()

      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)

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

    - #### touch

          public RedisAPI touch(List<String> args)

      Redis command TOUCH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTouch

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

      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)

      Redis command TTL.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### ttl

          public RedisAPI ttl(String arg0)

      Redis command TTL.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxTtl

          public Single<Response> rxTtl(String arg0)

      Redis command TTL.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### type

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

      Redis command TYPE.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### type

          public RedisAPI type(String arg0)

      Redis command TYPE.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxType

          public Single<Response> rxType(String arg0)

      Redis command TYPE.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### unlink

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

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

    - #### unlink

          public RedisAPI unlink(List<String> args)

      Redis command UNLINK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxUnlink

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

      Redis command UNLINK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### unsubscribe

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

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

    - #### unsubscribe

          public RedisAPI unsubscribe(List<String> args)

      Redis command UNSUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxUnsubscribe

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

      Redis command UNSUBSCRIBE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### unwatch

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

      Redis command UNWATCH.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### unwatch

          public RedisAPI unwatch()

      Redis command UNWATCH.
      Returns:
        fluent self

    - #### rxUnwatch

          public Single<Response> rxUnwatch()

      Redis command UNWATCH.
      Returns:
        fluent self

    - #### wait

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

      Redis command WAIT.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### wait

          public RedisAPI wait(String arg0,
                               String arg1)

      Redis command WAIT.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxWait

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

      Redis command WAIT.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### watch

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

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

    - #### watch

          public RedisAPI watch(List<String> args)

      Redis command WATCH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxWatch

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

      Redis command WATCH.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xack

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

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

    - #### xack

          public RedisAPI xack(List<String> args)

      Redis command XACK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXack

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

      Redis command XACK.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xadd

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

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

    - #### xadd

          public RedisAPI xadd(List<String> args)

      Redis command XADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXadd

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

      Redis command XADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xautoclaim

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

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

    - #### xautoclaim

          public RedisAPI xautoclaim(List<String> args)

      Redis command XAUTOCLAIM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXautoclaim

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

      Redis command XAUTOCLAIM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xclaim

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

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

    - #### xclaim

          public RedisAPI xclaim(List<String> args)

      Redis command XCLAIM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXclaim

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

      Redis command XCLAIM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xdel

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

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

    - #### xdel

          public RedisAPI xdel(List<String> args)

      Redis command XDEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXdel

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

      Redis command XDEL.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xgroup

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

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

    - #### xgroup

          public RedisAPI xgroup(List<String> args)

      Redis command XGROUP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXgroup

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

      Redis command XGROUP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xinfo

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

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

    - #### xinfo

          public RedisAPI xinfo(List<String> args)

      Redis command XINFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXinfo

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

      Redis command XINFO.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xlen

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

      Redis command XLEN.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### xlen

          public RedisAPI xlen(String arg0)

      Redis command XLEN.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxXlen

          public Single<Response> rxXlen(String arg0)

      Redis command XLEN.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### xpending

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

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

    - #### xpending

          public RedisAPI xpending(List<String> args)

      Redis command XPENDING.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXpending

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

      Redis command XPENDING.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xrange

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

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

    - #### xrange

          public RedisAPI xrange(List<String> args)

      Redis command XRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXrange

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

      Redis command XRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xread

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

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

    - #### xread

          public RedisAPI xread(List<String> args)

      Redis command XREAD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXread

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

      Redis command XREAD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xreadgroup

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

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

    - #### xreadgroup

          public RedisAPI xreadgroup(List<String> args)

      Redis command XREADGROUP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXreadgroup

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

      Redis command XREADGROUP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xrevrange

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

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

    - #### xrevrange

          public RedisAPI xrevrange(List<String> args)

      Redis command XREVRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXrevrange

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

      Redis command XREVRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xsetid

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

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

    - #### xsetid

          public RedisAPI xsetid(List<String> args)

      Redis command XSETID.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXsetid

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

      Redis command XSETID.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xtrim

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

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

    - #### xtrim

          public RedisAPI xtrim(List<String> args)

      Redis command XTRIM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXtrim

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

      Redis command XTRIM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zadd

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

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

    - #### zadd

          public RedisAPI zadd(List<String> args)

      Redis command ZADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZadd

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

      Redis command ZADD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zcard

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

      Redis command ZCARD.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### zcard

          public RedisAPI zcard(String arg0)

      Redis command ZCARD.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxZcard

          public Single<Response> rxZcard(String arg0)

      Redis command ZCARD.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### zcount

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

      Redis command ZCOUNT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zcount

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

      Redis command ZCOUNT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZcount

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

      Redis command ZCOUNT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zdiff

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

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

    - #### zdiff

          public RedisAPI zdiff(List<String> args)

      Redis command ZDIFF.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZdiff

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

      Redis command ZDIFF.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zdiffstore

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

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

    - #### zdiffstore

          public RedisAPI zdiffstore(List<String> args)

      Redis command ZDIFFSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZdiffstore

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

      Redis command ZDIFFSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zincrby

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

      Redis command ZINCRBY.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zincrby

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

      Redis command ZINCRBY.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZincrby

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

      Redis command ZINCRBY.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zinter

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

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

    - #### zinter

          public RedisAPI zinter(List<String> args)

      Redis command ZINTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZinter

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

      Redis command ZINTER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zintercard

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

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

    - #### zintercard

          public RedisAPI zintercard(List<String> args)

      Redis command ZINTERCARD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZintercard

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

      Redis command ZINTERCARD.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zinterstore

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

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

    - #### zinterstore

          public RedisAPI zinterstore(List<String> args)

      Redis command ZINTERSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZinterstore

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

      Redis command ZINTERSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zlexcount

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

      Redis command ZLEXCOUNT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zlexcount

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

      Redis command ZLEXCOUNT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZlexcount

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

      Redis command ZLEXCOUNT.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zmpop

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

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

    - #### zmpop

          public RedisAPI zmpop(List<String> args)

      Redis command ZMPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZmpop

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

      Redis command ZMPOP.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zmscore

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

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

    - #### zmscore

          public RedisAPI zmscore(List<String> args)

      Redis command ZMSCORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZmscore

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

      Redis command ZMSCORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zpopmax

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

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

    - #### zpopmax

          public RedisAPI zpopmax(List<String> args)

      Redis command ZPOPMAX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZpopmax

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

      Redis command ZPOPMAX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zpopmin

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

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

    - #### zpopmin

          public RedisAPI zpopmin(List<String> args)

      Redis command ZPOPMIN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZpopmin

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

      Redis command ZPOPMIN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrandmember

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

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

    - #### zrandmember

          public RedisAPI zrandmember(List<String> args)

      Redis command ZRANDMEMBER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrandmember

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

      Redis command ZRANDMEMBER.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrange

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

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

    - #### zrange

          public RedisAPI zrange(List<String> args)

      Redis command ZRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrange

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

      Redis command ZRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrangebylex

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

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

    - #### zrangebylex

          public RedisAPI zrangebylex(List<String> args)

      Redis command ZRANGEBYLEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrangebylex

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

      Redis command ZRANGEBYLEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrangebyscore

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

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

    - #### zrangebyscore

          public RedisAPI zrangebyscore(List<String> args)

      Redis command ZRANGEBYSCORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrangebyscore

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

      Redis command ZRANGEBYSCORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrangestore

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

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

    - #### zrangestore

          public RedisAPI zrangestore(List<String> args)

      Redis command ZRANGESTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrangestore

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

      Redis command ZRANGESTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrank

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

      Redis command ZRANK.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### zrank

          public RedisAPI zrank(String arg0,
                                String arg1)

      Redis command ZRANK.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZrank

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

      Redis command ZRANK.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zrem

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

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

    - #### zrem

          public RedisAPI zrem(List<String> args)

      Redis command ZREM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrem

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

      Redis command ZREM.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zremrangebylex

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

      Redis command ZREMRANGEBYLEX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zremrangebylex

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

      Redis command ZREMRANGEBYLEX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebylex

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

      Redis command ZREMRANGEBYLEX.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zremrangebyrank

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

      Redis command ZREMRANGEBYRANK.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zremrangebyrank

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

      Redis command ZREMRANGEBYRANK.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebyrank

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

      Redis command ZREMRANGEBYRANK.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zremrangebyscore

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

      Redis command ZREMRANGEBYSCORE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zremrangebyscore

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

      Redis command ZREMRANGEBYSCORE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebyscore

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

      Redis command ZREMRANGEBYSCORE.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zrevrange

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

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

    - #### zrevrange

          public RedisAPI zrevrange(List<String> args)

      Redis command ZREVRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrange

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

      Redis command ZREVRANGE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrangebylex

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

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

    - #### zrevrangebylex

          public RedisAPI zrevrangebylex(List<String> args)

      Redis command ZREVRANGEBYLEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrangebylex

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

      Redis command ZREVRANGEBYLEX.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrangebyscore

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

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

    - #### zrevrangebyscore

          public RedisAPI zrevrangebyscore(List<String> args)

      Redis command ZREVRANGEBYSCORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrangebyscore

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

      Redis command ZREVRANGEBYSCORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrank

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

      Redis command ZREVRANK.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### zrevrank

          public RedisAPI zrevrank(String arg0,
                                   String arg1)

      Redis command ZREVRANK.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZrevrank

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

      Redis command ZREVRANK.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zscan

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

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

    - #### zscan

          public RedisAPI zscan(List<String> args)

      Redis command ZSCAN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZscan

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

      Redis command ZSCAN.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zscore

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

      Redis command ZSCORE.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### zscore

          public RedisAPI zscore(String arg0,
                                 String arg1)

      Redis command ZSCORE.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZscore

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

      Redis command ZSCORE.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zunion

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

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

    - #### zunion

          public RedisAPI zunion(List<String> args)

      Redis command ZUNION.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZunion

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

      Redis command ZUNION.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zunionstore

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

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

    - #### zunionstore

          public RedisAPI zunionstore(List<String> args)

      Redis command ZUNIONSTORE.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZunionstore

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

      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 © 2024 Eclipse. All rights reserved.