RedisAPI (Vert.x Stack - Docs 4.4.9 API)

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

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)

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)

Class RedisAPI

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

RedisAPI

RedisAPI

Method Detail

toString

equals

hashCode

getDelegate

close

ftAdd

rxFtAdd

ftAggregate

rxFtAggregate

ftAliasadd

rxFtAliasadd

ftAliasdel

rxFtAliasdel

ftAliasupdate

rxFtAliasupdate

ftAlter

rxFtAlter

ftConfig

rxFtConfig

ftCreate

rxFtCreate

ftCursor

rxFtCursor

ftDebug

rxFtDebug

ftDel

rxFtDel

ftDictadd

rxFtDictadd

ftDictdel

rxFtDictdel

ftDictdump

rxFtDictdump

ftDrop

rxFtDrop

ftDropindex

rxFtDropindex

ftExplain

rxFtExplain

ftExplaincli

rxFtExplaincli

ftGet

rxFtGet

ftInfo

rxFtInfo

ftMget

rxFtMget

ftProfile

rxFtProfile

ftSafeadd

rxFtSafeadd

ftSearch

rxFtSearch

ftSpellcheck

rxFtSpellcheck

ftSugadd

rxFtSugadd

ftSugdel

rxFtSugdel

ftSugget

rxFtSugget

ftSuglen

rxFtSuglen

ftSynadd

rxFtSynadd

ftSyndump

rxFtSyndump

ftSynupdate

rxFtSynupdate