io.vertx.rxjava3.redis.client

## Class RedisAPI

- java.lang.Object
- - io.vertx.rxjava3.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
    --- | ---
    `Maybe<Response>` | `acl(List<String> args)` Redis command acl.
    `static RedisAPI` | `api(Redis client)`
    `static RedisAPI` | `api(RedisConnection connection)`
    `Maybe<Response>` | `append(String arg0, String arg1)` Redis command append.
    `Maybe<Response>` | `asking()` Redis command asking.
    `Maybe<Response>` | `auth(List<String> args)` Redis command auth.
    `Maybe<Response>` | `bfAdd(List<String> args)` Redis command bfAdd.
    `Maybe<Response>` | `bfDebug(List<String> args)` Redis command bfDebug.
    `Maybe<Response>` | `bfExists(List<String> args)` Redis command bfExists.
    `Maybe<Response>` | `bfInfo(List<String> args)` Redis command bfInfo.
    `Maybe<Response>` | `bfInsert(List<String> args)` Redis command bfInsert.
    `Maybe<Response>` | `bfLoadchunk(List<String> args)` Redis command bfLoadchunk.
    `Maybe<Response>` | `bfMadd(List<String> args)` Redis command bfMadd.
    `Maybe<Response>` | `bfMexists(List<String> args)` Redis command bfMexists.
    `Maybe<Response>` | `bfReserve(List<String> args)` Redis command bfReserve.
    `Maybe<Response>` | `bfScandump(List<String> args)` Redis command bfScandump.
    `Maybe<Response>` | `bgrewriteaof()` Redis command bgrewriteaof.
    `Maybe<Response>` | `bgsave(List<String> args)` Redis command bgsave.
    `Maybe<Response>` | `bitcount(List<String> args)` Redis command bitcount.
    `Maybe<Response>` | `bitfield(List<String> args)` Redis command bitfield.
    `Maybe<Response>` | `bitfieldRo(List<String> args)` Redis command bitfieldRo.
    `Maybe<Response>` | `bitop(List<String> args)` Redis command bitop.
    `Maybe<Response>` | `bitpos(List<String> args)` Redis command bitpos.
    `Maybe<Response>` | `blmove(String arg0, String arg1, String arg2, String arg3, String arg4)` Redis command blmove.
    `Maybe<Response>` | `blmpop(List<String> args)` Redis command blmpop.
    `Maybe<Response>` | `blpop(List<String> args)` Redis command blpop.
    `Maybe<Response>` | `brpop(List<String> args)` Redis command brpop.
    `Maybe<Response>` | `brpoplpush(String arg0, String arg1, String arg2)` Redis command brpoplpush.
    `Maybe<Response>` | `bzmpop(List<String> args)` Redis command bzmpop.
    `Maybe<Response>` | `bzpopmax(List<String> args)` Redis command bzpopmax.
    `Maybe<Response>` | `bzpopmin(List<String> args)` Redis command bzpopmin.
    `Maybe<Response>` | `cfAdd(List<String> args)` Redis command cfAdd.
    `Maybe<Response>` | `cfAddnx(List<String> args)` Redis command cfAddnx.
    `Maybe<Response>` | `cfCompact(List<String> args)` Redis command cfCompact.
    `Maybe<Response>` | `cfCount(List<String> args)` Redis command cfCount.
    `Maybe<Response>` | `cfDebug(List<String> args)` Redis command cfDebug.
    `Maybe<Response>` | `cfDel(List<String> args)` Redis command cfDel.
    `Maybe<Response>` | `cfExists(List<String> args)` Redis command cfExists.
    `Maybe<Response>` | `cfInfo(List<String> args)` Redis command cfInfo.
    `Maybe<Response>` | `cfInsert(List<String> args)` Redis command cfInsert.
    `Maybe<Response>` | `cfInsertnx(List<String> args)` Redis command cfInsertnx.
    `Maybe<Response>` | `cfLoadchunk(List<String> args)` Redis command cfLoadchunk.
    `Maybe<Response>` | `cfMexists(List<String> args)` Redis command cfMexists.
    `Maybe<Response>` | `cfReserve(List<String> args)` Redis command cfReserve.
    `Maybe<Response>` | `cfScandump(List<String> args)` Redis command cfScandump.
    `Maybe<Response>` | `client(List<String> args)` Redis command client.
    `void` | `close()`
    `Maybe<Response>` | `cluster(List<String> args)` Redis command cluster.
    `Maybe<Response>` | `cmsIncrby(List<String> args)` Redis command cmsIncrby.
    `Maybe<Response>` | `cmsInfo(List<String> args)` Redis command cmsInfo.
    `Maybe<Response>` | `cmsInitbydim(List<String> args)` Redis command cmsInitbydim.
    `Maybe<Response>` | `cmsInitbyprob(List<String> args)` Redis command cmsInitbyprob.
    `Maybe<Response>` | `cmsMerge(List<String> args)` Redis command cmsMerge.
    `Maybe<Response>` | `cmsQuery(List<String> args)` Redis command cmsQuery.
    `Maybe<Response>` | `command(List<String> args)` Redis command command.
    `Maybe<Response>` | `config(List<String> args)` Redis command config.
    `Maybe<Response>` | `copy(List<String> args)` Redis command copy.
    `Maybe<Response>` | `dbsize()` Redis command dbsize.
    `Maybe<Response>` | `debug(List<String> args)` Redis command debug.
    `Maybe<Response>` | `decr(String arg0)` Redis command decr.
    `Maybe<Response>` | `decrby(String arg0, String arg1)` Redis command decrby.
    `Maybe<Response>` | `del(List<String> args)` Redis command del.
    `Maybe<Response>` | `discard()` Redis command discard.
    `Maybe<Response>` | `dump(String arg0)` Redis command dump.
    `Maybe<Response>` | `echo(String arg0)` Redis command echo.
    `boolean` | `equals(Object o)`
    `Maybe<Response>` | `eval(List<String> args)` Redis command eval.
    `Maybe<Response>` | `evalRo(List<String> args)` Redis command evalRo.
    `Maybe<Response>` | `evalsha(List<String> args)` Redis command evalsha.
    `Maybe<Response>` | `evalshaRo(List<String> args)` Redis command evalshaRo.
    `Maybe<Response>` | `exec()` Redis command exec.
    `Maybe<Response>` | `exists(List<String> args)` Redis command exists.
    `Maybe<Response>` | `expire(List<String> args)` Redis command expire.
    `Maybe<Response>` | `expireat(List<String> args)` Redis command expireat.
    `Maybe<Response>` | `expiretime(String arg0)` Redis command expiretime.
    `Maybe<Response>` | `failover(List<String> args)` Redis command failover.
    `Maybe<Response>` | `fcall(List<String> args)` Redis command fcall.
    `Maybe<Response>` | `fcallRo(List<String> args)` Redis command fcallRo.
    `Maybe<Response>` | `flushall(List<String> args)` Redis command flushall.
    `Maybe<Response>` | `flushdb(List<String> args)` Redis command flushdb.
    `Maybe<Response>` | `ftAdd(List<String> args)` Redis command ftAdd.
    `Maybe<Response>` | `ftAggregate(List<String> args)` Redis command ftAggregate.
    `Maybe<Response>` | `ftAliasadd(List<String> args)` Redis command ftAliasadd.
    `Maybe<Response>` | `ftAliasaddifnx(List<String> args)` Redis command ftAliasaddifnx.
    `Maybe<Response>` | `ftAliasdel(List<String> args)` Redis command ftAliasdel.
    `Maybe<Response>` | `ftAliasdelifx(List<String> args)` Redis command ftAliasdelifx.
    `Maybe<Response>` | `ftAliasupdate(List<String> args)` Redis command ftAliasupdate.
    `Maybe<Response>` | `ftAlter(List<String> args)` Redis command ftAlter.
    `Maybe<Response>` | `ftAlterifnx(List<String> args)` Redis command ftAlterifnx.
    `Maybe<Response>` | `ftConfig(List<String> args)` Redis command ftConfig.
    `Maybe<Response>` | `ftCreate(List<String> args)` Redis command ftCreate.
    `Maybe<Response>` | `ftCreateifnx(List<String> args)` Redis command ftCreateifnx.
    `Maybe<Response>` | `ftCursor(List<String> args)` Redis command ftCursor.
    `Maybe<Response>` | `ftDebug(List<String> args)` Redis command ftDebug.
    `Maybe<Response>` | `ftDel(List<String> args)` Redis command ftDel.
    `Maybe<Response>` | `ftDictadd(List<String> args)` Redis command ftDictadd.
    `Maybe<Response>` | `ftDictdel(List<String> args)` Redis command ftDictdel.
    `Maybe<Response>` | `ftDictdump(List<String> args)` Redis command ftDictdump.
    `Maybe<Response>` | `ftDrop(List<String> args)` Redis command ftDrop.
    `Maybe<Response>` | `ftDropifx(List<String> args)` Redis command ftDropifx.
    `Maybe<Response>` | `ftDropindex(List<String> args)` Redis command ftDropindex.
    `Maybe<Response>` | `ftDropindexifx(List<String> args)` Redis command ftDropindexifx.
    `Maybe<Response>` | `ftExplain(List<String> args)` Redis command ftExplain.
    `Maybe<Response>` | `ftExplaincli(List<String> args)` Redis command ftExplaincli.
    `Maybe<Response>` | `ftGet(List<String> args)` Redis command ftGet.
    `Maybe<Response>` | `ftInfo(List<String> args)` Redis command ftInfo.
    `Maybe<Response>` | `ftList(List<String> args)` Redis command ftList.
    `Maybe<Response>` | `ftMget(List<String> args)` Redis command ftMget.
    `Maybe<Response>` | `ftProfile(List<String> args)` Redis command ftProfile.
    `Maybe<Response>` | `ftSafeadd(List<String> args)` Redis command ftSafeadd.
    `Maybe<Response>` | `ftSearch(List<String> args)` Redis command ftSearch.
    `Maybe<Response>` | `ftSpellcheck(List<String> args)` Redis command ftSpellcheck.
    `Maybe<Response>` | `ftSugadd(List<String> args)` Redis command ftSugadd.
    `Maybe<Response>` | `ftSugdel(List<String> args)` Redis command ftSugdel.
    `Maybe<Response>` | `ftSugget(List<String> args)` Redis command ftSugget.
    `Maybe<Response>` | `ftSuglen(List<String> args)` Redis command ftSuglen.
    `Maybe<Response>` | `ftSynadd(List<String> args)` Redis command ftSynadd.
    `Maybe<Response>` | `ftSyndump(List<String> args)` Redis command ftSyndump.
    `Maybe<Response>` | `ftSynupdate(List<String> args)` Redis command ftSynupdate.
    `Maybe<Response>` | `ftTagvals(List<String> args)` Redis command ftTagvals.
    `Maybe<Response>` | `function(List<String> args)` Redis command function.
    `Maybe<Response>` | `geoadd(List<String> args)` Redis command geoadd.
    `Maybe<Response>` | `geodist(List<String> args)` Redis command geodist.
    `Maybe<Response>` | `geohash(List<String> args)` Redis command geohash.
    `Maybe<Response>` | `geopos(List<String> args)` Redis command geopos.
    `Maybe<Response>` | `georadius(List<String> args)` Redis command georadius.
    `Maybe<Response>` | `georadiusbymember(List<String> args)` Redis command georadiusbymember.
    `Maybe<Response>` | `georadiusbymemberRo(List<String> args)` Redis command georadiusbymemberRo.
    `Maybe<Response>` | `georadiusRo(List<String> args)` Redis command georadiusRo.
    `Maybe<Response>` | `geosearch(List<String> args)` Redis command geosearch.
    `Maybe<Response>` | `geosearchstore(List<String> args)` Redis command geosearchstore.
    `Maybe<Response>` | `get(String arg0)` Redis command get.
    `Maybe<Response>` | `getbit(String arg0, String arg1)` Redis command getbit.
    `Maybe<Response>` | `getdel(String arg0)` Redis command getdel.
    `RedisAPI` | `getDelegate()`
    `Maybe<Response>` | `getex(List<String> args)` Redis command getex.
    `Maybe<Response>` | `getrange(String arg0, String arg1, String arg2)` Redis command getrange.
    `Maybe<Response>` | `getset(String arg0, String arg1)` Redis command getset.
    `Maybe<Response>` | `graphBulk(List<String> args)` Redis command graphBulk.
    `Maybe<Response>` | `graphConfig(List<String> args)` Redis command graphConfig.
    `Maybe<Response>` | `graphDebug(List<String> args)` Redis command graphDebug.
    `Maybe<Response>` | `graphDelete(List<String> args)` Redis command graphDelete.
    `Maybe<Response>` | `graphExplain(List<String> args)` Redis command graphExplain.
    `Maybe<Response>` | `graphList(List<String> args)` Redis command graphList.
    `Maybe<Response>` | `graphProfile(List<String> args)` Redis command graphProfile.
    `Maybe<Response>` | `graphQuery(List<String> args)` Redis command graphQuery.
    `Maybe<Response>` | `graphRoQuery(List<String> args)` Redis command graphRoQuery.
    `Maybe<Response>` | `graphSlowlog(List<String> args)` Redis command graphSlowlog.
    `int` | `hashCode()`
    `Maybe<Response>` | `hdel(List<String> args)` Redis command hdel.
    `Maybe<Response>` | `hello(List<String> args)` Redis command hello.
    `Maybe<Response>` | `hexists(String arg0, String arg1)` Redis command hexists.
    `Maybe<Response>` | `hget(String arg0, String arg1)` Redis command hget.
    `Maybe<Response>` | `hgetall(String arg0)` Redis command hgetall.
    `Maybe<Response>` | `hincrby(String arg0, String arg1, String arg2)` Redis command hincrby.
    `Maybe<Response>` | `hincrbyfloat(String arg0, String arg1, String arg2)` Redis command hincrbyfloat.
    `Maybe<Response>` | `hkeys(String arg0)` Redis command hkeys.
    `Maybe<Response>` | `hlen(String arg0)` Redis command hlen.
    `Maybe<Response>` | `hmget(List<String> args)` Redis command hmget.
    `Maybe<Response>` | `hmset(List<String> args)` Redis command hmset.
    `Maybe<Response>` | `hrandfield(List<String> args)` Redis command hrandfield.
    `Maybe<Response>` | `hscan(List<String> args)` Redis command hscan.
    `Maybe<Response>` | `hset(List<String> args)` Redis command hset.
    `Maybe<Response>` | `hsetnx(String arg0, String arg1, String arg2)` Redis command hsetnx.
    `Maybe<Response>` | `hstrlen(String arg0, String arg1)` Redis command hstrlen.
    `Maybe<Response>` | `hvals(String arg0)` Redis command hvals.
    `Maybe<Response>` | `incr(String arg0)` Redis command incr.
    `Maybe<Response>` | `incrby(String arg0, String arg1)` Redis command incrby.
    `Maybe<Response>` | `incrbyfloat(String arg0, String arg1)` Redis command incrbyfloat.
    `Maybe<Response>` | `info(List<String> args)` Redis command info.
    `Maybe<Response>` | `jsonArrappend(List<String> args)` Redis command jsonArrappend.
    `Maybe<Response>` | `jsonArrindex(List<String> args)` Redis command jsonArrindex.
    `Maybe<Response>` | `jsonArrinsert(List<String> args)` Redis command jsonArrinsert.
    `Maybe<Response>` | `jsonArrlen(List<String> args)` Redis command jsonArrlen.
    `Maybe<Response>` | `jsonArrpop(List<String> args)` Redis command jsonArrpop.
    `Maybe<Response>` | `jsonArrtrim(List<String> args)` Redis command jsonArrtrim.
    `Maybe<Response>` | `jsonClear(List<String> args)` Redis command jsonClear.
    `Maybe<Response>` | `jsonDebug(List<String> args)` Redis command jsonDebug.
    `Maybe<Response>` | `jsonDel(List<String> args)` Redis command jsonDel.
    `Maybe<Response>` | `jsonForget(List<String> args)` Redis command jsonForget.
    `Maybe<Response>` | `jsonGet(List<String> args)` Redis command jsonGet.
    `Maybe<Response>` | `jsonMget(List<String> args)` Redis command jsonMget.
    `Maybe<Response>` | `jsonNumincrby(List<String> args)` Redis command jsonNumincrby.
    `Maybe<Response>` | `jsonNummultby(List<String> args)` Redis command jsonNummultby.
    `Maybe<Response>` | `jsonNumpowby(List<String> args)` Redis command jsonNumpowby.
    `Maybe<Response>` | `jsonObjkeys(List<String> args)` Redis command jsonObjkeys.
    `Maybe<Response>` | `jsonObjlen(List<String> args)` Redis command jsonObjlen.
    `Maybe<Response>` | `jsonResp(List<String> args)` Redis command jsonResp.
    `Maybe<Response>` | `jsonSet(List<String> args)` Redis command jsonSet.
    `Maybe<Response>` | `jsonStrappend(List<String> args)` Redis command jsonStrappend.
    `Maybe<Response>` | `jsonStrlen(List<String> args)` Redis command jsonStrlen.
    `Maybe<Response>` | `jsonToggle(List<String> args)` Redis command jsonToggle.
    `Maybe<Response>` | `jsonType(List<String> args)` Redis command jsonType.
    `Maybe<Response>` | `keys(String arg0)` Redis command keys.
    `Maybe<Response>` | `lastsave()` Redis command lastsave.
    `Maybe<Response>` | `latency(List<String> args)` Redis command latency.
    `Maybe<Response>` | `lcs(List<String> args)` Redis command lcs.
    `Maybe<Response>` | `lindex(String arg0, String arg1)` Redis command lindex.
    `Maybe<Response>` | `linsert(String arg0, String arg1, String arg2, String arg3)` Redis command linsert.
    `Maybe<Response>` | `llen(String arg0)` Redis command llen.
    `Maybe<Response>` | `lmove(String arg0, String arg1, String arg2, String arg3)` Redis command lmove.
    `Maybe<Response>` | `lmpop(List<String> args)` Redis command lmpop.
    `Maybe<Response>` | `lolwut(List<String> args)` Redis command lolwut.
    `Maybe<Response>` | `lpop(List<String> args)` Redis command lpop.
    `Maybe<Response>` | `lpos(List<String> args)` Redis command lpos.
    `Maybe<Response>` | `lpush(List<String> args)` Redis command lpush.
    `Maybe<Response>` | `lpushx(List<String> args)` Redis command lpushx.
    `Maybe<Response>` | `lrange(String arg0, String arg1, String arg2)` Redis command lrange.
    `Maybe<Response>` | `lrem(String arg0, String arg1, String arg2)` Redis command lrem.
    `Maybe<Response>` | `lset(String arg0, String arg1, String arg2)` Redis command lset.
    `Maybe<Response>` | `ltrim(String arg0, String arg1, String arg2)` Redis command ltrim.
    `Maybe<Response>` | `memory(List<String> args)` Redis command memory.
    `Maybe<Response>` | `mget(List<String> args)` Redis command mget.
    `Maybe<Response>` | `migrate(List<String> args)` Redis command migrate.
    `Maybe<Response>` | `module(List<String> args)` Redis command module.
    `Maybe<Response>` | `monitor()` Redis command monitor.
    `Maybe<Response>` | `move(String arg0, String arg1)` Redis command move.
    `Maybe<Response>` | `mset(List<String> args)` Redis command mset.
    `Maybe<Response>` | `msetnx(List<String> args)` Redis command msetnx.
    `Maybe<Response>` | `multi()` Redis command multi.
    `static RedisAPI` | `newInstance(RedisAPI arg)`
    `Maybe<Response>` | `object(List<String> args)` Redis command object.
    `Maybe<Response>` | `persist(String arg0)` Redis command persist.
    `Maybe<Response>` | `pexpire(List<String> args)` Redis command pexpire.
    `Maybe<Response>` | `pexpireat(List<String> args)` Redis command pexpireat.
    `Maybe<Response>` | `pexpiretime(String arg0)` Redis command pexpiretime.
    `Maybe<Response>` | `pfadd(List<String> args)` Redis command pfadd.
    `Maybe<Response>` | `pfcount(List<String> args)` Redis command pfcount.
    `Maybe<Response>` | `pfdebug(List<String> args)` Redis command pfdebug.
    `Maybe<Response>` | `pfmerge(List<String> args)` Redis command pfmerge.
    `Maybe<Response>` | `pfselftest()` Redis command pfselftest.
    `Maybe<Response>` | `ping(List<String> args)` Redis command ping.
    `Maybe<Response>` | `psetex(String arg0, String arg1, String arg2)` Redis command psetex.
    `Maybe<Response>` | `psubscribe(List<String> args)` Redis command psubscribe.
    `Maybe<Response>` | `psync(List<String> args)` Redis command psync.
    `Maybe<Response>` | `pttl(String arg0)` Redis command pttl.
    `Maybe<Response>` | `publish(String arg0, String arg1)` Redis command publish.
    `Maybe<Response>` | `pubsub(List<String> args)` Redis command pubsub.
    `Maybe<Response>` | `punsubscribe(List<String> args)` Redis command punsubscribe.
    `Maybe<Response>` | `quit(List<String> args)` Redis command quit.
    `Maybe<Response>` | `randomkey()` Redis command randomkey.
    `Maybe<Response>` | `readonly()` Redis command readonly.
    `Maybe<Response>` | `readwrite()` Redis command readwrite.
    `Maybe<Response>` | `rename(String arg0, String arg1)` Redis command rename.
    `Maybe<Response>` | `renamenx(String arg0, String arg1)` Redis command renamenx.
    `Maybe<Response>` | `replconf(List<String> args)` Redis command replconf.
    `Maybe<Response>` | `replicaof(String arg0, String arg1)` Redis command replicaof.
    `Maybe<Response>` | `reset()` Redis command reset.
    `Maybe<Response>` | `restore(List<String> args)` Redis command restore.
    `Maybe<Response>` | `restoreAsking(List<String> args)` Redis command restoreAsking.
    `Maybe<Response>` | `role()` Redis command role.
    `Maybe<Response>` | `rpop(List<String> args)` Redis command rpop.
    `Maybe<Response>` | `rpoplpush(String arg0, String arg1)` Redis command rpoplpush.
    `Maybe<Response>` | `rpush(List<String> args)` Redis command rpush.
    `Maybe<Response>` | `rpushx(List<String> args)` Redis command rpushx.
    `Maybe<Response>` | `rxAcl(List<String> args)` Redis command acl.
    `Maybe<Response>` | `rxAppend(String arg0, String arg1)` Redis command append.
    `Maybe<Response>` | `rxAsking()` Redis command asking.
    `Maybe<Response>` | `rxAuth(List<String> args)` Redis command auth.
    `Maybe<Response>` | `rxBfAdd(List<String> args)` Redis command bfAdd.
    `Maybe<Response>` | `rxBfDebug(List<String> args)` Redis command bfDebug.
    `Maybe<Response>` | `rxBfExists(List<String> args)` Redis command bfExists.
    `Maybe<Response>` | `rxBfInfo(List<String> args)` Redis command bfInfo.
    `Maybe<Response>` | `rxBfInsert(List<String> args)` Redis command bfInsert.
    `Maybe<Response>` | `rxBfLoadchunk(List<String> args)` Redis command bfLoadchunk.
    `Maybe<Response>` | `rxBfMadd(List<String> args)` Redis command bfMadd.
    `Maybe<Response>` | `rxBfMexists(List<String> args)` Redis command bfMexists.
    `Maybe<Response>` | `rxBfReserve(List<String> args)` Redis command bfReserve.
    `Maybe<Response>` | `rxBfScandump(List<String> args)` Redis command bfScandump.
    `Maybe<Response>` | `rxBgrewriteaof()` Redis command bgrewriteaof.
    `Maybe<Response>` | `rxBgsave(List<String> args)` Redis command bgsave.
    `Maybe<Response>` | `rxBitcount(List<String> args)` Redis command bitcount.
    `Maybe<Response>` | `rxBitfield(List<String> args)` Redis command bitfield.
    `Maybe<Response>` | `rxBitfieldRo(List<String> args)` Redis command bitfieldRo.
    `Maybe<Response>` | `rxBitop(List<String> args)` Redis command bitop.
    `Maybe<Response>` | `rxBitpos(List<String> args)` Redis command bitpos.
    `Maybe<Response>` | `rxBlmove(String arg0, String arg1, String arg2, String arg3, String arg4)` Redis command blmove.
    `Maybe<Response>` | `rxBlmpop(List<String> args)` Redis command blmpop.
    `Maybe<Response>` | `rxBlpop(List<String> args)` Redis command blpop.
    `Maybe<Response>` | `rxBrpop(List<String> args)` Redis command brpop.
    `Maybe<Response>` | `rxBrpoplpush(String arg0, String arg1, String arg2)` Redis command brpoplpush.
    `Maybe<Response>` | `rxBzmpop(List<String> args)` Redis command bzmpop.
    `Maybe<Response>` | `rxBzpopmax(List<String> args)` Redis command bzpopmax.
    `Maybe<Response>` | `rxBzpopmin(List<String> args)` Redis command bzpopmin.
    `Maybe<Response>` | `rxCfAdd(List<String> args)` Redis command cfAdd.
    `Maybe<Response>` | `rxCfAddnx(List<String> args)` Redis command cfAddnx.
    `Maybe<Response>` | `rxCfCompact(List<String> args)` Redis command cfCompact.
    `Maybe<Response>` | `rxCfCount(List<String> args)` Redis command cfCount.
    `Maybe<Response>` | `rxCfDebug(List<String> args)` Redis command cfDebug.
    `Maybe<Response>` | `rxCfDel(List<String> args)` Redis command cfDel.
    `Maybe<Response>` | `rxCfExists(List<String> args)` Redis command cfExists.
    `Maybe<Response>` | `rxCfInfo(List<String> args)` Redis command cfInfo.
    `Maybe<Response>` | `rxCfInsert(List<String> args)` Redis command cfInsert.
    `Maybe<Response>` | `rxCfInsertnx(List<String> args)` Redis command cfInsertnx.
    `Maybe<Response>` | `rxCfLoadchunk(List<String> args)` Redis command cfLoadchunk.
    `Maybe<Response>` | `rxCfMexists(List<String> args)` Redis command cfMexists.
    `Maybe<Response>` | `rxCfReserve(List<String> args)` Redis command cfReserve.
    `Maybe<Response>` | `rxCfScandump(List<String> args)` Redis command cfScandump.
    `Maybe<Response>` | `rxClient(List<String> args)` Redis command client.
    `Maybe<Response>` | `rxCluster(List<String> args)` Redis command cluster.
    `Maybe<Response>` | `rxCmsIncrby(List<String> args)` Redis command cmsIncrby.
    `Maybe<Response>` | `rxCmsInfo(List<String> args)` Redis command cmsInfo.
    `Maybe<Response>` | `rxCmsInitbydim(List<String> args)` Redis command cmsInitbydim.
    `Maybe<Response>` | `rxCmsInitbyprob(List<String> args)` Redis command cmsInitbyprob.
    `Maybe<Response>` | `rxCmsMerge(List<String> args)` Redis command cmsMerge.
    `Maybe<Response>` | `rxCmsQuery(List<String> args)` Redis command cmsQuery.
    `Maybe<Response>` | `rxCommand(List<String> args)` Redis command command.
    `Maybe<Response>` | `rxConfig(List<String> args)` Redis command config.
    `Maybe<Response>` | `rxCopy(List<String> args)` Redis command copy.
    `Maybe<Response>` | `rxDbsize()` Redis command dbsize.
    `Maybe<Response>` | `rxDebug(List<String> args)` Redis command debug.
    `Maybe<Response>` | `rxDecr(String arg0)` Redis command decr.
    `Maybe<Response>` | `rxDecrby(String arg0, String arg1)` Redis command decrby.
    `Maybe<Response>` | `rxDel(List<String> args)` Redis command del.
    `Maybe<Response>` | `rxDiscard()` Redis command discard.
    `Maybe<Response>` | `rxDump(String arg0)` Redis command dump.
    `Maybe<Response>` | `rxEcho(String arg0)` Redis command echo.
    `Maybe<Response>` | `rxEval(List<String> args)` Redis command eval.
    `Maybe<Response>` | `rxEvalRo(List<String> args)` Redis command evalRo.
    `Maybe<Response>` | `rxEvalsha(List<String> args)` Redis command evalsha.
    `Maybe<Response>` | `rxEvalshaRo(List<String> args)` Redis command evalshaRo.
    `Maybe<Response>` | `rxExec()` Redis command exec.
    `Maybe<Response>` | `rxExists(List<String> args)` Redis command exists.
    `Maybe<Response>` | `rxExpire(List<String> args)` Redis command expire.
    `Maybe<Response>` | `rxExpireat(List<String> args)` Redis command expireat.
    `Maybe<Response>` | `rxExpiretime(String arg0)` Redis command expiretime.
    `Maybe<Response>` | `rxFailover(List<String> args)` Redis command failover.
    `Maybe<Response>` | `rxFcall(List<String> args)` Redis command fcall.
    `Maybe<Response>` | `rxFcallRo(List<String> args)` Redis command fcallRo.
    `Maybe<Response>` | `rxFlushall(List<String> args)` Redis command flushall.
    `Maybe<Response>` | `rxFlushdb(List<String> args)` Redis command flushdb.
    `Maybe<Response>` | `rxFtAdd(List<String> args)` Redis command ftAdd.
    `Maybe<Response>` | `rxFtAggregate(List<String> args)` Redis command ftAggregate.
    `Maybe<Response>` | `rxFtAliasadd(List<String> args)` Redis command ftAliasadd.
    `Maybe<Response>` | `rxFtAliasaddifnx(List<String> args)` Redis command ftAliasaddifnx.
    `Maybe<Response>` | `rxFtAliasdel(List<String> args)` Redis command ftAliasdel.
    `Maybe<Response>` | `rxFtAliasdelifx(List<String> args)` Redis command ftAliasdelifx.
    `Maybe<Response>` | `rxFtAliasupdate(List<String> args)` Redis command ftAliasupdate.
    `Maybe<Response>` | `rxFtAlter(List<String> args)` Redis command ftAlter.
    `Maybe<Response>` | `rxFtAlterifnx(List<String> args)` Redis command ftAlterifnx.
    `Maybe<Response>` | `rxFtConfig(List<String> args)` Redis command ftConfig.
    `Maybe<Response>` | `rxFtCreate(List<String> args)` Redis command ftCreate.
    `Maybe<Response>` | `rxFtCreateifnx(List<String> args)` Redis command ftCreateifnx.
    `Maybe<Response>` | `rxFtCursor(List<String> args)` Redis command ftCursor.
    `Maybe<Response>` | `rxFtDebug(List<String> args)` Redis command ftDebug.
    `Maybe<Response>` | `rxFtDel(List<String> args)` Redis command ftDel.
    `Maybe<Response>` | `rxFtDictadd(List<String> args)` Redis command ftDictadd.
    `Maybe<Response>` | `rxFtDictdel(List<String> args)` Redis command ftDictdel.
    `Maybe<Response>` | `rxFtDictdump(List<String> args)` Redis command ftDictdump.
    `Maybe<Response>` | `rxFtDrop(List<String> args)` Redis command ftDrop.
    `Maybe<Response>` | `rxFtDropifx(List<String> args)` Redis command ftDropifx.
    `Maybe<Response>` | `rxFtDropindex(List<String> args)` Redis command ftDropindex.
    `Maybe<Response>` | `rxFtDropindexifx(List<String> args)` Redis command ftDropindexifx.
    `Maybe<Response>` | `rxFtExplain(List<String> args)` Redis command ftExplain.
    `Maybe<Response>` | `rxFtExplaincli(List<String> args)` Redis command ftExplaincli.
    `Maybe<Response>` | `rxFtGet(List<String> args)` Redis command ftGet.
    `Maybe<Response>` | `rxFtInfo(List<String> args)` Redis command ftInfo.
    `Maybe<Response>` | `rxFtList(List<String> args)` Redis command ftList.
    `Maybe<Response>` | `rxFtMget(List<String> args)` Redis command ftMget.
    `Maybe<Response>` | `rxFtProfile(List<String> args)` Redis command ftProfile.
    `Maybe<Response>` | `rxFtSafeadd(List<String> args)` Redis command ftSafeadd.
    `Maybe<Response>` | `rxFtSearch(List<String> args)` Redis command ftSearch.
    `Maybe<Response>` | `rxFtSpellcheck(List<String> args)` Redis command ftSpellcheck.
    `Maybe<Response>` | `rxFtSugadd(List<String> args)` Redis command ftSugadd.
    `Maybe<Response>` | `rxFtSugdel(List<String> args)` Redis command ftSugdel.
    `Maybe<Response>` | `rxFtSugget(List<String> args)` Redis command ftSugget.
    `Maybe<Response>` | `rxFtSuglen(List<String> args)` Redis command ftSuglen.
    `Maybe<Response>` | `rxFtSynadd(List<String> args)` Redis command ftSynadd.
    `Maybe<Response>` | `rxFtSyndump(List<String> args)` Redis command ftSyndump.
    `Maybe<Response>` | `rxFtSynupdate(List<String> args)` Redis command ftSynupdate.
    `Maybe<Response>` | `rxFtTagvals(List<String> args)` Redis command ftTagvals.
    `Maybe<Response>` | `rxFunction(List<String> args)` Redis command function.
    `Maybe<Response>` | `rxGeoadd(List<String> args)` Redis command geoadd.
    `Maybe<Response>` | `rxGeodist(List<String> args)` Redis command geodist.
    `Maybe<Response>` | `rxGeohash(List<String> args)` Redis command geohash.
    `Maybe<Response>` | `rxGeopos(List<String> args)` Redis command geopos.
    `Maybe<Response>` | `rxGeoradius(List<String> args)` Redis command georadius.
    `Maybe<Response>` | `rxGeoradiusbymember(List<String> args)` Redis command georadiusbymember.
    `Maybe<Response>` | `rxGeoradiusbymemberRo(List<String> args)` Redis command georadiusbymemberRo.
    `Maybe<Response>` | `rxGeoradiusRo(List<String> args)` Redis command georadiusRo.
    `Maybe<Response>` | `rxGeosearch(List<String> args)` Redis command geosearch.
    `Maybe<Response>` | `rxGeosearchstore(List<String> args)` Redis command geosearchstore.
    `Maybe<Response>` | `rxGet(String arg0)` Redis command get.
    `Maybe<Response>` | `rxGetbit(String arg0, String arg1)` Redis command getbit.
    `Maybe<Response>` | `rxGetdel(String arg0)` Redis command getdel.
    `Maybe<Response>` | `rxGetex(List<String> args)` Redis command getex.
    `Maybe<Response>` | `rxGetrange(String arg0, String arg1, String arg2)` Redis command getrange.
    `Maybe<Response>` | `rxGetset(String arg0, String arg1)` Redis command getset.
    `Maybe<Response>` | `rxGraphBulk(List<String> args)` Redis command graphBulk.
    `Maybe<Response>` | `rxGraphConfig(List<String> args)` Redis command graphConfig.
    `Maybe<Response>` | `rxGraphDebug(List<String> args)` Redis command graphDebug.
    `Maybe<Response>` | `rxGraphDelete(List<String> args)` Redis command graphDelete.
    `Maybe<Response>` | `rxGraphExplain(List<String> args)` Redis command graphExplain.
    `Maybe<Response>` | `rxGraphList(List<String> args)` Redis command graphList.
    `Maybe<Response>` | `rxGraphProfile(List<String> args)` Redis command graphProfile.
    `Maybe<Response>` | `rxGraphQuery(List<String> args)` Redis command graphQuery.
    `Maybe<Response>` | `rxGraphRoQuery(List<String> args)` Redis command graphRoQuery.
    `Maybe<Response>` | `rxGraphSlowlog(List<String> args)` Redis command graphSlowlog.
    `Maybe<Response>` | `rxHdel(List<String> args)` Redis command hdel.
    `Maybe<Response>` | `rxHello(List<String> args)` Redis command hello.
    `Maybe<Response>` | `rxHexists(String arg0, String arg1)` Redis command hexists.
    `Maybe<Response>` | `rxHget(String arg0, String arg1)` Redis command hget.
    `Maybe<Response>` | `rxHgetall(String arg0)` Redis command hgetall.
    `Maybe<Response>` | `rxHincrby(String arg0, String arg1, String arg2)` Redis command hincrby.
    `Maybe<Response>` | `rxHincrbyfloat(String arg0, String arg1, String arg2)` Redis command hincrbyfloat.
    `Maybe<Response>` | `rxHkeys(String arg0)` Redis command hkeys.
    `Maybe<Response>` | `rxHlen(String arg0)` Redis command hlen.
    `Maybe<Response>` | `rxHmget(List<String> args)` Redis command hmget.
    `Maybe<Response>` | `rxHmset(List<String> args)` Redis command hmset.
    `Maybe<Response>` | `rxHrandfield(List<String> args)` Redis command hrandfield.
    `Maybe<Response>` | `rxHscan(List<String> args)` Redis command hscan.
    `Maybe<Response>` | `rxHset(List<String> args)` Redis command hset.
    `Maybe<Response>` | `rxHsetnx(String arg0, String arg1, String arg2)` Redis command hsetnx.
    `Maybe<Response>` | `rxHstrlen(String arg0, String arg1)` Redis command hstrlen.
    `Maybe<Response>` | `rxHvals(String arg0)` Redis command hvals.
    `Maybe<Response>` | `rxIncr(String arg0)` Redis command incr.
    `Maybe<Response>` | `rxIncrby(String arg0, String arg1)` Redis command incrby.
    `Maybe<Response>` | `rxIncrbyfloat(String arg0, String arg1)` Redis command incrbyfloat.
    `Maybe<Response>` | `rxInfo(List<String> args)` Redis command info.
    `Maybe<Response>` | `rxJsonArrappend(List<String> args)` Redis command jsonArrappend.
    `Maybe<Response>` | `rxJsonArrindex(List<String> args)` Redis command jsonArrindex.
    `Maybe<Response>` | `rxJsonArrinsert(List<String> args)` Redis command jsonArrinsert.
    `Maybe<Response>` | `rxJsonArrlen(List<String> args)` Redis command jsonArrlen.
    `Maybe<Response>` | `rxJsonArrpop(List<String> args)` Redis command jsonArrpop.
    `Maybe<Response>` | `rxJsonArrtrim(List<String> args)` Redis command jsonArrtrim.
    `Maybe<Response>` | `rxJsonClear(List<String> args)` Redis command jsonClear.
    `Maybe<Response>` | `rxJsonDebug(List<String> args)` Redis command jsonDebug.
    `Maybe<Response>` | `rxJsonDel(List<String> args)` Redis command jsonDel.
    `Maybe<Response>` | `rxJsonForget(List<String> args)` Redis command jsonForget.
    `Maybe<Response>` | `rxJsonGet(List<String> args)` Redis command jsonGet.
    `Maybe<Response>` | `rxJsonMget(List<String> args)` Redis command jsonMget.
    `Maybe<Response>` | `rxJsonNumincrby(List<String> args)` Redis command jsonNumincrby.
    `Maybe<Response>` | `rxJsonNummultby(List<String> args)` Redis command jsonNummultby.
    `Maybe<Response>` | `rxJsonNumpowby(List<String> args)` Redis command jsonNumpowby.
    `Maybe<Response>` | `rxJsonObjkeys(List<String> args)` Redis command jsonObjkeys.
    `Maybe<Response>` | `rxJsonObjlen(List<String> args)` Redis command jsonObjlen.
    `Maybe<Response>` | `rxJsonResp(List<String> args)` Redis command jsonResp.
    `Maybe<Response>` | `rxJsonSet(List<String> args)` Redis command jsonSet.
    `Maybe<Response>` | `rxJsonStrappend(List<String> args)` Redis command jsonStrappend.
    `Maybe<Response>` | `rxJsonStrlen(List<String> args)` Redis command jsonStrlen.
    `Maybe<Response>` | `rxJsonToggle(List<String> args)` Redis command jsonToggle.
    `Maybe<Response>` | `rxJsonType(List<String> args)` Redis command jsonType.
    `Maybe<Response>` | `rxKeys(String arg0)` Redis command keys.
    `Maybe<Response>` | `rxLastsave()` Redis command lastsave.
    `Maybe<Response>` | `rxLatency(List<String> args)` Redis command latency.
    `Maybe<Response>` | `rxLcs(List<String> args)` Redis command lcs.
    `Maybe<Response>` | `rxLindex(String arg0, String arg1)` Redis command lindex.
    `Maybe<Response>` | `rxLinsert(String arg0, String arg1, String arg2, String arg3)` Redis command linsert.
    `Maybe<Response>` | `rxLlen(String arg0)` Redis command llen.
    `Maybe<Response>` | `rxLmove(String arg0, String arg1, String arg2, String arg3)` Redis command lmove.
    `Maybe<Response>` | `rxLmpop(List<String> args)` Redis command lmpop.
    `Maybe<Response>` | `rxLolwut(List<String> args)` Redis command lolwut.
    `Maybe<Response>` | `rxLpop(List<String> args)` Redis command lpop.
    `Maybe<Response>` | `rxLpos(List<String> args)` Redis command lpos.
    `Maybe<Response>` | `rxLpush(List<String> args)` Redis command lpush.
    `Maybe<Response>` | `rxLpushx(List<String> args)` Redis command lpushx.
    `Maybe<Response>` | `rxLrange(String arg0, String arg1, String arg2)` Redis command lrange.
    `Maybe<Response>` | `rxLrem(String arg0, String arg1, String arg2)` Redis command lrem.
    `Maybe<Response>` | `rxLset(String arg0, String arg1, String arg2)` Redis command lset.
    `Maybe<Response>` | `rxLtrim(String arg0, String arg1, String arg2)` Redis command ltrim.
    `Maybe<Response>` | `rxMemory(List<String> args)` Redis command memory.
    `Maybe<Response>` | `rxMget(List<String> args)` Redis command mget.
    `Maybe<Response>` | `rxMigrate(List<String> args)` Redis command migrate.
    `Maybe<Response>` | `rxModule(List<String> args)` Redis command module.
    `Maybe<Response>` | `rxMonitor()` Redis command monitor.
    `Maybe<Response>` | `rxMove(String arg0, String arg1)` Redis command move.
    `Maybe<Response>` | `rxMset(List<String> args)` Redis command mset.
    `Maybe<Response>` | `rxMsetnx(List<String> args)` Redis command msetnx.
    `Maybe<Response>` | `rxMulti()` Redis command multi.
    `Maybe<Response>` | `rxObject(List<String> args)` Redis command object.
    `Maybe<Response>` | `rxPersist(String arg0)` Redis command persist.
    `Maybe<Response>` | `rxPexpire(List<String> args)` Redis command pexpire.
    `Maybe<Response>` | `rxPexpireat(List<String> args)` Redis command pexpireat.
    `Maybe<Response>` | `rxPexpiretime(String arg0)` Redis command pexpiretime.
    `Maybe<Response>` | `rxPfadd(List<String> args)` Redis command pfadd.
    `Maybe<Response>` | `rxPfcount(List<String> args)` Redis command pfcount.
    `Maybe<Response>` | `rxPfdebug(List<String> args)` Redis command pfdebug.
    `Maybe<Response>` | `rxPfmerge(List<String> args)` Redis command pfmerge.
    `Maybe<Response>` | `rxPfselftest()` Redis command pfselftest.
    `Maybe<Response>` | `rxPing(List<String> args)` Redis command ping.
    `Maybe<Response>` | `rxPsetex(String arg0, String arg1, String arg2)` Redis command psetex.
    `Maybe<Response>` | `rxPsubscribe(List<String> args)` Redis command psubscribe.
    `Maybe<Response>` | `rxPsync(List<String> args)` Redis command psync.
    `Maybe<Response>` | `rxPttl(String arg0)` Redis command pttl.
    `Maybe<Response>` | `rxPublish(String arg0, String arg1)` Redis command publish.
    `Maybe<Response>` | `rxPubsub(List<String> args)` Redis command pubsub.
    `Maybe<Response>` | `rxPunsubscribe(List<String> args)` Redis command punsubscribe.
    `Maybe<Response>` | `rxQuit(List<String> args)` Redis command quit.
    `Maybe<Response>` | `rxRandomkey()` Redis command randomkey.
    `Maybe<Response>` | `rxReadonly()` Redis command readonly.
    `Maybe<Response>` | `rxReadwrite()` Redis command readwrite.
    `Maybe<Response>` | `rxRename(String arg0, String arg1)` Redis command rename.
    `Maybe<Response>` | `rxRenamenx(String arg0, String arg1)` Redis command renamenx.
    `Maybe<Response>` | `rxReplconf(List<String> args)` Redis command replconf.
    `Maybe<Response>` | `rxReplicaof(String arg0, String arg1)` Redis command replicaof.
    `Maybe<Response>` | `rxReset()` Redis command reset.
    `Maybe<Response>` | `rxRestore(List<String> args)` Redis command restore.
    `Maybe<Response>` | `rxRestoreAsking(List<String> args)` Redis command restoreAsking.
    `Maybe<Response>` | `rxRole()` Redis command role.
    `Maybe<Response>` | `rxRpop(List<String> args)` Redis command rpop.
    `Maybe<Response>` | `rxRpoplpush(String arg0, String arg1)` Redis command rpoplpush.
    `Maybe<Response>` | `rxRpush(List<String> args)` Redis command rpush.
    `Maybe<Response>` | `rxRpushx(List<String> args)` Redis command rpushx.
    `Maybe<Response>` | `rxSadd(List<String> args)` Redis command sadd.
    `Maybe<Response>` | `rxSave()` Redis command save.
    `Maybe<Response>` | `rxScan(List<String> args)` Redis command scan.
    `Maybe<Response>` | `rxScard(String arg0)` Redis command scard.
    `Maybe<Response>` | `rxScript(List<String> args)` Redis command script.
    `Maybe<Response>` | `rxSdiff(List<String> args)` Redis command sdiff.
    `Maybe<Response>` | `rxSdiffstore(List<String> args)` Redis command sdiffstore.
    `Maybe<Response>` | `rxSelect(String arg0)` Redis command select.
    `Maybe<Response>` | `rxSet(List<String> args)` Redis command set.
    `Maybe<Response>` | `rxSetbit(String arg0, String arg1, String arg2)` Redis command setbit.
    `Maybe<Response>` | `rxSetex(String arg0, String arg1, String arg2)` Redis command setex.
    `Maybe<Response>` | `rxSetnx(String arg0, String arg1)` Redis command setnx.
    `Maybe<Response>` | `rxSetrange(String arg0, String arg1, String arg2)` Redis command setrange.
    `Maybe<Response>` | `rxShutdown(List<String> args)` Redis command shutdown.
    `Maybe<Response>` | `rxSinter(List<String> args)` Redis command sinter.
    `Maybe<Response>` | `rxSintercard(List<String> args)` Redis command sintercard.
    `Maybe<Response>` | `rxSinterstore(List<String> args)` Redis command sinterstore.
    `Maybe<Response>` | `rxSismember(String arg0, String arg1)` Redis command sismember.
    `Maybe<Response>` | `rxSlaveof(String arg0, String arg1)` Redis command slaveof.
    `Maybe<Response>` | `rxSlowlog(List<String> args)` Redis command slowlog.
    `Maybe<Response>` | `rxSmembers(String arg0)` Redis command smembers.
    `Maybe<Response>` | `rxSmismember(List<String> args)` Redis command smismember.
    `Maybe<Response>` | `rxSmove(String arg0, String arg1, String arg2)` Redis command smove.
    `Maybe<Response>` | `rxSort(List<String> args)` Redis command sort.
    `Maybe<Response>` | `rxSortRo(List<String> args)` Redis command sortRo.
    `Maybe<Response>` | `rxSpop(List<String> args)` Redis command spop.
    `Maybe<Response>` | `rxSpublish(String arg0, String arg1)` Redis command spublish.
    `Maybe<Response>` | `rxSrandmember(List<String> args)` Redis command srandmember.
    `Maybe<Response>` | `rxSrem(List<String> args)` Redis command srem.
    `Maybe<Response>` | `rxSscan(List<String> args)` Redis command sscan.
    `Maybe<Response>` | `rxSsubscribe(List<String> args)` Redis command ssubscribe.
    `Maybe<Response>` | `rxStrlen(String arg0)` Redis command strlen.
    `Maybe<Response>` | `rxSubscribe(List<String> args)` Redis command subscribe.
    `Maybe<Response>` | `rxSubstr(String arg0, String arg1, String arg2)` Redis command substr.
    `Maybe<Response>` | `rxSunion(List<String> args)` Redis command sunion.
    `Maybe<Response>` | `rxSunionstore(List<String> args)` Redis command sunionstore.
    `Maybe<Response>` | `rxSunsubscribe(List<String> args)` Redis command sunsubscribe.
    `Maybe<Response>` | `rxSwapdb(String arg0, String arg1)` Redis command swapdb.
    `Maybe<Response>` | `rxSync()` Redis command sync.
    `Maybe<Response>` | `rxTime()` Redis command time.
    `Maybe<Response>` | `rxTimeseriesClusterset(List<String> args)` Redis command timeseriesClusterset.
    `Maybe<Response>` | `rxTimeseriesClustersetfromshard(List<String> args)` Redis command timeseriesClustersetfromshard.
    `Maybe<Response>` | `rxTimeseriesHello(List<String> args)` Redis command timeseriesHello.
    `Maybe<Response>` | `rxTimeseriesInfocluster(List<String> args)` Redis command timeseriesInfocluster.
    `Maybe<Response>` | `rxTimeseriesInnercommunication(List<String> args)` Redis command timeseriesInnercommunication.
    `Maybe<Response>` | `rxTimeseriesNetworktest(List<String> args)` Redis command timeseriesNetworktest.
    `Maybe<Response>` | `rxTimeseriesRefreshcluster(List<String> args)` Redis command timeseriesRefreshcluster.
    `Maybe<Response>` | `rxTopkAdd(List<String> args)` Redis command topkAdd.
    `Maybe<Response>` | `rxTopkCount(List<String> args)` Redis command topkCount.
    `Maybe<Response>` | `rxTopkIncrby(List<String> args)` Redis command topkIncrby.
    `Maybe<Response>` | `rxTopkInfo(List<String> args)` Redis command topkInfo.
    `Maybe<Response>` | `rxTopkList(List<String> args)` Redis command topkList.
    `Maybe<Response>` | `rxTopkQuery(List<String> args)` Redis command topkQuery.
    `Maybe<Response>` | `rxTopkReserve(List<String> args)` Redis command topkReserve.
    `Maybe<Response>` | `rxTouch(List<String> args)` Redis command touch.
    `Maybe<Response>` | `rxTsAdd(List<String> args)` Redis command tsAdd.
    `Maybe<Response>` | `rxTsAlter(List<String> args)` Redis command tsAlter.
    `Maybe<Response>` | `rxTsCreate(List<String> args)` Redis command tsCreate.
    `Maybe<Response>` | `rxTsCreaterule(List<String> args)` Redis command tsCreaterule.
    `Maybe<Response>` | `rxTsDecrby(List<String> args)` Redis command tsDecrby.
    `Maybe<Response>` | `rxTsDel(List<String> args)` Redis command tsDel.
    `Maybe<Response>` | `rxTsDeleterule(List<String> args)` Redis command tsDeleterule.
    `Maybe<Response>` | `rxTsGet(List<String> args)` Redis command tsGet.
    `Maybe<Response>` | `rxTsIncrby(List<String> args)` Redis command tsIncrby.
    `Maybe<Response>` | `rxTsInfo(List<String> args)` Redis command tsInfo.
    `Maybe<Response>` | `rxTsMadd(List<String> args)` Redis command tsMadd.
    `Maybe<Response>` | `rxTsMget(List<String> args)` Redis command tsMget.
    `Maybe<Response>` | `rxTsMrange(List<String> args)` Redis command tsMrange.
    `Maybe<Response>` | `rxTsMrevrange(List<String> args)` Redis command tsMrevrange.
    `Maybe<Response>` | `rxTsQueryindex(List<String> args)` Redis command tsQueryindex.
    `Maybe<Response>` | `rxTsRange(List<String> args)` Redis command tsRange.
    `Maybe<Response>` | `rxTsRevrange(List<String> args)` Redis command tsRevrange.
    `Maybe<Response>` | `rxTtl(String arg0)` Redis command ttl.
    `Maybe<Response>` | `rxType(String arg0)` Redis command type.
    `Maybe<Response>` | `rxUnlink(List<String> args)` Redis command unlink.
    `Maybe<Response>` | `rxUnsubscribe(List<String> args)` Redis command unsubscribe.
    `Maybe<Response>` | `rxUnwatch()` Redis command unwatch.
    `Maybe<Response>` | `rxWait(String arg0, String arg1)` Redis command wait.
    `Maybe<Response>` | `rxWatch(List<String> args)` Redis command watch.
    `Maybe<Response>` | `rxXack(List<String> args)` Redis command xack.
    `Maybe<Response>` | `rxXadd(List<String> args)` Redis command xadd.
    `Maybe<Response>` | `rxXautoclaim(List<String> args)` Redis command xautoclaim.
    `Maybe<Response>` | `rxXclaim(List<String> args)` Redis command xclaim.
    `Maybe<Response>` | `rxXdel(List<String> args)` Redis command xdel.
    `Maybe<Response>` | `rxXgroup(List<String> args)` Redis command xgroup.
    `Maybe<Response>` | `rxXinfo(List<String> args)` Redis command xinfo.
    `Maybe<Response>` | `rxXlen(String arg0)` Redis command xlen.
    `Maybe<Response>` | `rxXpending(List<String> args)` Redis command xpending.
    `Maybe<Response>` | `rxXrange(List<String> args)` Redis command xrange.
    `Maybe<Response>` | `rxXread(List<String> args)` Redis command xread.
    `Maybe<Response>` | `rxXreadgroup(List<String> args)` Redis command xreadgroup.
    `Maybe<Response>` | `rxXrevrange(List<String> args)` Redis command xrevrange.
    `Maybe<Response>` | `rxXsetid(List<String> args)` Redis command xsetid.
    `Maybe<Response>` | `rxXtrim(List<String> args)` Redis command xtrim.
    `Maybe<Response>` | `rxZadd(List<String> args)` Redis command zadd.
    `Maybe<Response>` | `rxZcard(String arg0)` Redis command zcard.
    `Maybe<Response>` | `rxZcount(String arg0, String arg1, String arg2)` Redis command zcount.
    `Maybe<Response>` | `rxZdiff(List<String> args)` Redis command zdiff.
    `Maybe<Response>` | `rxZdiffstore(List<String> args)` Redis command zdiffstore.
    `Maybe<Response>` | `rxZincrby(String arg0, String arg1, String arg2)` Redis command zincrby.
    `Maybe<Response>` | `rxZinter(List<String> args)` Redis command zinter.
    `Maybe<Response>` | `rxZintercard(List<String> args)` Redis command zintercard.
    `Maybe<Response>` | `rxZinterstore(List<String> args)` Redis command zinterstore.
    `Maybe<Response>` | `rxZlexcount(String arg0, String arg1, String arg2)` Redis command zlexcount.
    `Maybe<Response>` | `rxZmpop(List<String> args)` Redis command zmpop.
    `Maybe<Response>` | `rxZmscore(List<String> args)` Redis command zmscore.
    `Maybe<Response>` | `rxZpopmax(List<String> args)` Redis command zpopmax.
    `Maybe<Response>` | `rxZpopmin(List<String> args)` Redis command zpopmin.
    `Maybe<Response>` | `rxZrandmember(List<String> args)` Redis command zrandmember.
    `Maybe<Response>` | `rxZrange(List<String> args)` Redis command zrange.
    `Maybe<Response>` | `rxZrangebylex(List<String> args)` Redis command zrangebylex.
    `Maybe<Response>` | `rxZrangebyscore(List<String> args)` Redis command zrangebyscore.
    `Maybe<Response>` | `rxZrangestore(List<String> args)` Redis command zrangestore.
    `Maybe<Response>` | `rxZrank(String arg0, String arg1)` Redis command zrank.
    `Maybe<Response>` | `rxZrem(List<String> args)` Redis command zrem.
    `Maybe<Response>` | `rxZremrangebylex(String arg0, String arg1, String arg2)` Redis command zremrangebylex.
    `Maybe<Response>` | `rxZremrangebyrank(String arg0, String arg1, String arg2)` Redis command zremrangebyrank.
    `Maybe<Response>` | `rxZremrangebyscore(String arg0, String arg1, String arg2)` Redis command zremrangebyscore.
    `Maybe<Response>` | `rxZrevrange(List<String> args)` Redis command zrevrange.
    `Maybe<Response>` | `rxZrevrangebylex(List<String> args)` Redis command zrevrangebylex.
    `Maybe<Response>` | `rxZrevrangebyscore(List<String> args)` Redis command zrevrangebyscore.
    `Maybe<Response>` | `rxZrevrank(String arg0, String arg1)` Redis command zrevrank.
    `Maybe<Response>` | `rxZscan(List<String> args)` Redis command zscan.
    `Maybe<Response>` | `rxZscore(String arg0, String arg1)` Redis command zscore.
    `Maybe<Response>` | `rxZunion(List<String> args)` Redis command zunion.
    `Maybe<Response>` | `rxZunionstore(List<String> args)` Redis command zunionstore.
    `Maybe<Response>` | `sadd(List<String> args)` Redis command sadd.
    `Maybe<Response>` | `save()` Redis command save.
    `Maybe<Response>` | `scan(List<String> args)` Redis command scan.
    `Maybe<Response>` | `scard(String arg0)` Redis command scard.
    `Maybe<Response>` | `script(List<String> args)` Redis command script.
    `Maybe<Response>` | `sdiff(List<String> args)` Redis command sdiff.
    `Maybe<Response>` | `sdiffstore(List<String> args)` Redis command sdiffstore.
    `Maybe<Response>` | `select(String arg0)` Redis command select.
    `Maybe<Response>` | `set(List<String> args)` Redis command set.
    `Maybe<Response>` | `setbit(String arg0, String arg1, String arg2)` Redis command setbit.
    `Maybe<Response>` | `setex(String arg0, String arg1, String arg2)` Redis command setex.
    `Maybe<Response>` | `setnx(String arg0, String arg1)` Redis command setnx.
    `Maybe<Response>` | `setrange(String arg0, String arg1, String arg2)` Redis command setrange.
    `Maybe<Response>` | `shutdown(List<String> args)` Redis command shutdown.
    `Maybe<Response>` | `sinter(List<String> args)` Redis command sinter.
    `Maybe<Response>` | `sintercard(List<String> args)` Redis command sintercard.
    `Maybe<Response>` | `sinterstore(List<String> args)` Redis command sinterstore.
    `Maybe<Response>` | `sismember(String arg0, String arg1)` Redis command sismember.
    `Maybe<Response>` | `slaveof(String arg0, String arg1)` Redis command slaveof.
    `Maybe<Response>` | `slowlog(List<String> args)` Redis command slowlog.
    `Maybe<Response>` | `smembers(String arg0)` Redis command smembers.
    `Maybe<Response>` | `smismember(List<String> args)` Redis command smismember.
    `Maybe<Response>` | `smove(String arg0, String arg1, String arg2)` Redis command smove.
    `Maybe<Response>` | `sort(List<String> args)` Redis command sort.
    `Maybe<Response>` | `sortRo(List<String> args)` Redis command sortRo.
    `Maybe<Response>` | `spop(List<String> args)` Redis command spop.
    `Maybe<Response>` | `spublish(String arg0, String arg1)` Redis command spublish.
    `Maybe<Response>` | `srandmember(List<String> args)` Redis command srandmember.
    `Maybe<Response>` | `srem(List<String> args)` Redis command srem.
    `Maybe<Response>` | `sscan(List<String> args)` Redis command sscan.
    `Maybe<Response>` | `ssubscribe(List<String> args)` Redis command ssubscribe.
    `Maybe<Response>` | `strlen(String arg0)` Redis command strlen.
    `Maybe<Response>` | `subscribe(List<String> args)` Redis command subscribe.
    `Maybe<Response>` | `substr(String arg0, String arg1, String arg2)` Redis command substr.
    `Maybe<Response>` | `sunion(List<String> args)` Redis command sunion.
    `Maybe<Response>` | `sunionstore(List<String> args)` Redis command sunionstore.
    `Maybe<Response>` | `sunsubscribe(List<String> args)` Redis command sunsubscribe.
    `Maybe<Response>` | `swapdb(String arg0, String arg1)` Redis command swapdb.
    `Maybe<Response>` | `sync()` Redis command sync.
    `Maybe<Response>` | `time()` Redis command time.
    `Maybe<Response>` | `timeseriesClusterset(List<String> args)` Redis command timeseriesClusterset.
    `Maybe<Response>` | `timeseriesClustersetfromshard(List<String> args)` Redis command timeseriesClustersetfromshard.
    `Maybe<Response>` | `timeseriesHello(List<String> args)` Redis command timeseriesHello.
    `Maybe<Response>` | `timeseriesInfocluster(List<String> args)` Redis command timeseriesInfocluster.
    `Maybe<Response>` | `timeseriesInnercommunication(List<String> args)` Redis command timeseriesInnercommunication.
    `Maybe<Response>` | `timeseriesNetworktest(List<String> args)` Redis command timeseriesNetworktest.
    `Maybe<Response>` | `timeseriesRefreshcluster(List<String> args)` Redis command timeseriesRefreshcluster.
    `Maybe<Response>` | `topkAdd(List<String> args)` Redis command topkAdd.
    `Maybe<Response>` | `topkCount(List<String> args)` Redis command topkCount.
    `Maybe<Response>` | `topkIncrby(List<String> args)` Redis command topkIncrby.
    `Maybe<Response>` | `topkInfo(List<String> args)` Redis command topkInfo.
    `Maybe<Response>` | `topkList(List<String> args)` Redis command topkList.
    `Maybe<Response>` | `topkQuery(List<String> args)` Redis command topkQuery.
    `Maybe<Response>` | `topkReserve(List<String> args)` Redis command topkReserve.
    `String` | `toString()`
    `Maybe<Response>` | `touch(List<String> args)` Redis command touch.
    `Maybe<Response>` | `tsAdd(List<String> args)` Redis command tsAdd.
    `Maybe<Response>` | `tsAlter(List<String> args)` Redis command tsAlter.
    `Maybe<Response>` | `tsCreate(List<String> args)` Redis command tsCreate.
    `Maybe<Response>` | `tsCreaterule(List<String> args)` Redis command tsCreaterule.
    `Maybe<Response>` | `tsDecrby(List<String> args)` Redis command tsDecrby.
    `Maybe<Response>` | `tsDel(List<String> args)` Redis command tsDel.
    `Maybe<Response>` | `tsDeleterule(List<String> args)` Redis command tsDeleterule.
    `Maybe<Response>` | `tsGet(List<String> args)` Redis command tsGet.
    `Maybe<Response>` | `tsIncrby(List<String> args)` Redis command tsIncrby.
    `Maybe<Response>` | `tsInfo(List<String> args)` Redis command tsInfo.
    `Maybe<Response>` | `tsMadd(List<String> args)` Redis command tsMadd.
    `Maybe<Response>` | `tsMget(List<String> args)` Redis command tsMget.
    `Maybe<Response>` | `tsMrange(List<String> args)` Redis command tsMrange.
    `Maybe<Response>` | `tsMrevrange(List<String> args)` Redis command tsMrevrange.
    `Maybe<Response>` | `tsQueryindex(List<String> args)` Redis command tsQueryindex.
    `Maybe<Response>` | `tsRange(List<String> args)` Redis command tsRange.
    `Maybe<Response>` | `tsRevrange(List<String> args)` Redis command tsRevrange.
    `Maybe<Response>` | `ttl(String arg0)` Redis command ttl.
    `Maybe<Response>` | `type(String arg0)` Redis command type.
    `Maybe<Response>` | `unlink(List<String> args)` Redis command unlink.
    `Maybe<Response>` | `unsubscribe(List<String> args)` Redis command unsubscribe.
    `Maybe<Response>` | `unwatch()` Redis command unwatch.
    `Maybe<Response>` | `wait(String arg0, String arg1)` Redis command wait.
    `Maybe<Response>` | `watch(List<String> args)` Redis command watch.
    `Maybe<Response>` | `xack(List<String> args)` Redis command xack.
    `Maybe<Response>` | `xadd(List<String> args)` Redis command xadd.
    `Maybe<Response>` | `xautoclaim(List<String> args)` Redis command xautoclaim.
    `Maybe<Response>` | `xclaim(List<String> args)` Redis command xclaim.
    `Maybe<Response>` | `xdel(List<String> args)` Redis command xdel.
    `Maybe<Response>` | `xgroup(List<String> args)` Redis command xgroup.
    `Maybe<Response>` | `xinfo(List<String> args)` Redis command xinfo.
    `Maybe<Response>` | `xlen(String arg0)` Redis command xlen.
    `Maybe<Response>` | `xpending(List<String> args)` Redis command xpending.
    `Maybe<Response>` | `xrange(List<String> args)` Redis command xrange.
    `Maybe<Response>` | `xread(List<String> args)` Redis command xread.
    `Maybe<Response>` | `xreadgroup(List<String> args)` Redis command xreadgroup.
    `Maybe<Response>` | `xrevrange(List<String> args)` Redis command xrevrange.
    `Maybe<Response>` | `xsetid(List<String> args)` Redis command xsetid.
    `Maybe<Response>` | `xtrim(List<String> args)` Redis command xtrim.
    `Maybe<Response>` | `zadd(List<String> args)` Redis command zadd.
    `Maybe<Response>` | `zcard(String arg0)` Redis command zcard.
    `Maybe<Response>` | `zcount(String arg0, String arg1, String arg2)` Redis command zcount.
    `Maybe<Response>` | `zdiff(List<String> args)` Redis command zdiff.
    `Maybe<Response>` | `zdiffstore(List<String> args)` Redis command zdiffstore.
    `Maybe<Response>` | `zincrby(String arg0, String arg1, String arg2)` Redis command zincrby.
    `Maybe<Response>` | `zinter(List<String> args)` Redis command zinter.
    `Maybe<Response>` | `zintercard(List<String> args)` Redis command zintercard.
    `Maybe<Response>` | `zinterstore(List<String> args)` Redis command zinterstore.
    `Maybe<Response>` | `zlexcount(String arg0, String arg1, String arg2)` Redis command zlexcount.
    `Maybe<Response>` | `zmpop(List<String> args)` Redis command zmpop.
    `Maybe<Response>` | `zmscore(List<String> args)` Redis command zmscore.
    `Maybe<Response>` | `zpopmax(List<String> args)` Redis command zpopmax.
    `Maybe<Response>` | `zpopmin(List<String> args)` Redis command zpopmin.
    `Maybe<Response>` | `zrandmember(List<String> args)` Redis command zrandmember.
    `Maybe<Response>` | `zrange(List<String> args)` Redis command zrange.
    `Maybe<Response>` | `zrangebylex(List<String> args)` Redis command zrangebylex.
    `Maybe<Response>` | `zrangebyscore(List<String> args)` Redis command zrangebyscore.
    `Maybe<Response>` | `zrangestore(List<String> args)` Redis command zrangestore.
    `Maybe<Response>` | `zrank(String arg0, String arg1)` Redis command zrank.
    `Maybe<Response>` | `zrem(List<String> args)` Redis command zrem.
    `Maybe<Response>` | `zremrangebylex(String arg0, String arg1, String arg2)` Redis command zremrangebylex.
    `Maybe<Response>` | `zremrangebyrank(String arg0, String arg1, String arg2)` Redis command zremrangebyrank.
    `Maybe<Response>` | `zremrangebyscore(String arg0, String arg1, String arg2)` Redis command zremrangebyscore.
    `Maybe<Response>` | `zrevrange(List<String> args)` Redis command zrevrange.
    `Maybe<Response>` | `zrevrangebylex(List<String> args)` Redis command zrevrangebylex.
    `Maybe<Response>` | `zrevrangebyscore(List<String> args)` Redis command zrevrangebyscore.
    `Maybe<Response>` | `zrevrank(String arg0, String arg1)` Redis command zrevrank.
    `Maybe<Response>` | `zscan(List<String> args)` Redis command zscan.
    `Maybe<Response>` | `zscore(String arg0, String arg1)` Redis command zscore.
    `Maybe<Response>` | `zunion(List<String> args)` Redis command zunion.
    `Maybe<Response>` | `zunionstore(List<String> args)` 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 Maybe<Response> ftAdd(List<String> args)

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

    - #### rxFtAdd

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

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

    - #### ftAggregate

          public Maybe<Response> ftAggregate(List<String> args)

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

    - #### rxFtAggregate

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

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

    - #### ftAliasadd

          public Maybe<Response> ftAliasadd(List<String> args)

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

    - #### rxFtAliasadd

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

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

    - #### ftAliasdel

          public Maybe<Response> ftAliasdel(List<String> args)

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

    - #### rxFtAliasdel

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

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

    - #### ftAliasupdate

          public Maybe<Response> ftAliasupdate(List<String> args)

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

    - #### rxFtAliasupdate

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

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

    - #### ftAlter

          public Maybe<Response> ftAlter(List<String> args)

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

    - #### rxFtAlter

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

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

    - #### ftConfig

          public Maybe<Response> ftConfig(List<String> args)

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

    - #### rxFtConfig

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

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

    - #### ftCreate

          public Maybe<Response> ftCreate(List<String> args)

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

    - #### rxFtCreate

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

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

    - #### ftCursor

          public Maybe<Response> ftCursor(List<String> args)

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

    - #### rxFtCursor

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

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

    - #### ftDebug

          public Maybe<Response> ftDebug(List<String> args)

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

    - #### rxFtDebug

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

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

    - #### ftDel

          public Maybe<Response> ftDel(List<String> args)

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

    - #### rxFtDel

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

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

    - #### ftDictadd

          public Maybe<Response> ftDictadd(List<String> args)

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

    - #### rxFtDictadd

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

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

    - #### ftDictdel

          public Maybe<Response> ftDictdel(List<String> args)

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

    - #### rxFtDictdel

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

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

    - #### ftDictdump

          public Maybe<Response> ftDictdump(List<String> args)

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

    - #### rxFtDictdump

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

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

    - #### ftDrop

          public Maybe<Response> ftDrop(List<String> args)

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

    - #### rxFtDrop

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

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

    - #### ftDropindex

          public Maybe<Response> ftDropindex(List<String> args)

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

    - #### rxFtDropindex

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

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

    - #### ftExplain

          public Maybe<Response> ftExplain(List<String> args)

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

    - #### rxFtExplain

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

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

    - #### ftExplaincli

          public Maybe<Response> ftExplaincli(List<String> args)

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

    - #### rxFtExplaincli

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

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

    - #### ftGet

          public Maybe<Response> ftGet(List<String> args)

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

    - #### rxFtGet

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

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

    - #### ftInfo

          public Maybe<Response> ftInfo(List<String> args)

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

    - #### rxFtInfo

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

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

    - #### ftMget

          public Maybe<Response> ftMget(List<String> args)

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

    - #### rxFtMget

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

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

    - #### ftProfile

          public Maybe<Response> ftProfile(List<String> args)

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

    - #### rxFtProfile

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

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

    - #### ftSafeadd

          public Maybe<Response> ftSafeadd(List<String> args)

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

    - #### rxFtSafeadd

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

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

    - #### ftSearch

          public Maybe<Response> ftSearch(List<String> args)

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

    - #### rxFtSearch

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

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

    - #### ftSpellcheck

          public Maybe<Response> ftSpellcheck(List<String> args)

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

    - #### rxFtSpellcheck

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

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

    - #### ftSugadd

          public Maybe<Response> ftSugadd(List<String> args)

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

    - #### rxFtSugadd

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

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

    - #### ftSugdel

          public Maybe<Response> ftSugdel(List<String> args)

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

    - #### rxFtSugdel

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

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

    - #### ftSugget

          public Maybe<Response> ftSugget(List<String> args)

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

    - #### rxFtSugget

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

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

    - #### ftSuglen

          public Maybe<Response> ftSuglen(List<String> args)

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

    - #### rxFtSuglen

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

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

    - #### ftSynadd

          public Maybe<Response> ftSynadd(List<String> args)

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

    - #### rxFtSynadd

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

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

    - #### ftSyndump

          public Maybe<Response> ftSyndump(List<String> args)

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

    - #### rxFtSyndump

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

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

    - #### ftSynupdate

          public Maybe<Response> ftSynupdate(List<String> args)

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

    - #### rxFtSynupdate

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

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

    - #### ftTagvals

          public Maybe<Response> ftTagvals(List<String> args)

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

    - #### rxFtTagvals

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

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

    - #### ftAliasaddifnx

          public Maybe<Response> ftAliasaddifnx(List<String> args)

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

    - #### rxFtAliasaddifnx

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

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

    - #### ftAliasdelifx

          public Maybe<Response> ftAliasdelifx(List<String> args)

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

    - #### rxFtAliasdelifx

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

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

    - #### ftAlterifnx

          public Maybe<Response> ftAlterifnx(List<String> args)

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

    - #### rxFtAlterifnx

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

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

    - #### ftCreateifnx

          public Maybe<Response> ftCreateifnx(List<String> args)

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

    - #### rxFtCreateifnx

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

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

    - #### ftDropifx

          public Maybe<Response> ftDropifx(List<String> args)

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

    - #### rxFtDropifx

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

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

    - #### ftDropindexifx

          public Maybe<Response> ftDropindexifx(List<String> args)

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

    - #### rxFtDropindexifx

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

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

    - #### ftList

          public Maybe<Response> ftList(List<String> args)

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

    - #### rxFtList

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

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

    - #### acl

          public Maybe<Response> acl(List<String> args)

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

    - #### rxAcl

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

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

    - #### append

          public Maybe<Response> append(String arg0,
                                        String arg1)

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

    - #### rxAppend

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

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

    - #### asking

          public Maybe<Response> asking()

      Redis command asking.
      Returns:
        fluent self

    - #### rxAsking

          public Maybe<Response> rxAsking()

      Redis command asking.
      Returns:
        fluent self

    - #### auth

          public Maybe<Response> auth(List<String> args)

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

    - #### rxAuth

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

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

    - #### bfAdd

          public Maybe<Response> bfAdd(List<String> args)

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

    - #### rxBfAdd

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

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

    - #### bfDebug

          public Maybe<Response> bfDebug(List<String> args)

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

    - #### rxBfDebug

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

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

    - #### bfExists

          public Maybe<Response> bfExists(List<String> args)

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

    - #### rxBfExists

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

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

    - #### bfInfo

          public Maybe<Response> bfInfo(List<String> args)

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

    - #### rxBfInfo

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

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

    - #### bfInsert

          public Maybe<Response> bfInsert(List<String> args)

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

    - #### rxBfInsert

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

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

    - #### bfLoadchunk

          public Maybe<Response> bfLoadchunk(List<String> args)

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

    - #### rxBfLoadchunk

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

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

    - #### bfMadd

          public Maybe<Response> bfMadd(List<String> args)

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

    - #### rxBfMadd

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

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

    - #### bfMexists

          public Maybe<Response> bfMexists(List<String> args)

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

    - #### rxBfMexists

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

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

    - #### bfReserve

          public Maybe<Response> bfReserve(List<String> args)

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

    - #### rxBfReserve

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

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

    - #### bfScandump

          public Maybe<Response> bfScandump(List<String> args)

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

    - #### rxBfScandump

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

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

    - #### bgrewriteaof

          public Maybe<Response> bgrewriteaof()

      Redis command bgrewriteaof.
      Returns:
        fluent self

    - #### rxBgrewriteaof

          public Maybe<Response> rxBgrewriteaof()

      Redis command bgrewriteaof.
      Returns:
        fluent self

    - #### bgsave

          public Maybe<Response> bgsave(List<String> args)

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

    - #### rxBgsave

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

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

    - #### bitcount

          public Maybe<Response> bitcount(List<String> args)

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

    - #### rxBitcount

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

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

    - #### bitfield

          public Maybe<Response> bitfield(List<String> args)

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

    - #### rxBitfield

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

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

    - #### bitfieldRo

          public Maybe<Response> bitfieldRo(List<String> args)

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

    - #### rxBitfieldRo

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

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

    - #### bitop

          public Maybe<Response> bitop(List<String> args)

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

    - #### rxBitop

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

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

    - #### bitpos

          public Maybe<Response> bitpos(List<String> args)

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

    - #### rxBitpos

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

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

    - #### blmove

          public Maybe<Response> 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 Maybe<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 Maybe<Response> blmpop(List<String> args)

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

    - #### rxBlmpop

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

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

    - #### blpop

          public Maybe<Response> blpop(List<String> args)

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

    - #### rxBlpop

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

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

    - #### brpop

          public Maybe<Response> brpop(List<String> args)

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

    - #### rxBrpop

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

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

    - #### brpoplpush

          public Maybe<Response> brpoplpush(String arg0,
                                            String arg1,
                                            String arg2)

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

    - #### rxBrpoplpush

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

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

    - #### bzmpop

          public Maybe<Response> bzmpop(List<String> args)

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

    - #### rxBzmpop

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

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

    - #### bzpopmax

          public Maybe<Response> bzpopmax(List<String> args)

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

    - #### rxBzpopmax

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

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

    - #### bzpopmin

          public Maybe<Response> bzpopmin(List<String> args)

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

    - #### rxBzpopmin

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

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

    - #### cfAdd

          public Maybe<Response> cfAdd(List<String> args)

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

    - #### rxCfAdd

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

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

    - #### cfAddnx

          public Maybe<Response> cfAddnx(List<String> args)

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

    - #### rxCfAddnx

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

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

    - #### cfCompact

          public Maybe<Response> cfCompact(List<String> args)

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

    - #### rxCfCompact

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

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

    - #### cfCount

          public Maybe<Response> cfCount(List<String> args)

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

    - #### rxCfCount

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

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

    - #### cfDebug

          public Maybe<Response> cfDebug(List<String> args)

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

    - #### rxCfDebug

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

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

    - #### cfDel

          public Maybe<Response> cfDel(List<String> args)

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

    - #### rxCfDel

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

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

    - #### cfExists

          public Maybe<Response> cfExists(List<String> args)

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

    - #### rxCfExists

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

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

    - #### cfInfo

          public Maybe<Response> cfInfo(List<String> args)

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

    - #### rxCfInfo

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

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

    - #### cfInsert

          public Maybe<Response> cfInsert(List<String> args)

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

    - #### rxCfInsert

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

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

    - #### cfInsertnx

          public Maybe<Response> cfInsertnx(List<String> args)

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

    - #### rxCfInsertnx

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

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

    - #### cfLoadchunk

          public Maybe<Response> cfLoadchunk(List<String> args)

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

    - #### rxCfLoadchunk

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

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

    - #### cfMexists

          public Maybe<Response> cfMexists(List<String> args)

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

    - #### rxCfMexists

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

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

    - #### cfReserve

          public Maybe<Response> cfReserve(List<String> args)

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

    - #### rxCfReserve

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

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

    - #### cfScandump

          public Maybe<Response> cfScandump(List<String> args)

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

    - #### rxCfScandump

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

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

    - #### client

          public Maybe<Response> client(List<String> args)

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

    - #### rxClient

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

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

    - #### cluster

          public Maybe<Response> cluster(List<String> args)

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

    - #### rxCluster

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

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

    - #### cmsIncrby

          public Maybe<Response> cmsIncrby(List<String> args)

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

    - #### rxCmsIncrby

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

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

    - #### cmsInfo

          public Maybe<Response> cmsInfo(List<String> args)

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

    - #### rxCmsInfo

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

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

    - #### cmsInitbydim

          public Maybe<Response> cmsInitbydim(List<String> args)

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

    - #### rxCmsInitbydim

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

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

    - #### cmsInitbyprob

          public Maybe<Response> cmsInitbyprob(List<String> args)

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

    - #### rxCmsInitbyprob

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

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

    - #### cmsMerge

          public Maybe<Response> cmsMerge(List<String> args)

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

    - #### rxCmsMerge

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

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

    - #### cmsQuery

          public Maybe<Response> cmsQuery(List<String> args)

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

    - #### rxCmsQuery

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

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

    - #### command

          public Maybe<Response> command(List<String> args)

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

    - #### rxCommand

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

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

    - #### config

          public Maybe<Response> config(List<String> args)

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

    - #### rxConfig

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

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

    - #### copy

          public Maybe<Response> copy(List<String> args)

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

    - #### rxCopy

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

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

    - #### dbsize

          public Maybe<Response> dbsize()

      Redis command dbsize.
      Returns:
        fluent self

    - #### rxDbsize

          public Maybe<Response> rxDbsize()

      Redis command dbsize.
      Returns:
        fluent self

    - #### debug

          public Maybe<Response> debug(List<String> args)

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

    - #### rxDebug

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

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

    - #### decr

          public Maybe<Response> decr(String arg0)

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

    - #### rxDecr

          public Maybe<Response> rxDecr(String arg0)

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

    - #### decrby

          public Maybe<Response> decrby(String arg0,
                                        String arg1)

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

    - #### rxDecrby

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

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

    - #### del

          public Maybe<Response> del(List<String> args)

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

    - #### rxDel

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

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

    - #### discard

          public Maybe<Response> discard()

      Redis command discard.
      Returns:
        fluent self

    - #### rxDiscard

          public Maybe<Response> rxDiscard()

      Redis command discard.
      Returns:
        fluent self

    - #### dump

          public Maybe<Response> dump(String arg0)

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

    - #### rxDump

          public Maybe<Response> rxDump(String arg0)

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

    - #### echo

          public Maybe<Response> echo(String arg0)

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

    - #### rxEcho

          public Maybe<Response> rxEcho(String arg0)

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

    - #### eval

          public Maybe<Response> eval(List<String> args)

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

    - #### rxEval

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

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

    - #### evalRo

          public Maybe<Response> evalRo(List<String> args)

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

    - #### rxEvalRo

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

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

    - #### evalsha

          public Maybe<Response> evalsha(List<String> args)

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

    - #### rxEvalsha

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

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

    - #### evalshaRo

          public Maybe<Response> evalshaRo(List<String> args)

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

    - #### rxEvalshaRo

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

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

    - #### exec

          public Maybe<Response> exec()

      Redis command exec.
      Returns:
        fluent self

    - #### rxExec

          public Maybe<Response> rxExec()

      Redis command exec.
      Returns:
        fluent self

    - #### exists

          public Maybe<Response> exists(List<String> args)

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

    - #### rxExists

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

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

    - #### expire

          public Maybe<Response> expire(List<String> args)

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

    - #### rxExpire

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

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

    - #### expireat

          public Maybe<Response> expireat(List<String> args)

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

    - #### rxExpireat

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

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

    - #### expiretime

          public Maybe<Response> expiretime(String arg0)

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

    - #### rxExpiretime

          public Maybe<Response> rxExpiretime(String arg0)

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

    - #### failover

          public Maybe<Response> failover(List<String> args)

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

    - #### rxFailover

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

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

    - #### fcall

          public Maybe<Response> fcall(List<String> args)

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

    - #### rxFcall

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

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

    - #### fcallRo

          public Maybe<Response> fcallRo(List<String> args)

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

    - #### rxFcallRo

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

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

    - #### flushall

          public Maybe<Response> flushall(List<String> args)

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

    - #### rxFlushall

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

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

    - #### flushdb

          public Maybe<Response> flushdb(List<String> args)

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

    - #### rxFlushdb

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

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

    - #### function

          public Maybe<Response> function(List<String> args)

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

    - #### rxFunction

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

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

    - #### geoadd

          public Maybe<Response> geoadd(List<String> args)

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

    - #### rxGeoadd

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

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

    - #### geodist

          public Maybe<Response> geodist(List<String> args)

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

    - #### rxGeodist

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

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

    - #### geohash

          public Maybe<Response> geohash(List<String> args)

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

    - #### rxGeohash

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

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

    - #### geopos

          public Maybe<Response> geopos(List<String> args)

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

    - #### rxGeopos

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

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

    - #### georadius

          public Maybe<Response> georadius(List<String> args)

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

    - #### rxGeoradius

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

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

    - #### georadiusRo

          public Maybe<Response> georadiusRo(List<String> args)

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

    - #### rxGeoradiusRo

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

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

    - #### georadiusbymember

          public Maybe<Response> georadiusbymember(List<String> args)

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

    - #### rxGeoradiusbymember

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

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

    - #### georadiusbymemberRo

          public Maybe<Response> georadiusbymemberRo(List<String> args)

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

    - #### rxGeoradiusbymemberRo

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

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

    - #### geosearch

          public Maybe<Response> geosearch(List<String> args)

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

    - #### rxGeosearch

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

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

    - #### geosearchstore

          public Maybe<Response> geosearchstore(List<String> args)

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

    - #### rxGeosearchstore

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

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

    - #### get

          public Maybe<Response> get(String arg0)

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

    - #### rxGet

          public Maybe<Response> rxGet(String arg0)

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

    - #### getbit

          public Maybe<Response> getbit(String arg0,
                                        String arg1)

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

    - #### rxGetbit

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

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

    - #### getdel

          public Maybe<Response> getdel(String arg0)

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

    - #### rxGetdel

          public Maybe<Response> rxGetdel(String arg0)

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

    - #### getex

          public Maybe<Response> getex(List<String> args)

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

    - #### rxGetex

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

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

    - #### getrange

          public Maybe<Response> getrange(String arg0,
                                          String arg1,
                                          String arg2)

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

    - #### rxGetrange

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

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

    - #### getset

          public Maybe<Response> getset(String arg0,
                                        String arg1)

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

    - #### rxGetset

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

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

    - #### graphBulk

          public Maybe<Response> graphBulk(List<String> args)

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

    - #### rxGraphBulk

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

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

    - #### graphConfig

          public Maybe<Response> graphConfig(List<String> args)

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

    - #### rxGraphConfig

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

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

    - #### graphDebug

          public Maybe<Response> graphDebug(List<String> args)

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

    - #### rxGraphDebug

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

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

    - #### graphDelete

          public Maybe<Response> graphDelete(List<String> args)

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

    - #### rxGraphDelete

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

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

    - #### graphExplain

          public Maybe<Response> graphExplain(List<String> args)

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

    - #### rxGraphExplain

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

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

    - #### graphList

          public Maybe<Response> graphList(List<String> args)

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

    - #### rxGraphList

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

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

    - #### graphProfile

          public Maybe<Response> graphProfile(List<String> args)

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

    - #### rxGraphProfile

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

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

    - #### graphQuery

          public Maybe<Response> graphQuery(List<String> args)

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

    - #### rxGraphQuery

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

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

    - #### graphRoQuery

          public Maybe<Response> graphRoQuery(List<String> args)

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

    - #### rxGraphRoQuery

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

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

    - #### graphSlowlog

          public Maybe<Response> graphSlowlog(List<String> args)

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

    - #### rxGraphSlowlog

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

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

    - #### hdel

          public Maybe<Response> hdel(List<String> args)

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

    - #### rxHdel

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

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

    - #### hello

          public Maybe<Response> hello(List<String> args)

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

    - #### rxHello

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

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

    - #### hexists

          public Maybe<Response> hexists(String arg0,
                                         String arg1)

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

    - #### rxHexists

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

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

    - #### hget

          public Maybe<Response> hget(String arg0,
                                      String arg1)

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

    - #### rxHget

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

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

    - #### hgetall

          public Maybe<Response> hgetall(String arg0)

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

    - #### rxHgetall

          public Maybe<Response> rxHgetall(String arg0)

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

    - #### hincrby

          public Maybe<Response> hincrby(String arg0,
                                         String arg1,
                                         String arg2)

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

    - #### rxHincrby

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

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

    - #### hincrbyfloat

          public Maybe<Response> hincrbyfloat(String arg0,
                                              String arg1,
                                              String arg2)

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

    - #### rxHincrbyfloat

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

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

    - #### hkeys

          public Maybe<Response> hkeys(String arg0)

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

    - #### rxHkeys

          public Maybe<Response> rxHkeys(String arg0)

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

    - #### hlen

          public Maybe<Response> hlen(String arg0)

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

    - #### rxHlen

          public Maybe<Response> rxHlen(String arg0)

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

    - #### hmget

          public Maybe<Response> hmget(List<String> args)

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

    - #### rxHmget

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

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

    - #### hmset

          public Maybe<Response> hmset(List<String> args)

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

    - #### rxHmset

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

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

    - #### hrandfield

          public Maybe<Response> hrandfield(List<String> args)

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

    - #### rxHrandfield

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

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

    - #### hscan

          public Maybe<Response> hscan(List<String> args)

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

    - #### rxHscan

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

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

    - #### hset

          public Maybe<Response> hset(List<String> args)

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

    - #### rxHset

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

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

    - #### hsetnx

          public Maybe<Response> hsetnx(String arg0,
                                        String arg1,
                                        String arg2)

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

    - #### rxHsetnx

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

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

    - #### hstrlen

          public Maybe<Response> hstrlen(String arg0,
                                         String arg1)

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

    - #### rxHstrlen

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

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

    - #### hvals

          public Maybe<Response> hvals(String arg0)

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

    - #### rxHvals

          public Maybe<Response> rxHvals(String arg0)

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

    - #### incr

          public Maybe<Response> incr(String arg0)

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

    - #### rxIncr

          public Maybe<Response> rxIncr(String arg0)

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

    - #### incrby

          public Maybe<Response> incrby(String arg0,
                                        String arg1)

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

    - #### rxIncrby

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

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

    - #### incrbyfloat

          public Maybe<Response> incrbyfloat(String arg0,
                                             String arg1)

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

    - #### rxIncrbyfloat

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

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

    - #### info

          public Maybe<Response> info(List<String> args)

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

    - #### rxInfo

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

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

    - #### jsonArrappend

          public Maybe<Response> jsonArrappend(List<String> args)

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

    - #### rxJsonArrappend

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

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

    - #### jsonArrindex

          public Maybe<Response> jsonArrindex(List<String> args)

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

    - #### rxJsonArrindex

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

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

    - #### jsonArrinsert

          public Maybe<Response> jsonArrinsert(List<String> args)

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

    - #### rxJsonArrinsert

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

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

    - #### jsonArrlen

          public Maybe<Response> jsonArrlen(List<String> args)

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

    - #### rxJsonArrlen

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

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

    - #### jsonArrpop

          public Maybe<Response> jsonArrpop(List<String> args)

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

    - #### rxJsonArrpop

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

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

    - #### jsonArrtrim

          public Maybe<Response> jsonArrtrim(List<String> args)

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

    - #### rxJsonArrtrim

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

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

    - #### jsonClear

          public Maybe<Response> jsonClear(List<String> args)

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

    - #### rxJsonClear

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

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

    - #### jsonDebug

          public Maybe<Response> jsonDebug(List<String> args)

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

    - #### rxJsonDebug

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

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

    - #### jsonDel

          public Maybe<Response> jsonDel(List<String> args)

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

    - #### rxJsonDel

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

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

    - #### jsonForget

          public Maybe<Response> jsonForget(List<String> args)

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

    - #### rxJsonForget

          public Maybe<Response> rxJsonForget(List<String> args)

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

    - #### jsonGet

          public Maybe<Response> jsonGet(List<String> args)

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

    - #### rxJsonGet

          public Maybe<Response> rxJsonGet(List<String> args)

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

    - #### jsonMget

          public Maybe<Response> jsonMget(List<String> args)

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

    - #### rxJsonMget

          public Maybe<Response> rxJsonMget(List<String> args)

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

    - #### jsonNumincrby

          public Maybe<Response> jsonNumincrby(List<String> args)

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

    - #### rxJsonNumincrby

          public Maybe<Response> rxJsonNumincrby(List<String> args)

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

    - #### jsonNummultby

          public Maybe<Response> jsonNummultby(List<String> args)

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

    - #### rxJsonNummultby

          public Maybe<Response> rxJsonNummultby(List<String> args)

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

    - #### jsonNumpowby

          public Maybe<Response> jsonNumpowby(List<String> args)

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

    - #### rxJsonNumpowby

          public Maybe<Response> rxJsonNumpowby(List<String> args)

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

    - #### jsonObjkeys

          public Maybe<Response> jsonObjkeys(List<String> args)

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

    - #### rxJsonObjkeys

          public Maybe<Response> rxJsonObjkeys(List<String> args)

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

    - #### jsonObjlen

          public Maybe<Response> jsonObjlen(List<String> args)

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

    - #### rxJsonObjlen

          public Maybe<Response> rxJsonObjlen(List<String> args)

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

    - #### jsonResp

          public Maybe<Response> jsonResp(List<String> args)

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

    - #### rxJsonResp

          public Maybe<Response> rxJsonResp(List<String> args)

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

    - #### jsonSet

          public Maybe<Response> jsonSet(List<String> args)

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

    - #### rxJsonSet

          public Maybe<Response> rxJsonSet(List<String> args)

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

    - #### jsonStrappend

          public Maybe<Response> jsonStrappend(List<String> args)

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

    - #### rxJsonStrappend

          public Maybe<Response> rxJsonStrappend(List<String> args)

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

    - #### jsonStrlen

          public Maybe<Response> jsonStrlen(List<String> args)

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

    - #### rxJsonStrlen

          public Maybe<Response> rxJsonStrlen(List<String> args)

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

    - #### jsonToggle

          public Maybe<Response> jsonToggle(List<String> args)

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

    - #### rxJsonToggle

          public Maybe<Response> rxJsonToggle(List<String> args)

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

    - #### jsonType

          public Maybe<Response> jsonType(List<String> args)

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

    - #### rxJsonType

          public Maybe<Response> rxJsonType(List<String> args)

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

    - #### keys

          public Maybe<Response> keys(String arg0)

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

    - #### rxKeys

          public Maybe<Response> rxKeys(String arg0)

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

    - #### lastsave

          public Maybe<Response> lastsave()

      Redis command lastsave.
      Returns:
        fluent self

    - #### rxLastsave

          public Maybe<Response> rxLastsave()

      Redis command lastsave.
      Returns:
        fluent self

    - #### latency

          public Maybe<Response> latency(List<String> args)

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

    - #### rxLatency

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

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

    - #### lcs

          public Maybe<Response> lcs(List<String> args)

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

    - #### rxLcs

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

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

    - #### lindex

          public Maybe<Response> lindex(String arg0,
                                        String arg1)

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

    - #### rxLindex

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

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

    - #### linsert

          public Maybe<Response> linsert(String arg0,
                                         String arg1,
                                         String arg2,
                                         String arg3)

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

    - #### rxLinsert

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

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

    - #### llen

          public Maybe<Response> llen(String arg0)

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

    - #### rxLlen

          public Maybe<Response> rxLlen(String arg0)

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

    - #### lmove

          public Maybe<Response> lmove(String arg0,
                                       String arg1,
                                       String arg2,
                                       String arg3)

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

    - #### rxLmove

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

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

    - #### lmpop

          public Maybe<Response> lmpop(List<String> args)

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

    - #### rxLmpop

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

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

    - #### lolwut

          public Maybe<Response> lolwut(List<String> args)

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

    - #### rxLolwut

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

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

    - #### lpop

          public Maybe<Response> lpop(List<String> args)

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

    - #### rxLpop

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

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

    - #### lpos

          public Maybe<Response> lpos(List<String> args)

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

    - #### rxLpos

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

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

    - #### lpush

          public Maybe<Response> lpush(List<String> args)

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

    - #### rxLpush

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

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

    - #### lpushx

          public Maybe<Response> lpushx(List<String> args)

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

    - #### rxLpushx

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

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

    - #### lrange

          public Maybe<Response> lrange(String arg0,
                                        String arg1,
                                        String arg2)

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

    - #### rxLrange

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

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

    - #### lrem

          public Maybe<Response> lrem(String arg0,
                                      String arg1,
                                      String arg2)

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

    - #### rxLrem

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

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

    - #### lset

          public Maybe<Response> lset(String arg0,
                                      String arg1,
                                      String arg2)

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

    - #### rxLset

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

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

    - #### ltrim

          public Maybe<Response> ltrim(String arg0,
                                       String arg1,
                                       String arg2)

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

    - #### rxLtrim

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

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

    - #### memory

          public Maybe<Response> memory(List<String> args)

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

    - #### rxMemory

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

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

    - #### mget

          public Maybe<Response> mget(List<String> args)

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

    - #### rxMget

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

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

    - #### migrate

          public Maybe<Response> migrate(List<String> args)

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

    - #### rxMigrate

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

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

    - #### module

          public Maybe<Response> module(List<String> args)

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

    - #### rxModule

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

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

    - #### monitor

          public Maybe<Response> monitor()

      Redis command monitor.
      Returns:
        fluent self

    - #### rxMonitor

          public Maybe<Response> rxMonitor()

      Redis command monitor.
      Returns:
        fluent self

    - #### move

          public Maybe<Response> move(String arg0,
                                      String arg1)

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

    - #### rxMove

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

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

    - #### mset

          public Maybe<Response> mset(List<String> args)

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

    - #### rxMset

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

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

    - #### msetnx

          public Maybe<Response> msetnx(List<String> args)

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

    - #### rxMsetnx

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

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

    - #### multi

          public Maybe<Response> multi()

      Redis command multi.
      Returns:
        fluent self

    - #### rxMulti

          public Maybe<Response> rxMulti()

      Redis command multi.
      Returns:
        fluent self

    - #### object

          public Maybe<Response> object(List<String> args)

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

    - #### rxObject

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

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

    - #### persist

          public Maybe<Response> persist(String arg0)

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

    - #### rxPersist

          public Maybe<Response> rxPersist(String arg0)

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

    - #### pexpire

          public Maybe<Response> pexpire(List<String> args)

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

    - #### rxPexpire

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

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

    - #### pexpireat

          public Maybe<Response> pexpireat(List<String> args)

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

    - #### rxPexpireat

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

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

    - #### pexpiretime

          public Maybe<Response> pexpiretime(String arg0)

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

    - #### rxPexpiretime

          public Maybe<Response> rxPexpiretime(String arg0)

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

    - #### pfadd

          public Maybe<Response> pfadd(List<String> args)

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

    - #### rxPfadd

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

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

    - #### pfcount

          public Maybe<Response> pfcount(List<String> args)

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

    - #### rxPfcount

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

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

    - #### pfdebug

          public Maybe<Response> pfdebug(List<String> args)

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

    - #### rxPfdebug

          public Maybe<Response> rxPfdebug(List<String> args)

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

    - #### pfmerge

          public Maybe<Response> pfmerge(List<String> args)

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

    - #### rxPfmerge

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

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

    - #### pfselftest

          public Maybe<Response> pfselftest()

      Redis command pfselftest.
      Returns:
        fluent self

    - #### rxPfselftest

          public Maybe<Response> rxPfselftest()

      Redis command pfselftest.
      Returns:
        fluent self

    - #### ping

          public Maybe<Response> ping(List<String> args)

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

    - #### rxPing

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

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

    - #### psetex

          public Maybe<Response> psetex(String arg0,
                                        String arg1,
                                        String arg2)

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

    - #### rxPsetex

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

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

    - #### psubscribe

          public Maybe<Response> psubscribe(List<String> args)

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

    - #### rxPsubscribe

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

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

    - #### psync

          public Maybe<Response> psync(List<String> args)

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

    - #### rxPsync

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

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

    - #### pttl

          public Maybe<Response> pttl(String arg0)

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

    - #### rxPttl

          public Maybe<Response> rxPttl(String arg0)

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

    - #### publish

          public Maybe<Response> publish(String arg0,
                                         String arg1)

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

    - #### rxPublish

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

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

    - #### pubsub

          public Maybe<Response> pubsub(List<String> args)

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

    - #### rxPubsub

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

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

    - #### punsubscribe

          public Maybe<Response> punsubscribe(List<String> args)

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

    - #### rxPunsubscribe

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

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

    - #### quit

          public Maybe<Response> quit(List<String> args)

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

    - #### rxQuit

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

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

    - #### randomkey

          public Maybe<Response> randomkey()

      Redis command randomkey.
      Returns:
        fluent self

    - #### rxRandomkey

          public Maybe<Response> rxRandomkey()

      Redis command randomkey.
      Returns:
        fluent self

    - #### readonly

          public Maybe<Response> readonly()

      Redis command readonly.
      Returns:
        fluent self

    - #### rxReadonly

          public Maybe<Response> rxReadonly()

      Redis command readonly.
      Returns:
        fluent self

    - #### readwrite

          public Maybe<Response> readwrite()

      Redis command readwrite.
      Returns:
        fluent self

    - #### rxReadwrite

          public Maybe<Response> rxReadwrite()

      Redis command readwrite.
      Returns:
        fluent self

    - #### rename

          public Maybe<Response> rename(String arg0,
                                        String arg1)

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

    - #### rxRename

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

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

    - #### renamenx

          public Maybe<Response> renamenx(String arg0,
                                          String arg1)

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

    - #### rxRenamenx

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

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

    - #### replconf

          public Maybe<Response> replconf(List<String> args)

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

    - #### rxReplconf

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

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

    - #### replicaof

          public Maybe<Response> replicaof(String arg0,
                                           String arg1)

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

    - #### rxReplicaof

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

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

    - #### reset

          public Maybe<Response> reset()

      Redis command reset.
      Returns:
        fluent self

    - #### rxReset

          public Maybe<Response> rxReset()

      Redis command reset.
      Returns:
        fluent self

    - #### restore

          public Maybe<Response> restore(List<String> args)

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

    - #### rxRestore

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

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

    - #### restoreAsking

          public Maybe<Response> restoreAsking(List<String> args)

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

    - #### rxRestoreAsking

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

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

    - #### role

          public Maybe<Response> role()

      Redis command role.
      Returns:
        fluent self

    - #### rxRole

          public Maybe<Response> rxRole()

      Redis command role.
      Returns:
        fluent self

    - #### rpop

          public Maybe<Response> rpop(List<String> args)

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

    - #### rxRpop

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

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

    - #### rpoplpush

          public Maybe<Response> rpoplpush(String arg0,
                                           String arg1)

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

    - #### rxRpoplpush

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

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

    - #### rpush

          public Maybe<Response> rpush(List<String> args)

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

    - #### rxRpush

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

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

    - #### rpushx

          public Maybe<Response> rpushx(List<String> args)

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

    - #### rxRpushx

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

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

    - #### sadd

          public Maybe<Response> sadd(List<String> args)

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

    - #### rxSadd

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

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

    - #### save

          public Maybe<Response> save()

      Redis command save.
      Returns:
        fluent self

    - #### rxSave

          public Maybe<Response> rxSave()

      Redis command save.
      Returns:
        fluent self

    - #### scan

          public Maybe<Response> scan(List<String> args)

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

    - #### rxScan

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

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

    - #### scard

          public Maybe<Response> scard(String arg0)

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

    - #### rxScard

          public Maybe<Response> rxScard(String arg0)

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

    - #### script

          public Maybe<Response> script(List<String> args)

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

    - #### rxScript

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

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

    - #### sdiff

          public Maybe<Response> sdiff(List<String> args)

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

    - #### rxSdiff

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

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

    - #### sdiffstore

          public Maybe<Response> sdiffstore(List<String> args)

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

    - #### rxSdiffstore

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

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

    - #### select

          public Maybe<Response> select(String arg0)

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

    - #### rxSelect

          public Maybe<Response> rxSelect(String arg0)

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

    - #### set

          public Maybe<Response> set(List<String> args)

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

    - #### rxSet

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

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

    - #### setbit

          public Maybe<Response> setbit(String arg0,
                                        String arg1,
                                        String arg2)

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

    - #### rxSetbit

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

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

    - #### setex

          public Maybe<Response> setex(String arg0,
                                       String arg1,
                                       String arg2)

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

    - #### rxSetex

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

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

    - #### setnx

          public Maybe<Response> setnx(String arg0,
                                       String arg1)

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

    - #### rxSetnx

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

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

    - #### setrange

          public Maybe<Response> setrange(String arg0,
                                          String arg1,
                                          String arg2)

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

    - #### rxSetrange

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

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

    - #### shutdown

          public Maybe<Response> shutdown(List<String> args)

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

    - #### rxShutdown

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

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

    - #### sinter

          public Maybe<Response> sinter(List<String> args)

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

    - #### rxSinter

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

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

    - #### sintercard

          public Maybe<Response> sintercard(List<String> args)

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

    - #### rxSintercard

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

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

    - #### sinterstore

          public Maybe<Response> sinterstore(List<String> args)

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

    - #### rxSinterstore

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

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

    - #### sismember

          public Maybe<Response> sismember(String arg0,
                                           String arg1)

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

    - #### rxSismember

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

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

    - #### slaveof

          public Maybe<Response> slaveof(String arg0,
                                         String arg1)

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

    - #### rxSlaveof

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

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

    - #### slowlog

          public Maybe<Response> slowlog(List<String> args)

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

    - #### rxSlowlog

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

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

    - #### smembers

          public Maybe<Response> smembers(String arg0)

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

    - #### rxSmembers

          public Maybe<Response> rxSmembers(String arg0)

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

    - #### smismember

          public Maybe<Response> smismember(List<String> args)

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

    - #### rxSmismember

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

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

    - #### smove

          public Maybe<Response> smove(String arg0,
                                       String arg1,
                                       String arg2)

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

    - #### rxSmove

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

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

    - #### sort

          public Maybe<Response> sort(List<String> args)

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

    - #### rxSort

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

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

    - #### sortRo

          public Maybe<Response> sortRo(List<String> args)

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

    - #### rxSortRo

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

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

    - #### spop

          public Maybe<Response> spop(List<String> args)

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

    - #### rxSpop

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

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

    - #### spublish

          public Maybe<Response> spublish(String arg0,
                                          String arg1)

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

    - #### rxSpublish

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

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

    - #### srandmember

          public Maybe<Response> srandmember(List<String> args)

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

    - #### rxSrandmember

          public Maybe<Response> rxSrandmember(List<String> args)

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

    - #### srem

          public Maybe<Response> srem(List<String> args)

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

    - #### rxSrem

          public Maybe<Response> rxSrem(List<String> args)

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

    - #### sscan

          public Maybe<Response> sscan(List<String> args)

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

    - #### rxSscan

          public Maybe<Response> rxSscan(List<String> args)

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

    - #### ssubscribe

          public Maybe<Response> ssubscribe(List<String> args)

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

    - #### rxSsubscribe

          public Maybe<Response> rxSsubscribe(List<String> args)

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

    - #### strlen

          public Maybe<Response> strlen(String arg0)

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

    - #### rxStrlen

          public Maybe<Response> rxStrlen(String arg0)

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

    - #### subscribe

          public Maybe<Response> subscribe(List<String> args)

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

    - #### rxSubscribe

          public Maybe<Response> rxSubscribe(List<String> args)

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

    - #### substr

          public Maybe<Response> substr(String arg0,
                                        String arg1,
                                        String arg2)

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

    - #### rxSubstr

          public Maybe<Response> rxSubstr(String arg0,
                                          String arg1,
                                          String arg2)

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

    - #### sunion

          public Maybe<Response> sunion(List<String> args)

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

    - #### rxSunion

          public Maybe<Response> rxSunion(List<String> args)

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

    - #### sunionstore

          public Maybe<Response> sunionstore(List<String> args)

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

    - #### rxSunionstore

          public Maybe<Response> rxSunionstore(List<String> args)

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

    - #### sunsubscribe

          public Maybe<Response> sunsubscribe(List<String> args)

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

    - #### rxSunsubscribe

          public Maybe<Response> rxSunsubscribe(List<String> args)

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

    - #### swapdb

          public Maybe<Response> swapdb(String arg0,
                                        String arg1)

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

    - #### rxSwapdb

          public Maybe<Response> rxSwapdb(String arg0,
                                          String arg1)

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

    - #### sync

          public Maybe<Response> sync()

      Redis command sync.
      Returns:
        fluent self

    - #### rxSync

          public Maybe<Response> rxSync()

      Redis command sync.
      Returns:
        fluent self

    - #### time

          public Maybe<Response> time()

      Redis command time.
      Returns:
        fluent self

    - #### rxTime

          public Maybe<Response> rxTime()

      Redis command time.
      Returns:
        fluent self

    - #### timeseriesClusterset

          public Maybe<Response> timeseriesClusterset(List<String> args)

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

    - #### rxTimeseriesClusterset

          public Maybe<Response> rxTimeseriesClusterset(List<String> args)

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

    - #### timeseriesClustersetfromshard

          public Maybe<Response> timeseriesClustersetfromshard(List<String> args)

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

    - #### rxTimeseriesClustersetfromshard

          public Maybe<Response> rxTimeseriesClustersetfromshard(List<String> args)

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

    - #### timeseriesHello

          public Maybe<Response> timeseriesHello(List<String> args)

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

    - #### rxTimeseriesHello

          public Maybe<Response> rxTimeseriesHello(List<String> args)

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

    - #### timeseriesInfocluster

          public Maybe<Response> timeseriesInfocluster(List<String> args)

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

    - #### rxTimeseriesInfocluster

          public Maybe<Response> rxTimeseriesInfocluster(List<String> args)

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

    - #### timeseriesInnercommunication

          public Maybe<Response> timeseriesInnercommunication(List<String> args)

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

    - #### rxTimeseriesInnercommunication

          public Maybe<Response> rxTimeseriesInnercommunication(List<String> args)

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

    - #### timeseriesNetworktest

          public Maybe<Response> timeseriesNetworktest(List<String> args)

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

    - #### rxTimeseriesNetworktest

          public Maybe<Response> rxTimeseriesNetworktest(List<String> args)

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

    - #### timeseriesRefreshcluster

          public Maybe<Response> timeseriesRefreshcluster(List<String> args)

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

    - #### rxTimeseriesRefreshcluster

          public Maybe<Response> rxTimeseriesRefreshcluster(List<String> args)

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

    - #### topkAdd

          public Maybe<Response> topkAdd(List<String> args)

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

    - #### rxTopkAdd

          public Maybe<Response> rxTopkAdd(List<String> args)

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

    - #### topkCount

          public Maybe<Response> topkCount(List<String> args)

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

    - #### rxTopkCount

          public Maybe<Response> rxTopkCount(List<String> args)

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

    - #### topkIncrby

          public Maybe<Response> topkIncrby(List<String> args)

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

    - #### rxTopkIncrby

          public Maybe<Response> rxTopkIncrby(List<String> args)

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

    - #### topkInfo

          public Maybe<Response> topkInfo(List<String> args)

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

    - #### rxTopkInfo

          public Maybe<Response> rxTopkInfo(List<String> args)

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

    - #### topkList

          public Maybe<Response> topkList(List<String> args)

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

    - #### rxTopkList

          public Maybe<Response> rxTopkList(List<String> args)

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

    - #### topkQuery

          public Maybe<Response> topkQuery(List<String> args)

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

    - #### rxTopkQuery

          public Maybe<Response> rxTopkQuery(List<String> args)

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

    - #### topkReserve

          public Maybe<Response> topkReserve(List<String> args)

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

    - #### rxTopkReserve

          public Maybe<Response> rxTopkReserve(List<String> args)

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

    - #### touch

          public Maybe<Response> touch(List<String> args)

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

    - #### rxTouch

          public Maybe<Response> rxTouch(List<String> args)

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

    - #### tsAdd

          public Maybe<Response> tsAdd(List<String> args)

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

    - #### rxTsAdd

          public Maybe<Response> rxTsAdd(List<String> args)

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

    - #### tsAlter

          public Maybe<Response> tsAlter(List<String> args)

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

    - #### rxTsAlter

          public Maybe<Response> rxTsAlter(List<String> args)

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

    - #### tsCreate

          public Maybe<Response> tsCreate(List<String> args)

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

    - #### rxTsCreate

          public Maybe<Response> rxTsCreate(List<String> args)

      Redis command tsCreate.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsCreaterule

          public Maybe<Response> tsCreaterule(List<String> args)

      Redis command tsCreaterule.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsCreaterule

          public Maybe<Response> rxTsCreaterule(List<String> args)

      Redis command tsCreaterule.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsDecrby

          public Maybe<Response> tsDecrby(List<String> args)

      Redis command tsDecrby.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsDecrby

          public Maybe<Response> rxTsDecrby(List<String> args)

      Redis command tsDecrby.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsDel

          public Maybe<Response> tsDel(List<String> args)

      Redis command tsDel.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsDel

          public Maybe<Response> rxTsDel(List<String> args)

      Redis command tsDel.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsDeleterule

          public Maybe<Response> tsDeleterule(List<String> args)

      Redis command tsDeleterule.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsDeleterule

          public Maybe<Response> rxTsDeleterule(List<String> args)

      Redis command tsDeleterule.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsGet

          public Maybe<Response> tsGet(List<String> args)

      Redis command tsGet.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsGet

          public Maybe<Response> rxTsGet(List<String> args)

      Redis command tsGet.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsIncrby

          public Maybe<Response> tsIncrby(List<String> args)

      Redis command tsIncrby.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsIncrby

          public Maybe<Response> rxTsIncrby(List<String> args)

      Redis command tsIncrby.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsInfo

          public Maybe<Response> tsInfo(List<String> args)

      Redis command tsInfo.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsInfo

          public Maybe<Response> rxTsInfo(List<String> args)

      Redis command tsInfo.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsMadd

          public Maybe<Response> tsMadd(List<String> args)

      Redis command tsMadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsMadd

          public Maybe<Response> rxTsMadd(List<String> args)

      Redis command tsMadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsMget

          public Maybe<Response> tsMget(List<String> args)

      Redis command tsMget.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsMget

          public Maybe<Response> rxTsMget(List<String> args)

      Redis command tsMget.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsMrange

          public Maybe<Response> tsMrange(List<String> args)

      Redis command tsMrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsMrange

          public Maybe<Response> rxTsMrange(List<String> args)

      Redis command tsMrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsMrevrange

          public Maybe<Response> tsMrevrange(List<String> args)

      Redis command tsMrevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsMrevrange

          public Maybe<Response> rxTsMrevrange(List<String> args)

      Redis command tsMrevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsQueryindex

          public Maybe<Response> tsQueryindex(List<String> args)

      Redis command tsQueryindex.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsQueryindex

          public Maybe<Response> rxTsQueryindex(List<String> args)

      Redis command tsQueryindex.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsRange

          public Maybe<Response> tsRange(List<String> args)

      Redis command tsRange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsRange

          public Maybe<Response> rxTsRange(List<String> args)

      Redis command tsRange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### tsRevrange

          public Maybe<Response> tsRevrange(List<String> args)

      Redis command tsRevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTsRevrange

          public Maybe<Response> rxTsRevrange(List<String> args)

      Redis command tsRevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ttl

          public Maybe<Response> ttl(String arg0)

      Redis command ttl.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxTtl

          public Maybe<Response> rxTtl(String arg0)

      Redis command ttl.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### type

          public Maybe<Response> type(String arg0)

      Redis command type.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxType

          public Maybe<Response> rxType(String arg0)

      Redis command type.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### unlink

          public Maybe<Response> unlink(List<String> args)

      Redis command unlink.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxUnlink

          public Maybe<Response> rxUnlink(List<String> args)

      Redis command unlink.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### unsubscribe

          public Maybe<Response> unsubscribe(List<String> args)

      Redis command unsubscribe.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxUnsubscribe

          public Maybe<Response> rxUnsubscribe(List<String> args)

      Redis command unsubscribe.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### unwatch

          public Maybe<Response> unwatch()

      Redis command unwatch.
      Returns:
        fluent self

    - #### rxUnwatch

          public Maybe<Response> rxUnwatch()

      Redis command unwatch.
      Returns:
        fluent self

    - #### wait

          public Maybe<Response> wait(String arg0,
                                      String arg1)

      Redis command wait.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxWait

          public Maybe<Response> rxWait(String arg0,
                                        String arg1)

      Redis command wait.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### watch

          public Maybe<Response> watch(List<String> args)

      Redis command watch.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxWatch

          public Maybe<Response> rxWatch(List<String> args)

      Redis command watch.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xack

          public Maybe<Response> xack(List<String> args)

      Redis command xack.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXack

          public Maybe<Response> rxXack(List<String> args)

      Redis command xack.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xadd

          public Maybe<Response> xadd(List<String> args)

      Redis command xadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXadd

          public Maybe<Response> rxXadd(List<String> args)

      Redis command xadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xautoclaim

          public Maybe<Response> xautoclaim(List<String> args)

      Redis command xautoclaim.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXautoclaim

          public Maybe<Response> rxXautoclaim(List<String> args)

      Redis command xautoclaim.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xclaim

          public Maybe<Response> xclaim(List<String> args)

      Redis command xclaim.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXclaim

          public Maybe<Response> rxXclaim(List<String> args)

      Redis command xclaim.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xdel

          public Maybe<Response> xdel(List<String> args)

      Redis command xdel.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXdel

          public Maybe<Response> rxXdel(List<String> args)

      Redis command xdel.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xgroup

          public Maybe<Response> xgroup(List<String> args)

      Redis command xgroup.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXgroup

          public Maybe<Response> rxXgroup(List<String> args)

      Redis command xgroup.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xinfo

          public Maybe<Response> xinfo(List<String> args)

      Redis command xinfo.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXinfo

          public Maybe<Response> rxXinfo(List<String> args)

      Redis command xinfo.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xlen

          public Maybe<Response> xlen(String arg0)

      Redis command xlen.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxXlen

          public Maybe<Response> rxXlen(String arg0)

      Redis command xlen.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### xpending

          public Maybe<Response> xpending(List<String> args)

      Redis command xpending.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXpending

          public Maybe<Response> rxXpending(List<String> args)

      Redis command xpending.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xrange

          public Maybe<Response> xrange(List<String> args)

      Redis command xrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXrange

          public Maybe<Response> rxXrange(List<String> args)

      Redis command xrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xread

          public Maybe<Response> xread(List<String> args)

      Redis command xread.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXread

          public Maybe<Response> rxXread(List<String> args)

      Redis command xread.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xreadgroup

          public Maybe<Response> xreadgroup(List<String> args)

      Redis command xreadgroup.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXreadgroup

          public Maybe<Response> rxXreadgroup(List<String> args)

      Redis command xreadgroup.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xrevrange

          public Maybe<Response> xrevrange(List<String> args)

      Redis command xrevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXrevrange

          public Maybe<Response> rxXrevrange(List<String> args)

      Redis command xrevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xsetid

          public Maybe<Response> xsetid(List<String> args)

      Redis command xsetid.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXsetid

          public Maybe<Response> rxXsetid(List<String> args)

      Redis command xsetid.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xtrim

          public Maybe<Response> xtrim(List<String> args)

      Redis command xtrim.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXtrim

          public Maybe<Response> rxXtrim(List<String> args)

      Redis command xtrim.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zadd

          public Maybe<Response> zadd(List<String> args)

      Redis command zadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZadd

          public Maybe<Response> rxZadd(List<String> args)

      Redis command zadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zcard

          public Maybe<Response> zcard(String arg0)

      Redis command zcard.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxZcard

          public Maybe<Response> rxZcard(String arg0)

      Redis command zcard.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### zcount

          public Maybe<Response> zcount(String arg0,
                                        String arg1,
                                        String arg2)

      Redis command zcount.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZcount

          public Maybe<Response> rxZcount(String arg0,
                                          String arg1,
                                          String arg2)

      Redis command zcount.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zdiff

          public Maybe<Response> zdiff(List<String> args)

      Redis command zdiff.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZdiff

          public Maybe<Response> rxZdiff(List<String> args)

      Redis command zdiff.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zdiffstore

          public Maybe<Response> zdiffstore(List<String> args)

      Redis command zdiffstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZdiffstore

          public Maybe<Response> rxZdiffstore(List<String> args)

      Redis command zdiffstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zincrby

          public Maybe<Response> zincrby(String arg0,
                                         String arg1,
                                         String arg2)

      Redis command zincrby.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZincrby

          public Maybe<Response> rxZincrby(String arg0,
                                           String arg1,
                                           String arg2)

      Redis command zincrby.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zinter

          public Maybe<Response> zinter(List<String> args)

      Redis command zinter.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZinter

          public Maybe<Response> rxZinter(List<String> args)

      Redis command zinter.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zintercard

          public Maybe<Response> zintercard(List<String> args)

      Redis command zintercard.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZintercard

          public Maybe<Response> rxZintercard(List<String> args)

      Redis command zintercard.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zinterstore

          public Maybe<Response> zinterstore(List<String> args)

      Redis command zinterstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZinterstore

          public Maybe<Response> rxZinterstore(List<String> args)

      Redis command zinterstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zlexcount

          public Maybe<Response> zlexcount(String arg0,
                                           String arg1,
                                           String arg2)

      Redis command zlexcount.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZlexcount

          public Maybe<Response> rxZlexcount(String arg0,
                                             String arg1,
                                             String arg2)

      Redis command zlexcount.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zmpop

          public Maybe<Response> zmpop(List<String> args)

      Redis command zmpop.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZmpop

          public Maybe<Response> rxZmpop(List<String> args)

      Redis command zmpop.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zmscore

          public Maybe<Response> zmscore(List<String> args)

      Redis command zmscore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZmscore

          public Maybe<Response> rxZmscore(List<String> args)

      Redis command zmscore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zpopmax

          public Maybe<Response> zpopmax(List<String> args)

      Redis command zpopmax.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZpopmax

          public Maybe<Response> rxZpopmax(List<String> args)

      Redis command zpopmax.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zpopmin

          public Maybe<Response> zpopmin(List<String> args)

      Redis command zpopmin.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZpopmin

          public Maybe<Response> rxZpopmin(List<String> args)

      Redis command zpopmin.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrandmember

          public Maybe<Response> zrandmember(List<String> args)

      Redis command zrandmember.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrandmember

          public Maybe<Response> rxZrandmember(List<String> args)

      Redis command zrandmember.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrange

          public Maybe<Response> zrange(List<String> args)

      Redis command zrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrange

          public Maybe<Response> rxZrange(List<String> args)

      Redis command zrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrangebylex

          public Maybe<Response> zrangebylex(List<String> args)

      Redis command zrangebylex.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrangebylex

          public Maybe<Response> rxZrangebylex(List<String> args)

      Redis command zrangebylex.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrangebyscore

          public Maybe<Response> zrangebyscore(List<String> args)

      Redis command zrangebyscore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrangebyscore

          public Maybe<Response> rxZrangebyscore(List<String> args)

      Redis command zrangebyscore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrangestore

          public Maybe<Response> zrangestore(List<String> args)

      Redis command zrangestore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrangestore

          public Maybe<Response> rxZrangestore(List<String> args)

      Redis command zrangestore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrank

          public Maybe<Response> zrank(String arg0,
                                       String arg1)

      Redis command zrank.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZrank

          public Maybe<Response> rxZrank(String arg0,
                                         String arg1)

      Redis command zrank.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zrem

          public Maybe<Response> zrem(List<String> args)

      Redis command zrem.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrem

          public Maybe<Response> rxZrem(List<String> args)

      Redis command zrem.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zremrangebylex

          public Maybe<Response> zremrangebylex(String arg0,
                                                String arg1,
                                                String arg2)

      Redis command zremrangebylex.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebylex

          public Maybe<Response> rxZremrangebylex(String arg0,
                                                  String arg1,
                                                  String arg2)

      Redis command zremrangebylex.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zremrangebyrank

          public Maybe<Response> zremrangebyrank(String arg0,
                                                 String arg1,
                                                 String arg2)

      Redis command zremrangebyrank.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebyrank

          public Maybe<Response> rxZremrangebyrank(String arg0,
                                                   String arg1,
                                                   String arg2)

      Redis command zremrangebyrank.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zremrangebyscore

          public Maybe<Response> zremrangebyscore(String arg0,
                                                  String arg1,
                                                  String arg2)

      Redis command zremrangebyscore.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebyscore

          public Maybe<Response> rxZremrangebyscore(String arg0,
                                                    String arg1,
                                                    String arg2)

      Redis command zremrangebyscore.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zrevrange

          public Maybe<Response> zrevrange(List<String> args)

      Redis command zrevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrange

          public Maybe<Response> rxZrevrange(List<String> args)

      Redis command zrevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrangebylex

          public Maybe<Response> zrevrangebylex(List<String> args)

      Redis command zrevrangebylex.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrangebylex

          public Maybe<Response> rxZrevrangebylex(List<String> args)

      Redis command zrevrangebylex.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrangebyscore

          public Maybe<Response> zrevrangebyscore(List<String> args)

      Redis command zrevrangebyscore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrangebyscore

          public Maybe<Response> rxZrevrangebyscore(List<String> args)

      Redis command zrevrangebyscore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrank

          public Maybe<Response> zrevrank(String arg0,
                                          String arg1)

      Redis command zrevrank.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZrevrank

          public Maybe<Response> rxZrevrank(String arg0,
                                            String arg1)

      Redis command zrevrank.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zscan

          public Maybe<Response> zscan(List<String> args)

      Redis command zscan.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZscan

          public Maybe<Response> rxZscan(List<String> args)

      Redis command zscan.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zscore

          public Maybe<Response> zscore(String arg0,
                                        String arg1)

      Redis command zscore.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZscore

          public Maybe<Response> rxZscore(String arg0,
                                          String arg1)

      Redis command zscore.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zunion

          public Maybe<Response> zunion(List<String> args)

      Redis command zunion.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZunion

          public Maybe<Response> rxZunion(List<String> args)

      Redis command zunion.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zunionstore

          public Maybe<Response> zunionstore(List<String> args)

      Redis command zunionstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZunionstore

          public Maybe<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 © 2023 Eclipse. All rights reserved.