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 Description

static TypeArg<RedisAPI> __TYPE_ARG

Constructor Summary

Constructors
Constructor Description

RedisAPI(RedisAPI delegate)

RedisAPI(Object delegate)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`io.reactivex.rxjava3.core.Maybe<Response>`	`acl(List<String> args)`	Redis command ACL.
`static RedisAPI`	`api(Redis client)`
`static RedisAPI`	`api(RedisConnection connection)`
`io.reactivex.rxjava3.core.Maybe<Response>`	`append(String arg0, String arg1)`	Redis command APPEND.
`io.reactivex.rxjava3.core.Maybe<Response>`	`asking()`	Redis command ASKING.
`io.reactivex.rxjava3.core.Maybe<Response>`	`auth(List<String> args)`	Redis command AUTH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bfAdd(List<String> args)`	Redis command BF.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bfCard(List<String> args)`	Redis command BF.CARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bfDebug(List<String> args)`	Redis command BF.DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bfExists(List<String> args)`	Redis command BF.EXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bfInfo(List<String> args)`	Redis command BF.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bfInsert(List<String> args)`	Redis command BF.INSERT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bfLoadchunk(List<String> args)`	Redis command BF.LOADCHUNK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bfMadd(List<String> args)`	Redis command BF.MADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bfMexists(List<String> args)`	Redis command BF.MEXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bfReserve(List<String> args)`	Redis command BF.RESERVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bfScandump(List<String> args)`	Redis command BF.SCANDUMP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bgrewriteaof()`	Redis command BGREWRITEAOF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bgsave(List<String> args)`	Redis command BGSAVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bitcount(List<String> args)`	Redis command BITCOUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bitfield(List<String> args)`	Redis command BITFIELD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bitfieldRo(List<String> args)`	Redis command BITFIELD_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bitop(List<String> args)`	Redis command BITOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bitpos(List<String> args)`	Redis command BITPOS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`blmove(String arg0, String arg1, String arg2, String arg3, String arg4)`	Redis command BLMOVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`blmpop(List<String> args)`	Redis command BLMPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`blpop(List<String> args)`	Redis command BLPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`brpop(List<String> args)`	Redis command BRPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`brpoplpush(String arg0, String arg1, String arg2)`	Redis command BRPOPLPUSH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bzmpop(List<String> args)`	Redis command BZMPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bzpopmax(List<String> args)`	Redis command BZPOPMAX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`bzpopmin(List<String> args)`	Redis command BZPOPMIN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfAdd(List<String> args)`	Redis command CF.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfAddnx(List<String> args)`	Redis command CF.ADDNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfCompact(List<String> args)`	Redis command CF.COMPACT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfCount(List<String> args)`	Redis command CF.COUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfDebug(List<String> args)`	Redis command CF.DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfDel(List<String> args)`	Redis command CF.DEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfExists(List<String> args)`	Redis command CF.EXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfInfo(List<String> args)`	Redis command CF.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfInsert(List<String> args)`	Redis command CF.INSERT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfInsertnx(List<String> args)`	Redis command CF.INSERTNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfLoadchunk(List<String> args)`	Redis command CF.LOADCHUNK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfMexists(List<String> args)`	Redis command CF.MEXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfReserve(List<String> args)`	Redis command CF.RESERVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cfScandump(List<String> args)`	Redis command CF.SCANDUMP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`client(List<String> args)`	Redis command CLIENT.
`void`	`close()`
`io.reactivex.rxjava3.core.Maybe<Response>`	`cluster(List<String> args)`	Redis command CLUSTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cmsIncrby(List<String> args)`	Redis command CMS.INCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cmsInfo(List<String> args)`	Redis command CMS.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cmsInitbydim(List<String> args)`	Redis command CMS.INITBYDIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cmsInitbyprob(List<String> args)`	Redis command CMS.INITBYPROB.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cmsMerge(List<String> args)`	Redis command CMS.MERGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`cmsQuery(List<String> args)`	Redis command CMS.QUERY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`command(List<String> args)`	Redis command COMMAND.
`io.reactivex.rxjava3.core.Maybe<Response>`	`config(List<String> args)`	Redis command CONFIG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`copy(List<String> args)`	Redis command COPY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`dbsize()`	Redis command DBSIZE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`debug(List<String> args)`	Redis command DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`decr(String arg0)`	Redis command DECR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`decrby(String arg0, String arg1)`	Redis command DECRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`del(List<String> args)`	Redis command DEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`discard()`	Redis command DISCARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`dump(String arg0)`	Redis command DUMP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`echo(String arg0)`	Redis command ECHO.
`boolean`	`equals(Object o)`
`io.reactivex.rxjava3.core.Maybe<Response>`	`eval(List<String> args)`	Redis command EVAL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`evalRo(List<String> args)`	Redis command EVAL_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`evalsha(List<String> args)`	Redis command EVALSHA.
`io.reactivex.rxjava3.core.Maybe<Response>`	`evalshaRo(List<String> args)`	Redis command EVALSHA_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`exec()`	Redis command EXEC.
`io.reactivex.rxjava3.core.Maybe<Response>`	`exists(List<String> args)`	Redis command EXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`expire(List<String> args)`	Redis command EXPIRE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`expireat(List<String> args)`	Redis command EXPIREAT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`expiretime(String arg0)`	Redis command EXPIRETIME.
`io.reactivex.rxjava3.core.Maybe<Response>`	`failover(List<String> args)`	Redis command FAILOVER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`fcall(List<String> args)`	Redis command FCALL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`fcallRo(List<String> args)`	Redis command FCALL_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`flushall(List<String> args)`	Redis command FLUSHALL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`flushdb(List<String> args)`	Redis command FLUSHDB.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftAdd(List<String> args)`	Redis command FT.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftAggregate(List<String> args)`	Redis command FT.AGGREGATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftAliasadd(List<String> args)`	Redis command FT.ALIASADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftAliasaddifnx(List<String> args)`	Redis command FT._ALIASADDIFNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftAliasdel(List<String> args)`	Redis command FT.ALIASDEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftAliasdelifx(List<String> args)`	Redis command FT._ALIASDELIFX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftAliasupdate(List<String> args)`	Redis command FT.ALIASUPDATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftAlter(List<String> args)`	Redis command FT.ALTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftAlterifnx(List<String> args)`	Redis command FT._ALTERIFNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftConfig(List<String> args)`	Redis command FT.CONFIG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftCreate(List<String> args)`	Redis command FT.CREATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftCreateifnx(List<String> args)`	Redis command FT._CREATEIFNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftCursor(List<String> args)`	Redis command FT.CURSOR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftDebug(List<String> args)`	Redis command FT.DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftDel(List<String> args)`	Redis command FT.DEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftDictadd(List<String> args)`	Redis command FT.DICTADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftDictdel(List<String> args)`	Redis command FT.DICTDEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftDictdump(List<String> args)`	Redis command FT.DICTDUMP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftDrop(List<String> args)`	Redis command FT.DROP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftDropifx(List<String> args)`	Redis command FT._DROPIFX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftDropindex(List<String> args)`	Redis command FT.DROPINDEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftDropindexifx(List<String> args)`	Redis command FT._DROPINDEXIFX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftExplain(List<String> args)`	Redis command FT.EXPLAIN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftExplaincli(List<String> args)`	Redis command FT.EXPLAINCLI.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftGet(List<String> args)`	Redis command FT.GET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftInfo(List<String> args)`	Redis command FT.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftList(List<String> args)`	Redis command FT._LIST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftMget(List<String> args)`	Redis command FT.MGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftProfile(List<String> args)`	Redis command FT.PROFILE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftSafeadd(List<String> args)`	Redis command FT.SAFEADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftSearch(List<String> args)`	Redis command FT.SEARCH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftSpellcheck(List<String> args)`	Redis command FT.SPELLCHECK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftSugadd(List<String> args)`	Redis command FT.SUGADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftSugdel(List<String> args)`	Redis command FT.SUGDEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftSugget(List<String> args)`	Redis command FT.SUGGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftSuglen(List<String> args)`	Redis command FT.SUGLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftSynadd(List<String> args)`	Redis command FT.SYNADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftSyndump(List<String> args)`	Redis command FT.SYNDUMP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftSynupdate(List<String> args)`	Redis command FT.SYNUPDATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ftTagvals(List<String> args)`	Redis command FT.TAGVALS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`function(List<String> args)`	Redis command FUNCTION.
`io.reactivex.rxjava3.core.Maybe<Response>`	`geoadd(List<String> args)`	Redis command GEOADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`geodist(List<String> args)`	Redis command GEODIST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`geohash(List<String> args)`	Redis command GEOHASH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`geopos(List<String> args)`	Redis command GEOPOS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`georadius(List<String> args)`	Redis command GEORADIUS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`georadiusbymember(List<String> args)`	Redis command GEORADIUSBYMEMBER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`georadiusbymemberRo(List<String> args)`	Redis command GEORADIUSBYMEMBER_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`georadiusRo(List<String> args)`	Redis command GEORADIUS_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`geosearch(List<String> args)`	Redis command GEOSEARCH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`geosearchstore(List<String> args)`	Redis command GEOSEARCHSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`get(String arg0)`	Redis command GET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`getbit(String arg0, String arg1)`	Redis command GETBIT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`getdel(String arg0)`	Redis command GETDEL.
`RedisAPI`	`getDelegate()`
`io.reactivex.rxjava3.core.Maybe<Response>`	`getex(List<String> args)`	Redis command GETEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`getrange(String arg0, String arg1, String arg2)`	Redis command GETRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`getset(String arg0, String arg1)`	Redis command GETSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`graphBulk(List<String> args)`	Redis command GRAPH.BULK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`graphConfig(List<String> args)`	Redis command GRAPH.CONFIG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`graphDebug(List<String> args)`	Redis command GRAPH.DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`graphDelete(List<String> args)`	Redis command GRAPH.DELETE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`graphExplain(List<String> args)`	Redis command GRAPH.EXPLAIN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`graphList(List<String> args)`	Redis command GRAPH.LIST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`graphProfile(List<String> args)`	Redis command GRAPH.PROFILE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`graphQuery(List<String> args)`	Redis command GRAPH.QUERY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`graphRoQuery(List<String> args)`	Redis command GRAPH.RO_QUERY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`graphSlowlog(List<String> args)`	Redis command GRAPH.SLOWLOG.
`int`	`hashCode()`
`io.reactivex.rxjava3.core.Maybe<Response>`	`hdel(List<String> args)`	Redis command HDEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hello(List<String> args)`	Redis command HELLO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hexists(String arg0, String arg1)`	Redis command HEXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hget(String arg0, String arg1)`	Redis command HGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hgetall(String arg0)`	Redis command HGETALL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hincrby(String arg0, String arg1, String arg2)`	Redis command HINCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hincrbyfloat(String arg0, String arg1, String arg2)`	Redis command HINCRBYFLOAT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hkeys(String arg0)`	Redis command HKEYS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hlen(String arg0)`	Redis command HLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hmget(List<String> args)`	Redis command HMGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hmset(List<String> args)`	Redis command HMSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hrandfield(List<String> args)`	Redis command HRANDFIELD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hscan(List<String> args)`	Redis command HSCAN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hset(List<String> args)`	Redis command HSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hsetnx(String arg0, String arg1, String arg2)`	Redis command HSETNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hstrlen(String arg0, String arg1)`	Redis command HSTRLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`hvals(String arg0)`	Redis command HVALS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`incr(String arg0)`	Redis command INCR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`incrby(String arg0, String arg1)`	Redis command INCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`incrbyfloat(String arg0, String arg1)`	Redis command INCRBYFLOAT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`info(List<String> args)`	Redis command INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonArrappend(List<String> args)`	Redis command JSON.ARRAPPEND.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonArrindex(List<String> args)`	Redis command JSON.ARRINDEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonArrinsert(List<String> args)`	Redis command JSON.ARRINSERT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonArrlen(List<String> args)`	Redis command JSON.ARRLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonArrpop(List<String> args)`	Redis command JSON.ARRPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonArrtrim(List<String> args)`	Redis command JSON.ARRTRIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonClear(List<String> args)`	Redis command JSON.CLEAR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonDebug(List<String> args)`	Redis command JSON.DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonDel(List<String> args)`	Redis command JSON.DEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonForget(List<String> args)`	Redis command JSON.FORGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonGet(List<String> args)`	Redis command JSON.GET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonMget(List<String> args)`	Redis command JSON.MGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonNumincrby(List<String> args)`	Redis command JSON.NUMINCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonNummultby(List<String> args)`	Redis command JSON.NUMMULTBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonNumpowby(List<String> args)`	Redis command JSON.NUMPOWBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonObjkeys(List<String> args)`	Redis command JSON.OBJKEYS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonObjlen(List<String> args)`	Redis command JSON.OBJLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonResp(List<String> args)`	Redis command JSON.RESP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonSet(List<String> args)`	Redis command JSON.SET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonStrappend(List<String> args)`	Redis command JSON.STRAPPEND.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonStrlen(List<String> args)`	Redis command JSON.STRLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonToggle(List<String> args)`	Redis command JSON.TOGGLE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`jsonType(List<String> args)`	Redis command JSON.TYPE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`keys(String arg0)`	Redis command KEYS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lastsave()`	Redis command LASTSAVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`latency(List<String> args)`	Redis command LATENCY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lcs(List<String> args)`	Redis command LCS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lindex(String arg0, String arg1)`	Redis command LINDEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`linsert(String arg0, String arg1, String arg2, String arg3)`	Redis command LINSERT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`llen(String arg0)`	Redis command LLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lmove(String arg0, String arg1, String arg2, String arg3)`	Redis command LMOVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lmpop(List<String> args)`	Redis command LMPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lolwut(List<String> args)`	Redis command LOLWUT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lpop(List<String> args)`	Redis command LPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lpos(List<String> args)`	Redis command LPOS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lpush(List<String> args)`	Redis command LPUSH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lpushx(List<String> args)`	Redis command LPUSHX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lrange(String arg0, String arg1, String arg2)`	Redis command LRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lrem(String arg0, String arg1, String arg2)`	Redis command LREM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`lset(String arg0, String arg1, String arg2)`	Redis command LSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ltrim(String arg0, String arg1, String arg2)`	Redis command LTRIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`memory(List<String> args)`	Redis command MEMORY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`mget(List<String> args)`	Redis command MGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`migrate(List<String> args)`	Redis command MIGRATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`module(List<String> args)`	Redis command MODULE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`monitor()`	Redis command MONITOR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`move(String arg0, String arg1)`	Redis command MOVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`mset(List<String> args)`	Redis command MSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`msetnx(List<String> args)`	Redis command MSETNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`multi()`	Redis command MULTI.
`static RedisAPI`	`newInstance(RedisAPI arg)`
`io.reactivex.rxjava3.core.Maybe<Response>`	`object(List<String> args)`	Redis command OBJECT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`persist(String arg0)`	Redis command PERSIST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`pexpire(List<String> args)`	Redis command PEXPIRE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`pexpireat(List<String> args)`	Redis command PEXPIREAT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`pexpiretime(String arg0)`	Redis command PEXPIRETIME.
`io.reactivex.rxjava3.core.Maybe<Response>`	`pfadd(List<String> args)`	Redis command PFADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`pfcount(List<String> args)`	Redis command PFCOUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`pfdebug(String arg0, String arg1)`	Redis command PFDEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`pfmerge(List<String> args)`	Redis command PFMERGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`pfselftest()`	Redis command PFSELFTEST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ping(List<String> args)`	Redis command PING.
`io.reactivex.rxjava3.core.Maybe<Response>`	`psetex(String arg0, String arg1, String arg2)`	Redis command PSETEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`psubscribe(List<String> args)`	Redis command PSUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`psync(List<String> args)`	Redis command PSYNC.
`io.reactivex.rxjava3.core.Maybe<Response>`	`pttl(String arg0)`	Redis command PTTL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`publish(String arg0, String arg1)`	Redis command PUBLISH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`pubsub(List<String> args)`	Redis command PUBSUB.
`io.reactivex.rxjava3.core.Maybe<Response>`	`punsubscribe(List<String> args)`	Redis command PUNSUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`quit(List<String> args)`	Redis command QUIT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`randomkey()`	Redis command RANDOMKEY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`readonly()`	Redis command READONLY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`readwrite()`	Redis command READWRITE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rename(String arg0, String arg1)`	Redis command RENAME.
`io.reactivex.rxjava3.core.Maybe<Response>`	`renamenx(String arg0, String arg1)`	Redis command RENAMENX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`replconf(List<String> args)`	Redis command REPLCONF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`replicaof(String arg0, String arg1)`	Redis command REPLICAOF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`reset()`	Redis command RESET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`restore(List<String> args)`	Redis command RESTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`restoreAsking(List<String> args)`	Redis command RESTORE-ASKING.
`io.reactivex.rxjava3.core.Maybe<Response>`	`role()`	Redis command ROLE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rpop(List<String> args)`	Redis command RPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rpoplpush(String arg0, String arg1)`	Redis command RPOPLPUSH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rpush(List<String> args)`	Redis command RPUSH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rpushx(List<String> args)`	Redis command RPUSHX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxAcl(List<String> args)`	Redis command ACL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxAppend(String arg0, String arg1)`	Redis command APPEND.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxAsking()`	Redis command ASKING.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxAuth(List<String> args)`	Redis command AUTH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBfAdd(List<String> args)`	Redis command BF.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBfCard(List<String> args)`	Redis command BF.CARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBfDebug(List<String> args)`	Redis command BF.DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBfExists(List<String> args)`	Redis command BF.EXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBfInfo(List<String> args)`	Redis command BF.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBfInsert(List<String> args)`	Redis command BF.INSERT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBfLoadchunk(List<String> args)`	Redis command BF.LOADCHUNK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBfMadd(List<String> args)`	Redis command BF.MADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBfMexists(List<String> args)`	Redis command BF.MEXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBfReserve(List<String> args)`	Redis command BF.RESERVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBfScandump(List<String> args)`	Redis command BF.SCANDUMP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBgrewriteaof()`	Redis command BGREWRITEAOF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBgsave(List<String> args)`	Redis command BGSAVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBitcount(List<String> args)`	Redis command BITCOUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBitfield(List<String> args)`	Redis command BITFIELD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBitfieldRo(List<String> args)`	Redis command BITFIELD_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBitop(List<String> args)`	Redis command BITOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBitpos(List<String> args)`	Redis command BITPOS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBlmove(String arg0, String arg1, String arg2, String arg3, String arg4)`	Redis command BLMOVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBlmpop(List<String> args)`	Redis command BLMPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBlpop(List<String> args)`	Redis command BLPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBrpop(List<String> args)`	Redis command BRPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBrpoplpush(String arg0, String arg1, String arg2)`	Redis command BRPOPLPUSH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBzmpop(List<String> args)`	Redis command BZMPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBzpopmax(List<String> args)`	Redis command BZPOPMAX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxBzpopmin(List<String> args)`	Redis command BZPOPMIN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfAdd(List<String> args)`	Redis command CF.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfAddnx(List<String> args)`	Redis command CF.ADDNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfCompact(List<String> args)`	Redis command CF.COMPACT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfCount(List<String> args)`	Redis command CF.COUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfDebug(List<String> args)`	Redis command CF.DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfDel(List<String> args)`	Redis command CF.DEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfExists(List<String> args)`	Redis command CF.EXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfInfo(List<String> args)`	Redis command CF.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfInsert(List<String> args)`	Redis command CF.INSERT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfInsertnx(List<String> args)`	Redis command CF.INSERTNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfLoadchunk(List<String> args)`	Redis command CF.LOADCHUNK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfMexists(List<String> args)`	Redis command CF.MEXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfReserve(List<String> args)`	Redis command CF.RESERVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCfScandump(List<String> args)`	Redis command CF.SCANDUMP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxClient(List<String> args)`	Redis command CLIENT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCluster(List<String> args)`	Redis command CLUSTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCmsIncrby(List<String> args)`	Redis command CMS.INCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCmsInfo(List<String> args)`	Redis command CMS.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCmsInitbydim(List<String> args)`	Redis command CMS.INITBYDIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCmsInitbyprob(List<String> args)`	Redis command CMS.INITBYPROB.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCmsMerge(List<String> args)`	Redis command CMS.MERGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCmsQuery(List<String> args)`	Redis command CMS.QUERY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCommand(List<String> args)`	Redis command COMMAND.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxConfig(List<String> args)`	Redis command CONFIG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxCopy(List<String> args)`	Redis command COPY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxDbsize()`	Redis command DBSIZE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxDebug(List<String> args)`	Redis command DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxDecr(String arg0)`	Redis command DECR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxDecrby(String arg0, String arg1)`	Redis command DECRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxDel(List<String> args)`	Redis command DEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxDiscard()`	Redis command DISCARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxDump(String arg0)`	Redis command DUMP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxEcho(String arg0)`	Redis command ECHO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxEval(List<String> args)`	Redis command EVAL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxEvalRo(List<String> args)`	Redis command EVAL_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxEvalsha(List<String> args)`	Redis command EVALSHA.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxEvalshaRo(List<String> args)`	Redis command EVALSHA_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxExec()`	Redis command EXEC.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxExists(List<String> args)`	Redis command EXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxExpire(List<String> args)`	Redis command EXPIRE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxExpireat(List<String> args)`	Redis command EXPIREAT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxExpiretime(String arg0)`	Redis command EXPIRETIME.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFailover(List<String> args)`	Redis command FAILOVER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFcall(List<String> args)`	Redis command FCALL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFcallRo(List<String> args)`	Redis command FCALL_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFlushall(List<String> args)`	Redis command FLUSHALL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFlushdb(List<String> args)`	Redis command FLUSHDB.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtAdd(List<String> args)`	Redis command FT.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtAggregate(List<String> args)`	Redis command FT.AGGREGATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtAliasadd(List<String> args)`	Redis command FT.ALIASADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtAliasaddifnx(List<String> args)`	Redis command FT._ALIASADDIFNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtAliasdel(List<String> args)`	Redis command FT.ALIASDEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtAliasdelifx(List<String> args)`	Redis command FT._ALIASDELIFX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtAliasupdate(List<String> args)`	Redis command FT.ALIASUPDATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtAlter(List<String> args)`	Redis command FT.ALTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtAlterifnx(List<String> args)`	Redis command FT._ALTERIFNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtConfig(List<String> args)`	Redis command FT.CONFIG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtCreate(List<String> args)`	Redis command FT.CREATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtCreateifnx(List<String> args)`	Redis command FT._CREATEIFNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtCursor(List<String> args)`	Redis command FT.CURSOR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtDebug(List<String> args)`	Redis command FT.DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtDel(List<String> args)`	Redis command FT.DEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtDictadd(List<String> args)`	Redis command FT.DICTADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtDictdel(List<String> args)`	Redis command FT.DICTDEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtDictdump(List<String> args)`	Redis command FT.DICTDUMP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtDrop(List<String> args)`	Redis command FT.DROP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtDropifx(List<String> args)`	Redis command FT._DROPIFX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtDropindex(List<String> args)`	Redis command FT.DROPINDEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtDropindexifx(List<String> args)`	Redis command FT._DROPINDEXIFX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtExplain(List<String> args)`	Redis command FT.EXPLAIN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtExplaincli(List<String> args)`	Redis command FT.EXPLAINCLI.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtGet(List<String> args)`	Redis command FT.GET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtInfo(List<String> args)`	Redis command FT.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtList(List<String> args)`	Redis command FT._LIST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtMget(List<String> args)`	Redis command FT.MGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtProfile(List<String> args)`	Redis command FT.PROFILE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtSafeadd(List<String> args)`	Redis command FT.SAFEADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtSearch(List<String> args)`	Redis command FT.SEARCH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtSpellcheck(List<String> args)`	Redis command FT.SPELLCHECK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtSugadd(List<String> args)`	Redis command FT.SUGADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtSugdel(List<String> args)`	Redis command FT.SUGDEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtSugget(List<String> args)`	Redis command FT.SUGGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtSuglen(List<String> args)`	Redis command FT.SUGLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtSynadd(List<String> args)`	Redis command FT.SYNADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtSyndump(List<String> args)`	Redis command FT.SYNDUMP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtSynupdate(List<String> args)`	Redis command FT.SYNUPDATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFtTagvals(List<String> args)`	Redis command FT.TAGVALS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxFunction(List<String> args)`	Redis command FUNCTION.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGeoadd(List<String> args)`	Redis command GEOADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGeodist(List<String> args)`	Redis command GEODIST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGeohash(List<String> args)`	Redis command GEOHASH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGeopos(List<String> args)`	Redis command GEOPOS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGeoradius(List<String> args)`	Redis command GEORADIUS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGeoradiusbymember(List<String> args)`	Redis command GEORADIUSBYMEMBER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGeoradiusbymemberRo(List<String> args)`	Redis command GEORADIUSBYMEMBER_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGeoradiusRo(List<String> args)`	Redis command GEORADIUS_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGeosearch(List<String> args)`	Redis command GEOSEARCH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGeosearchstore(List<String> args)`	Redis command GEOSEARCHSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGet(String arg0)`	Redis command GET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGetbit(String arg0, String arg1)`	Redis command GETBIT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGetdel(String arg0)`	Redis command GETDEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGetex(List<String> args)`	Redis command GETEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGetrange(String arg0, String arg1, String arg2)`	Redis command GETRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGetset(String arg0, String arg1)`	Redis command GETSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGraphBulk(List<String> args)`	Redis command GRAPH.BULK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGraphConfig(List<String> args)`	Redis command GRAPH.CONFIG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGraphDebug(List<String> args)`	Redis command GRAPH.DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGraphDelete(List<String> args)`	Redis command GRAPH.DELETE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGraphExplain(List<String> args)`	Redis command GRAPH.EXPLAIN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGraphList(List<String> args)`	Redis command GRAPH.LIST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGraphProfile(List<String> args)`	Redis command GRAPH.PROFILE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGraphQuery(List<String> args)`	Redis command GRAPH.QUERY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGraphRoQuery(List<String> args)`	Redis command GRAPH.RO_QUERY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxGraphSlowlog(List<String> args)`	Redis command GRAPH.SLOWLOG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHdel(List<String> args)`	Redis command HDEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHello(List<String> args)`	Redis command HELLO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHexists(String arg0, String arg1)`	Redis command HEXISTS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHget(String arg0, String arg1)`	Redis command HGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHgetall(String arg0)`	Redis command HGETALL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHincrby(String arg0, String arg1, String arg2)`	Redis command HINCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHincrbyfloat(String arg0, String arg1, String arg2)`	Redis command HINCRBYFLOAT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHkeys(String arg0)`	Redis command HKEYS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHlen(String arg0)`	Redis command HLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHmget(List<String> args)`	Redis command HMGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHmset(List<String> args)`	Redis command HMSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHrandfield(List<String> args)`	Redis command HRANDFIELD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHscan(List<String> args)`	Redis command HSCAN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHset(List<String> args)`	Redis command HSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHsetnx(String arg0, String arg1, String arg2)`	Redis command HSETNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHstrlen(String arg0, String arg1)`	Redis command HSTRLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxHvals(String arg0)`	Redis command HVALS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxIncr(String arg0)`	Redis command INCR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxIncrby(String arg0, String arg1)`	Redis command INCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxIncrbyfloat(String arg0, String arg1)`	Redis command INCRBYFLOAT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxInfo(List<String> args)`	Redis command INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonArrappend(List<String> args)`	Redis command JSON.ARRAPPEND.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonArrindex(List<String> args)`	Redis command JSON.ARRINDEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonArrinsert(List<String> args)`	Redis command JSON.ARRINSERT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonArrlen(List<String> args)`	Redis command JSON.ARRLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonArrpop(List<String> args)`	Redis command JSON.ARRPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonArrtrim(List<String> args)`	Redis command JSON.ARRTRIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonClear(List<String> args)`	Redis command JSON.CLEAR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonDebug(List<String> args)`	Redis command JSON.DEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonDel(List<String> args)`	Redis command JSON.DEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonForget(List<String> args)`	Redis command JSON.FORGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonGet(List<String> args)`	Redis command JSON.GET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonMget(List<String> args)`	Redis command JSON.MGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonNumincrby(List<String> args)`	Redis command JSON.NUMINCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonNummultby(List<String> args)`	Redis command JSON.NUMMULTBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonNumpowby(List<String> args)`	Redis command JSON.NUMPOWBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonObjkeys(List<String> args)`	Redis command JSON.OBJKEYS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonObjlen(List<String> args)`	Redis command JSON.OBJLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonResp(List<String> args)`	Redis command JSON.RESP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonSet(List<String> args)`	Redis command JSON.SET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonStrappend(List<String> args)`	Redis command JSON.STRAPPEND.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonStrlen(List<String> args)`	Redis command JSON.STRLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonToggle(List<String> args)`	Redis command JSON.TOGGLE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxJsonType(List<String> args)`	Redis command JSON.TYPE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxKeys(String arg0)`	Redis command KEYS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLastsave()`	Redis command LASTSAVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLatency(List<String> args)`	Redis command LATENCY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLcs(List<String> args)`	Redis command LCS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLindex(String arg0, String arg1)`	Redis command LINDEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLinsert(String arg0, String arg1, String arg2, String arg3)`	Redis command LINSERT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLlen(String arg0)`	Redis command LLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLmove(String arg0, String arg1, String arg2, String arg3)`	Redis command LMOVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLmpop(List<String> args)`	Redis command LMPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLolwut(List<String> args)`	Redis command LOLWUT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLpop(List<String> args)`	Redis command LPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLpos(List<String> args)`	Redis command LPOS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLpush(List<String> args)`	Redis command LPUSH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLpushx(List<String> args)`	Redis command LPUSHX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLrange(String arg0, String arg1, String arg2)`	Redis command LRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLrem(String arg0, String arg1, String arg2)`	Redis command LREM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLset(String arg0, String arg1, String arg2)`	Redis command LSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxLtrim(String arg0, String arg1, String arg2)`	Redis command LTRIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxMemory(List<String> args)`	Redis command MEMORY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxMget(List<String> args)`	Redis command MGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxMigrate(List<String> args)`	Redis command MIGRATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxModule(List<String> args)`	Redis command MODULE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxMonitor()`	Redis command MONITOR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxMove(String arg0, String arg1)`	Redis command MOVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxMset(List<String> args)`	Redis command MSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxMsetnx(List<String> args)`	Redis command MSETNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxMulti()`	Redis command MULTI.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxObject(List<String> args)`	Redis command OBJECT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPersist(String arg0)`	Redis command PERSIST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPexpire(List<String> args)`	Redis command PEXPIRE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPexpireat(List<String> args)`	Redis command PEXPIREAT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPexpiretime(String arg0)`	Redis command PEXPIRETIME.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPfadd(List<String> args)`	Redis command PFADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPfcount(List<String> args)`	Redis command PFCOUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPfdebug(String arg0, String arg1)`	Redis command PFDEBUG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPfmerge(List<String> args)`	Redis command PFMERGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPfselftest()`	Redis command PFSELFTEST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPing(List<String> args)`	Redis command PING.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPsetex(String arg0, String arg1, String arg2)`	Redis command PSETEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPsubscribe(List<String> args)`	Redis command PSUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPsync(List<String> args)`	Redis command PSYNC.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPttl(String arg0)`	Redis command PTTL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPublish(String arg0, String arg1)`	Redis command PUBLISH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPubsub(List<String> args)`	Redis command PUBSUB.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxPunsubscribe(List<String> args)`	Redis command PUNSUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxQuit(List<String> args)`	Redis command QUIT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxRandomkey()`	Redis command RANDOMKEY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxReadonly()`	Redis command READONLY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxReadwrite()`	Redis command READWRITE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxRename(String arg0, String arg1)`	Redis command RENAME.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxRenamenx(String arg0, String arg1)`	Redis command RENAMENX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxReplconf(List<String> args)`	Redis command REPLCONF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxReplicaof(String arg0, String arg1)`	Redis command REPLICAOF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxReset()`	Redis command RESET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxRestore(List<String> args)`	Redis command RESTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxRestoreAsking(List<String> args)`	Redis command RESTORE-ASKING.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxRole()`	Redis command ROLE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxRpop(List<String> args)`	Redis command RPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxRpoplpush(String arg0, String arg1)`	Redis command RPOPLPUSH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxRpush(List<String> args)`	Redis command RPUSH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxRpushx(List<String> args)`	Redis command RPUSHX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSadd(List<String> args)`	Redis command SADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSave()`	Redis command SAVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxScan(List<String> args)`	Redis command SCAN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxScard(String arg0)`	Redis command SCARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxScript(List<String> args)`	Redis command SCRIPT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSdiff(List<String> args)`	Redis command SDIFF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSdiffstore(List<String> args)`	Redis command SDIFFSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSelect(String arg0)`	Redis command SELECT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSet(List<String> args)`	Redis command SET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSetbit(String arg0, String arg1, String arg2)`	Redis command SETBIT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSetex(String arg0, String arg1, String arg2)`	Redis command SETEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSetnx(String arg0, String arg1)`	Redis command SETNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSetrange(String arg0, String arg1, String arg2)`	Redis command SETRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxShutdown(List<String> args)`	Redis command SHUTDOWN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSinter(List<String> args)`	Redis command SINTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSintercard(List<String> args)`	Redis command SINTERCARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSinterstore(List<String> args)`	Redis command SINTERSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSismember(String arg0, String arg1)`	Redis command SISMEMBER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSlaveof(String arg0, String arg1)`	Redis command SLAVEOF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSlowlog(List<String> args)`	Redis command SLOWLOG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSmembers(String arg0)`	Redis command SMEMBERS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSmismember(List<String> args)`	Redis command SMISMEMBER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSmove(String arg0, String arg1, String arg2)`	Redis command SMOVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSort(List<String> args)`	Redis command SORT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSortRo(List<String> args)`	Redis command SORT_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSpop(List<String> args)`	Redis command SPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSpublish(String arg0, String arg1)`	Redis command SPUBLISH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSrandmember(List<String> args)`	Redis command SRANDMEMBER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSrem(List<String> args)`	Redis command SREM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSscan(List<String> args)`	Redis command SSCAN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSsubscribe(List<String> args)`	Redis command SSUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxStrlen(String arg0)`	Redis command STRLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSubscribe(List<String> args)`	Redis command SUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSubstr(String arg0, String arg1, String arg2)`	Redis command SUBSTR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSunion(List<String> args)`	Redis command SUNION.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSunionstore(List<String> args)`	Redis command SUNIONSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSunsubscribe(List<String> args)`	Redis command SUNSUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSwapdb(String arg0, String arg1)`	Redis command SWAPDB.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxSync()`	Redis command SYNC.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestAdd(List<String> args)`	Redis command TDIGEST.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestByrank(List<String> args)`	Redis command TDIGEST.BYRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestByrevrank(List<String> args)`	Redis command TDIGEST.BYREVRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestCdf(List<String> args)`	Redis command TDIGEST.CDF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestCreate(List<String> args)`	Redis command TDIGEST.CREATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestInfo(List<String> args)`	Redis command TDIGEST.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestMax(List<String> args)`	Redis command TDIGEST.MAX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestMerge(List<String> args)`	Redis command TDIGEST.MERGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestMin(List<String> args)`	Redis command TDIGEST.MIN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestQuantile(List<String> args)`	Redis command TDIGEST.QUANTILE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestRank(List<String> args)`	Redis command TDIGEST.RANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestReset(List<String> args)`	Redis command TDIGEST.RESET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestRevrank(List<String> args)`	Redis command TDIGEST.REVRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTdigestTrimmedMean(List<String> args)`	Redis command TDIGEST.TRIMMED_MEAN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTime()`	Redis command TIME.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTimeseriesClusterset(List<String> args)`	Redis command TIMESERIES.CLUSTERSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTimeseriesClustersetfromshard(List<String> args)`	Redis command TIMESERIES.CLUSTERSETFROMSHARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTimeseriesHello(List<String> args)`	Redis command TIMESERIES.HELLO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTimeseriesInfocluster(List<String> args)`	Redis command TIMESERIES.INFOCLUSTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTimeseriesInnercommunication(List<String> args)`	Redis command TIMESERIES.INNERCOMMUNICATION.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTimeseriesNetworktest(List<String> args)`	Redis command TIMESERIES.NETWORKTEST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTimeseriesRefreshcluster(List<String> args)`	Redis command TIMESERIES.REFRESHCLUSTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTopkAdd(List<String> args)`	Redis command TOPK.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTopkCount(List<String> args)`	Redis command TOPK.COUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTopkIncrby(List<String> args)`	Redis command TOPK.INCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTopkInfo(List<String> args)`	Redis command TOPK.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTopkList(List<String> args)`	Redis command TOPK.LIST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTopkQuery(List<String> args)`	Redis command TOPK.QUERY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTopkReserve(List<String> args)`	Redis command TOPK.RESERVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTouch(List<String> args)`	Redis command TOUCH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsAdd(List<String> args)`	Redis command TS.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsAlter(List<String> args)`	Redis command TS.ALTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsCreate(List<String> args)`	Redis command TS.CREATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsCreaterule(List<String> args)`	Redis command TS.CREATERULE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsDecrby(List<String> args)`	Redis command TS.DECRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsDel(List<String> args)`	Redis command TS.DEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsDeleterule(List<String> args)`	Redis command TS.DELETERULE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsGet(List<String> args)`	Redis command TS.GET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsIncrby(List<String> args)`	Redis command TS.INCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsInfo(List<String> args)`	Redis command TS.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsMadd(List<String> args)`	Redis command TS.MADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsMget(List<String> args)`	Redis command TS.MGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsMrange(List<String> args)`	Redis command TS.MRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsMrevrange(List<String> args)`	Redis command TS.MREVRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsQueryindex(List<String> args)`	Redis command TS.QUERYINDEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsRange(List<String> args)`	Redis command TS.RANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTsRevrange(List<String> args)`	Redis command TS.REVRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxTtl(String arg0)`	Redis command TTL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxType(String arg0)`	Redis command TYPE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxUnlink(List<String> args)`	Redis command UNLINK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxUnsubscribe(List<String> args)`	Redis command UNSUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxUnwatch()`	Redis command UNWATCH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxWait(String arg0, String arg1)`	Redis command WAIT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxWatch(List<String> args)`	Redis command WATCH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXack(List<String> args)`	Redis command XACK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXadd(List<String> args)`	Redis command XADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXautoclaim(List<String> args)`	Redis command XAUTOCLAIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXclaim(List<String> args)`	Redis command XCLAIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXdel(List<String> args)`	Redis command XDEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXgroup(List<String> args)`	Redis command XGROUP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXinfo(List<String> args)`	Redis command XINFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXlen(String arg0)`	Redis command XLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXpending(List<String> args)`	Redis command XPENDING.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXrange(List<String> args)`	Redis command XRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXread(List<String> args)`	Redis command XREAD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXreadgroup(List<String> args)`	Redis command XREADGROUP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXrevrange(List<String> args)`	Redis command XREVRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXsetid(List<String> args)`	Redis command XSETID.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxXtrim(List<String> args)`	Redis command XTRIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZadd(List<String> args)`	Redis command ZADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZcard(String arg0)`	Redis command ZCARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZcount(String arg0, String arg1, String arg2)`	Redis command ZCOUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZdiff(List<String> args)`	Redis command ZDIFF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZdiffstore(List<String> args)`	Redis command ZDIFFSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZincrby(String arg0, String arg1, String arg2)`	Redis command ZINCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZinter(List<String> args)`	Redis command ZINTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZintercard(List<String> args)`	Redis command ZINTERCARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZinterstore(List<String> args)`	Redis command ZINTERSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZlexcount(String arg0, String arg1, String arg2)`	Redis command ZLEXCOUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZmpop(List<String> args)`	Redis command ZMPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZmscore(List<String> args)`	Redis command ZMSCORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZpopmax(List<String> args)`	Redis command ZPOPMAX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZpopmin(List<String> args)`	Redis command ZPOPMIN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZrandmember(List<String> args)`	Redis command ZRANDMEMBER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZrange(List<String> args)`	Redis command ZRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZrangebylex(List<String> args)`	Redis command ZRANGEBYLEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZrangebyscore(List<String> args)`	Redis command ZRANGEBYSCORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZrangestore(List<String> args)`	Redis command ZRANGESTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZrank(String arg0, String arg1)`	Redis command ZRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZrem(List<String> args)`	Redis command ZREM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZremrangebylex(String arg0, String arg1, String arg2)`	Redis command ZREMRANGEBYLEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZremrangebyrank(String arg0, String arg1, String arg2)`	Redis command ZREMRANGEBYRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZremrangebyscore(String arg0, String arg1, String arg2)`	Redis command ZREMRANGEBYSCORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZrevrange(List<String> args)`	Redis command ZREVRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZrevrangebylex(List<String> args)`	Redis command ZREVRANGEBYLEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZrevrangebyscore(List<String> args)`	Redis command ZREVRANGEBYSCORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZrevrank(String arg0, String arg1)`	Redis command ZREVRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZscan(List<String> args)`	Redis command ZSCAN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZscore(String arg0, String arg1)`	Redis command ZSCORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZunion(List<String> args)`	Redis command ZUNION.
`io.reactivex.rxjava3.core.Maybe<Response>`	`rxZunionstore(List<String> args)`	Redis command ZUNIONSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sadd(List<String> args)`	Redis command SADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`save()`	Redis command SAVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`scan(List<String> args)`	Redis command SCAN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`scard(String arg0)`	Redis command SCARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`script(List<String> args)`	Redis command SCRIPT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sdiff(List<String> args)`	Redis command SDIFF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sdiffstore(List<String> args)`	Redis command SDIFFSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`select(String arg0)`	Redis command SELECT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`set(List<String> args)`	Redis command SET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`setbit(String arg0, String arg1, String arg2)`	Redis command SETBIT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`setex(String arg0, String arg1, String arg2)`	Redis command SETEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`setnx(String arg0, String arg1)`	Redis command SETNX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`setrange(String arg0, String arg1, String arg2)`	Redis command SETRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`shutdown(List<String> args)`	Redis command SHUTDOWN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sinter(List<String> args)`	Redis command SINTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sintercard(List<String> args)`	Redis command SINTERCARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sinterstore(List<String> args)`	Redis command SINTERSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sismember(String arg0, String arg1)`	Redis command SISMEMBER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`slaveof(String arg0, String arg1)`	Redis command SLAVEOF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`slowlog(List<String> args)`	Redis command SLOWLOG.
`io.reactivex.rxjava3.core.Maybe<Response>`	`smembers(String arg0)`	Redis command SMEMBERS.
`io.reactivex.rxjava3.core.Maybe<Response>`	`smismember(List<String> args)`	Redis command SMISMEMBER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`smove(String arg0, String arg1, String arg2)`	Redis command SMOVE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sort(List<String> args)`	Redis command SORT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sortRo(List<String> args)`	Redis command SORT_RO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`spop(List<String> args)`	Redis command SPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`spublish(String arg0, String arg1)`	Redis command SPUBLISH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`srandmember(List<String> args)`	Redis command SRANDMEMBER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`srem(List<String> args)`	Redis command SREM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sscan(List<String> args)`	Redis command SSCAN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ssubscribe(List<String> args)`	Redis command SSUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`strlen(String arg0)`	Redis command STRLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`subscribe(List<String> args)`	Redis command SUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`substr(String arg0, String arg1, String arg2)`	Redis command SUBSTR.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sunion(List<String> args)`	Redis command SUNION.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sunionstore(List<String> args)`	Redis command SUNIONSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sunsubscribe(List<String> args)`	Redis command SUNSUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`swapdb(String arg0, String arg1)`	Redis command SWAPDB.
`io.reactivex.rxjava3.core.Maybe<Response>`	`sync()`	Redis command SYNC.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestAdd(List<String> args)`	Redis command TDIGEST.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestByrank(List<String> args)`	Redis command TDIGEST.BYRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestByrevrank(List<String> args)`	Redis command TDIGEST.BYREVRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestCdf(List<String> args)`	Redis command TDIGEST.CDF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestCreate(List<String> args)`	Redis command TDIGEST.CREATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestInfo(List<String> args)`	Redis command TDIGEST.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestMax(List<String> args)`	Redis command TDIGEST.MAX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestMerge(List<String> args)`	Redis command TDIGEST.MERGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestMin(List<String> args)`	Redis command TDIGEST.MIN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestQuantile(List<String> args)`	Redis command TDIGEST.QUANTILE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestRank(List<String> args)`	Redis command TDIGEST.RANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestReset(List<String> args)`	Redis command TDIGEST.RESET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestRevrank(List<String> args)`	Redis command TDIGEST.REVRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tdigestTrimmedMean(List<String> args)`	Redis command TDIGEST.TRIMMED_MEAN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`time()`	Redis command TIME.
`io.reactivex.rxjava3.core.Maybe<Response>`	`timeseriesClusterset(List<String> args)`	Redis command TIMESERIES.CLUSTERSET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`timeseriesClustersetfromshard(List<String> args)`	Redis command TIMESERIES.CLUSTERSETFROMSHARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`timeseriesHello(List<String> args)`	Redis command TIMESERIES.HELLO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`timeseriesInfocluster(List<String> args)`	Redis command TIMESERIES.INFOCLUSTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`timeseriesInnercommunication(List<String> args)`	Redis command TIMESERIES.INNERCOMMUNICATION.
`io.reactivex.rxjava3.core.Maybe<Response>`	`timeseriesNetworktest(List<String> args)`	Redis command TIMESERIES.NETWORKTEST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`timeseriesRefreshcluster(List<String> args)`	Redis command TIMESERIES.REFRESHCLUSTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`topkAdd(List<String> args)`	Redis command TOPK.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`topkCount(List<String> args)`	Redis command TOPK.COUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`topkIncrby(List<String> args)`	Redis command TOPK.INCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`topkInfo(List<String> args)`	Redis command TOPK.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`topkList(List<String> args)`	Redis command TOPK.LIST.
`io.reactivex.rxjava3.core.Maybe<Response>`	`topkQuery(List<String> args)`	Redis command TOPK.QUERY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`topkReserve(List<String> args)`	Redis command TOPK.RESERVE.
`String`	`toString()`
`io.reactivex.rxjava3.core.Maybe<Response>`	`touch(List<String> args)`	Redis command TOUCH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsAdd(List<String> args)`	Redis command TS.ADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsAlter(List<String> args)`	Redis command TS.ALTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsCreate(List<String> args)`	Redis command TS.CREATE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsCreaterule(List<String> args)`	Redis command TS.CREATERULE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsDecrby(List<String> args)`	Redis command TS.DECRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsDel(List<String> args)`	Redis command TS.DEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsDeleterule(List<String> args)`	Redis command TS.DELETERULE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsGet(List<String> args)`	Redis command TS.GET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsIncrby(List<String> args)`	Redis command TS.INCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsInfo(List<String> args)`	Redis command TS.INFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsMadd(List<String> args)`	Redis command TS.MADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsMget(List<String> args)`	Redis command TS.MGET.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsMrange(List<String> args)`	Redis command TS.MRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsMrevrange(List<String> args)`	Redis command TS.MREVRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsQueryindex(List<String> args)`	Redis command TS.QUERYINDEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsRange(List<String> args)`	Redis command TS.RANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`tsRevrange(List<String> args)`	Redis command TS.REVRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`ttl(String arg0)`	Redis command TTL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`type(String arg0)`	Redis command TYPE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`unlink(List<String> args)`	Redis command UNLINK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`unsubscribe(List<String> args)`	Redis command UNSUBSCRIBE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`unwatch()`	Redis command UNWATCH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`wait(String arg0, String arg1)`	Redis command WAIT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`watch(List<String> args)`	Redis command WATCH.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xack(List<String> args)`	Redis command XACK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xadd(List<String> args)`	Redis command XADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xautoclaim(List<String> args)`	Redis command XAUTOCLAIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xclaim(List<String> args)`	Redis command XCLAIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xdel(List<String> args)`	Redis command XDEL.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xgroup(List<String> args)`	Redis command XGROUP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xinfo(List<String> args)`	Redis command XINFO.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xlen(String arg0)`	Redis command XLEN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xpending(List<String> args)`	Redis command XPENDING.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xrange(List<String> args)`	Redis command XRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xread(List<String> args)`	Redis command XREAD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xreadgroup(List<String> args)`	Redis command XREADGROUP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xrevrange(List<String> args)`	Redis command XREVRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xsetid(List<String> args)`	Redis command XSETID.
`io.reactivex.rxjava3.core.Maybe<Response>`	`xtrim(List<String> args)`	Redis command XTRIM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zadd(List<String> args)`	Redis command ZADD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zcard(String arg0)`	Redis command ZCARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zcount(String arg0, String arg1, String arg2)`	Redis command ZCOUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zdiff(List<String> args)`	Redis command ZDIFF.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zdiffstore(List<String> args)`	Redis command ZDIFFSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zincrby(String arg0, String arg1, String arg2)`	Redis command ZINCRBY.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zinter(List<String> args)`	Redis command ZINTER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zintercard(List<String> args)`	Redis command ZINTERCARD.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zinterstore(List<String> args)`	Redis command ZINTERSTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zlexcount(String arg0, String arg1, String arg2)`	Redis command ZLEXCOUNT.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zmpop(List<String> args)`	Redis command ZMPOP.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zmscore(List<String> args)`	Redis command ZMSCORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zpopmax(List<String> args)`	Redis command ZPOPMAX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zpopmin(List<String> args)`	Redis command ZPOPMIN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zrandmember(List<String> args)`	Redis command ZRANDMEMBER.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zrange(List<String> args)`	Redis command ZRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zrangebylex(List<String> args)`	Redis command ZRANGEBYLEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zrangebyscore(List<String> args)`	Redis command ZRANGEBYSCORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zrangestore(List<String> args)`	Redis command ZRANGESTORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zrank(String arg0, String arg1)`	Redis command ZRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zrem(List<String> args)`	Redis command ZREM.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zremrangebylex(String arg0, String arg1, String arg2)`	Redis command ZREMRANGEBYLEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zremrangebyrank(String arg0, String arg1, String arg2)`	Redis command ZREMRANGEBYRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zremrangebyscore(String arg0, String arg1, String arg2)`	Redis command ZREMRANGEBYSCORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zrevrange(List<String> args)`	Redis command ZREVRANGE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zrevrangebylex(List<String> args)`	Redis command ZREVRANGEBYLEX.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zrevrangebyscore(List<String> args)`	Redis command ZREVRANGEBYSCORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zrevrank(String arg0, String arg1)`	Redis command ZREVRANK.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zscan(List<String> args)`	Redis command ZSCAN.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zscore(String arg0, String arg1)`	Redis command ZSCORE.
`io.reactivex.rxjava3.core.Maybe<Response>`	`zunion(List<String> args)`	Redis command ZUNION.
`io.reactivex.rxjava3.core.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 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 io.reactivex.rxjava3.core.Maybe<Response> ftAdd(List<String> args)

Redis command FT.ADD.

Parameters:: args -
Returns:: fluent self

rxFtAdd

public io.reactivex.rxjava3.core.Maybe<Response> rxFtAdd(List<String> args)

Redis command FT.ADD.

Parameters:: args -
Returns:: fluent self

ftAggregate

public io.reactivex.rxjava3.core.Maybe<Response> ftAggregate(List<String> args)

Redis command FT.AGGREGATE.

Parameters:: args -
Returns:: fluent self

rxFtAggregate

public io.reactivex.rxjava3.core.Maybe<Response> rxFtAggregate(List<String> args)

Redis command FT.AGGREGATE.

Parameters:: args -
Returns:: fluent self

ftAliasadd

public io.reactivex.rxjava3.core.Maybe<Response> ftAliasadd(List<String> args)

Redis command FT.ALIASADD.

Parameters:: args -
Returns:: fluent self

rxFtAliasadd

public io.reactivex.rxjava3.core.Maybe<Response> rxFtAliasadd(List<String> args)

Redis command FT.ALIASADD.

Parameters:: args -
Returns:: fluent self

ftAliasdel

public io.reactivex.rxjava3.core.Maybe<Response> ftAliasdel(List<String> args)

Redis command FT.ALIASDEL.

Parameters:: args -
Returns:: fluent self

rxFtAliasdel

public io.reactivex.rxjava3.core.Maybe<Response> rxFtAliasdel(List<String> args)

Redis command FT.ALIASDEL.

Parameters:: args -
Returns:: fluent self

ftAliasupdate

public io.reactivex.rxjava3.core.Maybe<Response> ftAliasupdate(List<String> args)

Redis command FT.ALIASUPDATE.

Parameters:: args -
Returns:: fluent self

rxFtAliasupdate

public io.reactivex.rxjava3.core.Maybe<Response> rxFtAliasupdate(List<String> args)

Redis command FT.ALIASUPDATE.

Parameters:: args -
Returns:: fluent self

ftAlter

public io.reactivex.rxjava3.core.Maybe<Response> ftAlter(List<String> args)

Redis command FT.ALTER.

Parameters:: args -
Returns:: fluent self

rxFtAlter

public io.reactivex.rxjava3.core.Maybe<Response> rxFtAlter(List<String> args)

Redis command FT.ALTER.

Parameters:: args -
Returns:: fluent self

ftConfig

public io.reactivex.rxjava3.core.Maybe<Response> ftConfig(List<String> args)

Redis command FT.CONFIG.

Parameters:: args -
Returns:: fluent self

rxFtConfig

public io.reactivex.rxjava3.core.Maybe<Response> rxFtConfig(List<String> args)

Redis command FT.CONFIG.

Parameters:: args -
Returns:: fluent self

ftCreate

public io.reactivex.rxjava3.core.Maybe<Response> ftCreate(List<String> args)

Redis command FT.CREATE.

Parameters:: args -
Returns:: fluent self

rxFtCreate

public io.reactivex.rxjava3.core.Maybe<Response> rxFtCreate(List<String> args)

Redis command FT.CREATE.

Parameters:: args -
Returns:: fluent self

ftCursor

public io.reactivex.rxjava3.core.Maybe<Response> ftCursor(List<String> args)

Redis command FT.CURSOR.

Parameters:: args -
Returns:: fluent self

rxFtCursor

public io.reactivex.rxjava3.core.Maybe<Response> rxFtCursor(List<String> args)

Redis command FT.CURSOR.

Parameters:: args -
Returns:: fluent self

ftDebug

public io.reactivex.rxjava3.core.Maybe<Response> ftDebug(List<String> args)

Redis command FT.DEBUG.

Parameters:: args -
Returns:: fluent self

rxFtDebug

public io.reactivex.rxjava3.core.Maybe<Response> rxFtDebug(List<String> args)

Redis command FT.DEBUG.

Parameters:: args -
Returns:: fluent self

ftDel

public io.reactivex.rxjava3.core.Maybe<Response> ftDel(List<String> args)

Redis command FT.DEL.

Parameters:: args -
Returns:: fluent self

rxFtDel

public io.reactivex.rxjava3.core.Maybe<Response> rxFtDel(List<String> args)

Redis command FT.DEL.

Parameters:: args -
Returns:: fluent self

ftDictadd

public io.reactivex.rxjava3.core.Maybe<Response> ftDictadd(List<String> args)

Redis command FT.DICTADD.

Parameters:: args -
Returns:: fluent self

rxFtDictadd

public io.reactivex.rxjava3.core.Maybe<Response> rxFtDictadd(List<String> args)

Redis command FT.DICTADD.

Parameters:: args -
Returns:: fluent self

ftDictdel

public io.reactivex.rxjava3.core.Maybe<Response> ftDictdel(List<String> args)

Redis command FT.DICTDEL.

Parameters:: args -
Returns:: fluent self

rxFtDictdel

public io.reactivex.rxjava3.core.Maybe<Response> rxFtDictdel(List<String> args)

Redis command FT.DICTDEL.

Parameters:: args -
Returns:: fluent self

ftDictdump

public io.reactivex.rxjava3.core.Maybe<Response> ftDictdump(List<String> args)

Redis command FT.DICTDUMP.

Parameters:: args -
Returns:: fluent self

rxFtDictdump

public io.reactivex.rxjava3.core.Maybe<Response> rxFtDictdump(List<String> args)

Redis command FT.DICTDUMP.

Parameters:: args -
Returns:: fluent self

ftDrop

public io.reactivex.rxjava3.core.Maybe<Response> ftDrop(List<String> args)

Redis command FT.DROP.

Parameters:: args -
Returns:: fluent self

rxFtDrop

public io.reactivex.rxjava3.core.Maybe<Response> rxFtDrop(List<String> args)

Redis command FT.DROP.

Parameters:: args -
Returns:: fluent self

ftDropindex

public io.reactivex.rxjava3.core.Maybe<Response> ftDropindex(List<String> args)

Redis command FT.DROPINDEX.

Parameters:: args -
Returns:: fluent self

rxFtDropindex

public io.reactivex.rxjava3.core.Maybe<Response> rxFtDropindex(List<String> args)

Redis command FT.DROPINDEX.

Parameters:: args -
Returns:: fluent self

ftExplain

public io.reactivex.rxjava3.core.Maybe<Response> ftExplain(List<String> args)

Redis command FT.EXPLAIN.

Parameters:: args -
Returns:: fluent self

rxFtExplain

public io.reactivex.rxjava3.core.Maybe<Response> rxFtExplain(List<String> args)

Redis command FT.EXPLAIN.

Parameters:: args -
Returns:: fluent self

ftExplaincli

public io.reactivex.rxjava3.core.Maybe<Response> ftExplaincli(List<String> args)

Redis command FT.EXPLAINCLI.

Parameters:: args -
Returns:: fluent self

rxFtExplaincli

public io.reactivex.rxjava3.core.Maybe<Response> rxFtExplaincli(List<String> args)

Redis command FT.EXPLAINCLI.

Parameters:: args -
Returns:: fluent self

ftGet

public io.reactivex.rxjava3.core.Maybe<Response> ftGet(List<String> args)

Redis command FT.GET.

Parameters:: args -
Returns:: fluent self

rxFtGet

public io.reactivex.rxjava3.core.Maybe<Response> rxFtGet(List<String> args)

Redis command FT.GET.

Parameters:: args -
Returns:: fluent self

ftInfo

public io.reactivex.rxjava3.core.Maybe<Response> ftInfo(List<String> args)

Redis command FT.INFO.

Parameters:: args -
Returns:: fluent self

rxFtInfo

public io.reactivex.rxjava3.core.Maybe<Response> rxFtInfo(List<String> args)

Redis command FT.INFO.

Parameters:: args -
Returns:: fluent self

ftMget

public io.reactivex.rxjava3.core.Maybe<Response> ftMget(List<String> args)

Redis command FT.MGET.

Parameters:: args -
Returns:: fluent self

rxFtMget

public io.reactivex.rxjava3.core.Maybe<Response> rxFtMget(List<String> args)

Redis command FT.MGET.

Parameters:: args -
Returns:: fluent self

ftProfile

public io.reactivex.rxjava3.core.Maybe<Response> ftProfile(List<String> args)

Redis command FT.PROFILE.

Parameters:: args -
Returns:: fluent self

rxFtProfile

public io.reactivex.rxjava3.core.Maybe<Response> rxFtProfile(List<String> args)

Redis command FT.PROFILE.

Parameters:: args -
Returns:: fluent self

ftSafeadd

public io.reactivex.rxjava3.core.Maybe<Response> ftSafeadd(List<String> args)

Redis command FT.SAFEADD.

Parameters:: args -
Returns:: fluent self

rxFtSafeadd

public io.reactivex.rxjava3.core.Maybe<Response> rxFtSafeadd(List<String> args)

Redis command FT.SAFEADD.

Parameters:: args -
Returns:: fluent self

ftSearch

public io.reactivex.rxjava3.core.Maybe<Response> ftSearch(List<String> args)

Redis command FT.SEARCH.

Parameters:: args -
Returns:: fluent self

rxFtSearch

public io.reactivex.rxjava3.core.Maybe<Response> rxFtSearch(List<String> args)

Redis command FT.SEARCH.

Parameters:: args -
Returns:: fluent self

ftSpellcheck

public io.reactivex.rxjava3.core.Maybe<Response> ftSpellcheck(List<String> args)

Redis command FT.SPELLCHECK.

Parameters:: args -
Returns:: fluent self

rxFtSpellcheck

public io.reactivex.rxjava3.core.Maybe<Response> rxFtSpellcheck(List<String> args)

Redis command FT.SPELLCHECK.

Parameters:: args -
Returns:: fluent self

ftSugadd

public io.reactivex.rxjava3.core.Maybe<Response> ftSugadd(List<String> args)

Redis command FT.SUGADD.

Parameters:: args -
Returns:: fluent self

rxFtSugadd

public io.reactivex.rxjava3.core.Maybe<Response> rxFtSugadd(List<String> args)

Redis command FT.SUGADD.

Parameters:: args -
Returns:: fluent self

ftSugdel

public io.reactivex.rxjava3.core.Maybe<Response> ftSugdel(List<String> args)

Redis command FT.SUGDEL.

Parameters:: args -
Returns:: fluent self

rxFtSugdel

public io.reactivex.rxjava3.core.Maybe<Response> rxFtSugdel(List<String> args)

Redis command FT.SUGDEL.

Parameters:: args -
Returns:: fluent self

ftSugget

public io.reactivex.rxjava3.core.Maybe<Response> ftSugget(List<String> args)

Redis command FT.SUGGET.

Parameters:: args -
Returns:: fluent self

rxFtSugget

public io.reactivex.rxjava3.core.Maybe<Response> rxFtSugget(List<String> args)

Redis command FT.SUGGET.

Parameters:: args -
Returns:: fluent self

ftSuglen

public io.reactivex.rxjava3.core.Maybe<Response> ftSuglen(List<String> args)

Redis command FT.SUGLEN.

Parameters:: args -
Returns:: fluent self

rxFtSuglen

public io.reactivex.rxjava3.core.Maybe<Response> rxFtSuglen(List<String> args)

Redis command FT.SUGLEN.

Parameters:: args -
Returns:: fluent self

ftSynadd

public io.reactivex.rxjava3.core.Maybe<Response> ftSynadd(List<String> args)

Redis command FT.SYNADD.

Parameters:: args -
Returns:: fluent self

rxFtSynadd

public io.reactivex.rxjava3.core.Maybe<Response> rxFtSynadd(List<String> args)

Redis command FT.SYNADD.

Parameters:: args -
Returns:: fluent self

ftSyndump

public io.reactivex.rxjava3.core.Maybe<Response> ftSyndump(List<String> args)

Redis command FT.SYNDUMP.

Parameters:: args -
Returns:: fluent self

rxFtSyndump

public io.reactivex.rxjava3.core.Maybe<Response> rxFtSyndump(List<String> args)

Redis command FT.SYNDUMP.

Parameters:: args -
Returns:: fluent self

ftSynupdate

public io.reactivex.rxjava3.core.Maybe<Response> ftSynupdate(List<String> args)

Redis command FT.SYNUPDATE.

Parameters:: args -
Returns:: fluent self

rxFtSynupdate

public io.reactivex.rxjava3.core.Maybe<Response> rxFtSynupdate(List<String> args)

Redis command FT.SYNUPDATE.

Parameters:: args -
Returns:: fluent self

ftTagvals

public io.reactivex.rxjava3.core.Maybe<Response> ftTagvals(List<String> args)

Redis command FT.TAGVALS.

Parameters:: args -
Returns:: fluent self

rxFtTagvals

public io.reactivex.rxjava3.core.Maybe<Response> rxFtTagvals(List<String> args)

Redis command FT.TAGVALS.

Parameters:: args -
Returns:: fluent self

ftAliasaddifnx

public io.reactivex.rxjava3.core.Maybe<Response> ftAliasaddifnx(List<String> args)

Redis command FT._ALIASADDIFNX.

Parameters:: args -
Returns:: fluent self

rxFtAliasaddifnx

public io.reactivex.rxjava3.core.Maybe<Response> rxFtAliasaddifnx(List<String> args)

Redis command FT._ALIASADDIFNX.

Parameters:: args -
Returns:: fluent self

ftAliasdelifx

public io.reactivex.rxjava3.core.Maybe<Response> ftAliasdelifx(List<String> args)

Redis command FT._ALIASDELIFX.

Parameters:: args -
Returns:: fluent self

rxFtAliasdelifx

public io.reactivex.rxjava3.core.Maybe<Response> rxFtAliasdelifx(List<String> args)

Redis command FT._ALIASDELIFX.

Parameters:: args -
Returns:: fluent self

ftAlterifnx

public io.reactivex.rxjava3.core.Maybe<Response> ftAlterifnx(List<String> args)

Redis command FT._ALTERIFNX.

Parameters:: args -
Returns:: fluent self

rxFtAlterifnx

public io.reactivex.rxjava3.core.Maybe<Response> rxFtAlterifnx(List<String> args)

Redis command FT._ALTERIFNX.

Parameters:: args -
Returns:: fluent self

ftCreateifnx

public io.reactivex.rxjava3.core.Maybe<Response> ftCreateifnx(List<String> args)

Redis command FT._CREATEIFNX.

Parameters:: args -
Returns:: fluent self

rxFtCreateifnx

public io.reactivex.rxjava3.core.Maybe<Response> rxFtCreateifnx(List<String> args)

Redis command FT._CREATEIFNX.

Parameters:: args -
Returns:: fluent self

ftDropifx

public io.reactivex.rxjava3.core.Maybe<Response> ftDropifx(List<String> args)

Redis command FT._DROPIFX.

Parameters:: args -
Returns:: fluent self

rxFtDropifx

public io.reactivex.rxjava3.core.Maybe<Response> rxFtDropifx(List<String> args)

Redis command FT._DROPIFX.

Parameters:: args -
Returns:: fluent self

ftDropindexifx

public io.reactivex.rxjava3.core.Maybe<Response> ftDropindexifx(List<String> args)

Redis command FT._DROPINDEXIFX.

Parameters:: args -
Returns:: fluent self

rxFtDropindexifx

public io.reactivex.rxjava3.core.Maybe<Response> rxFtDropindexifx(List<String> args)

Redis command FT._DROPINDEXIFX.

Parameters:: args -
Returns:: fluent self

ftList

public io.reactivex.rxjava3.core.Maybe<Response> ftList(List<String> args)

Redis command FT._LIST.

Parameters:: args -
Returns:: fluent self

rxFtList

public io.reactivex.rxjava3.core.Maybe<Response> rxFtList(List<String> args)

Redis command FT._LIST.

Parameters:: args -
Returns:: fluent self

acl

public io.reactivex.rxjava3.core.Maybe<Response> acl(List<String> args)

Redis command ACL.

Parameters:: args -
Returns:: fluent self

rxAcl

public io.reactivex.rxjava3.core.Maybe<Response> rxAcl(List<String> args)

Redis command ACL.

Parameters:: args -
Returns:: fluent self

append

public io.reactivex.rxjava3.core.Maybe<Response> append(String arg0,
                                                        String arg1)

Redis command APPEND.

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

rxAppend

public io.reactivex.rxjava3.core.Maybe<Response> rxAppend(String arg0,
                                                          String arg1)

Redis command APPEND.

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

asking

public io.reactivex.rxjava3.core.Maybe<Response> asking()

Redis command ASKING.

Returns:: fluent self

rxAsking

public io.reactivex.rxjava3.core.Maybe<Response> rxAsking()

Redis command ASKING.

Returns:: fluent self

auth

public io.reactivex.rxjava3.core.Maybe<Response> auth(List<String> args)

Redis command AUTH.

Parameters:: args -
Returns:: fluent self

rxAuth

public io.reactivex.rxjava3.core.Maybe<Response> rxAuth(List<String> args)

Redis command AUTH.

Parameters:: args -
Returns:: fluent self

bfAdd

public io.reactivex.rxjava3.core.Maybe<Response> bfAdd(List<String> args)

Redis command BF.ADD.

Parameters:: args -
Returns:: fluent self

rxBfAdd

public io.reactivex.rxjava3.core.Maybe<Response> rxBfAdd(List<String> args)

Redis command BF.ADD.

Parameters:: args -
Returns:: fluent self

bfCard

public io.reactivex.rxjava3.core.Maybe<Response> bfCard(List<String> args)

Redis command BF.CARD.

Parameters:: args -
Returns:: fluent self

rxBfCard

public io.reactivex.rxjava3.core.Maybe<Response> rxBfCard(List<String> args)

Redis command BF.CARD.

Parameters:: args -
Returns:: fluent self

bfDebug

public io.reactivex.rxjava3.core.Maybe<Response> bfDebug(List<String> args)

Redis command BF.DEBUG.

Parameters:: args -
Returns:: fluent self

rxBfDebug

public io.reactivex.rxjava3.core.Maybe<Response> rxBfDebug(List<String> args)

Redis command BF.DEBUG.

Parameters:: args -
Returns:: fluent self

bfExists

public io.reactivex.rxjava3.core.Maybe<Response> bfExists(List<String> args)

Redis command BF.EXISTS.

Parameters:: args -
Returns:: fluent self

rxBfExists

public io.reactivex.rxjava3.core.Maybe<Response> rxBfExists(List<String> args)

Redis command BF.EXISTS.

Parameters:: args -
Returns:: fluent self

bfInfo

public io.reactivex.rxjava3.core.Maybe<Response> bfInfo(List<String> args)

Redis command BF.INFO.

Parameters:: args -
Returns:: fluent self

rxBfInfo

public io.reactivex.rxjava3.core.Maybe<Response> rxBfInfo(List<String> args)

Redis command BF.INFO.

Parameters:: args -
Returns:: fluent self

bfInsert

public io.reactivex.rxjava3.core.Maybe<Response> bfInsert(List<String> args)

Redis command BF.INSERT.

Parameters:: args -
Returns:: fluent self

rxBfInsert

public io.reactivex.rxjava3.core.Maybe<Response> rxBfInsert(List<String> args)

Redis command BF.INSERT.

Parameters:: args -
Returns:: fluent self

bfLoadchunk

public io.reactivex.rxjava3.core.Maybe<Response> bfLoadchunk(List<String> args)

Redis command BF.LOADCHUNK.

Parameters:: args -
Returns:: fluent self

rxBfLoadchunk

public io.reactivex.rxjava3.core.Maybe<Response> rxBfLoadchunk(List<String> args)

Redis command BF.LOADCHUNK.

Parameters:: args -
Returns:: fluent self

bfMadd

public io.reactivex.rxjava3.core.Maybe<Response> bfMadd(List<String> args)

Redis command BF.MADD.

Parameters:: args -
Returns:: fluent self

rxBfMadd

public io.reactivex.rxjava3.core.Maybe<Response> rxBfMadd(List<String> args)

Redis command BF.MADD.

Parameters:: args -
Returns:: fluent self

bfMexists

public io.reactivex.rxjava3.core.Maybe<Response> bfMexists(List<String> args)

Redis command BF.MEXISTS.

Parameters:: args -
Returns:: fluent self

rxBfMexists

public io.reactivex.rxjava3.core.Maybe<Response> rxBfMexists(List<String> args)

Redis command BF.MEXISTS.

Parameters:: args -
Returns:: fluent self

bfReserve

public io.reactivex.rxjava3.core.Maybe<Response> bfReserve(List<String> args)

Redis command BF.RESERVE.

Parameters:: args -
Returns:: fluent self

rxBfReserve

public io.reactivex.rxjava3.core.Maybe<Response> rxBfReserve(List<String> args)

Redis command BF.RESERVE.

Parameters:: args -
Returns:: fluent self

bfScandump

public io.reactivex.rxjava3.core.Maybe<Response> bfScandump(List<String> args)

Redis command BF.SCANDUMP.

Parameters:: args -
Returns:: fluent self

rxBfScandump

public io.reactivex.rxjava3.core.Maybe<Response> rxBfScandump(List<String> args)

Redis command BF.SCANDUMP.

Parameters:: args -
Returns:: fluent self

bgrewriteaof

public io.reactivex.rxjava3.core.Maybe<Response> bgrewriteaof()

Redis command BGREWRITEAOF.

Returns:: fluent self

rxBgrewriteaof

public io.reactivex.rxjava3.core.Maybe<Response> rxBgrewriteaof()

Redis command BGREWRITEAOF.

Returns:: fluent self

bgsave

public io.reactivex.rxjava3.core.Maybe<Response> bgsave(List<String> args)

Redis command BGSAVE.

Parameters:: args -
Returns:: fluent self

rxBgsave

public io.reactivex.rxjava3.core.Maybe<Response> rxBgsave(List<String> args)

Redis command BGSAVE.

Parameters:: args -
Returns:: fluent self

bitcount

public io.reactivex.rxjava3.core.Maybe<Response> bitcount(List<String> args)

Redis command BITCOUNT.

Parameters:: args -
Returns:: fluent self

rxBitcount

public io.reactivex.rxjava3.core.Maybe<Response> rxBitcount(List<String> args)

Redis command BITCOUNT.

Parameters:: args -
Returns:: fluent self

bitfield

public io.reactivex.rxjava3.core.Maybe<Response> bitfield(List<String> args)

Redis command BITFIELD.

Parameters:: args -
Returns:: fluent self

rxBitfield

public io.reactivex.rxjava3.core.Maybe<Response> rxBitfield(List<String> args)

Redis command BITFIELD.

Parameters:: args -
Returns:: fluent self

bitfieldRo

public io.reactivex.rxjava3.core.Maybe<Response> bitfieldRo(List<String> args)

Redis command BITFIELD_RO.

Parameters:: args -
Returns:: fluent self

rxBitfieldRo

public io.reactivex.rxjava3.core.Maybe<Response> rxBitfieldRo(List<String> args)

Redis command BITFIELD_RO.

Parameters:: args -
Returns:: fluent self

bitop

public io.reactivex.rxjava3.core.Maybe<Response> bitop(List<String> args)

Redis command BITOP.

Parameters:: args -
Returns:: fluent self

rxBitop

public io.reactivex.rxjava3.core.Maybe<Response> rxBitop(List<String> args)

Redis command BITOP.

Parameters:: args -
Returns:: fluent self

bitpos

public io.reactivex.rxjava3.core.Maybe<Response> bitpos(List<String> args)

Redis command BITPOS.

Parameters:: args -
Returns:: fluent self

rxBitpos

public io.reactivex.rxjava3.core.Maybe<Response> rxBitpos(List<String> args)

Redis command BITPOS.

Parameters:: args -
Returns:: fluent self

blmove

public io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.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 io.reactivex.rxjava3.core.Maybe<Response> blmpop(List<String> args)

Redis command BLMPOP.

Parameters:: args -
Returns:: fluent self

rxBlmpop

public io.reactivex.rxjava3.core.Maybe<Response> rxBlmpop(List<String> args)

Redis command BLMPOP.

Parameters:: args -
Returns:: fluent self

blpop

public io.reactivex.rxjava3.core.Maybe<Response> blpop(List<String> args)

Redis command BLPOP.

Parameters:: args -
Returns:: fluent self

rxBlpop

public io.reactivex.rxjava3.core.Maybe<Response> rxBlpop(List<String> args)

Redis command BLPOP.

Parameters:: args -
Returns:: fluent self

brpop

public io.reactivex.rxjava3.core.Maybe<Response> brpop(List<String> args)

Redis command BRPOP.

Parameters:: args -
Returns:: fluent self

rxBrpop

public io.reactivex.rxjava3.core.Maybe<Response> rxBrpop(List<String> args)

Redis command BRPOP.

Parameters:: args -
Returns:: fluent self

brpoplpush

public io.reactivex.rxjava3.core.Maybe<Response> brpoplpush(String arg0,
                                                            String arg1,
                                                            String arg2)

Redis command BRPOPLPUSH.

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

rxBrpoplpush

public io.reactivex.rxjava3.core.Maybe<Response> rxBrpoplpush(String arg0,
                                                              String arg1,
                                                              String arg2)

Redis command BRPOPLPUSH.

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

bzmpop

public io.reactivex.rxjava3.core.Maybe<Response> bzmpop(List<String> args)

Redis command BZMPOP.

Parameters:: args -
Returns:: fluent self

rxBzmpop

public io.reactivex.rxjava3.core.Maybe<Response> rxBzmpop(List<String> args)

Redis command BZMPOP.

Parameters:: args -
Returns:: fluent self

bzpopmax

public io.reactivex.rxjava3.core.Maybe<Response> bzpopmax(List<String> args)

Redis command BZPOPMAX.

Parameters:: args -
Returns:: fluent self

rxBzpopmax

public io.reactivex.rxjava3.core.Maybe<Response> rxBzpopmax(List<String> args)

Redis command BZPOPMAX.

Parameters:: args -
Returns:: fluent self

bzpopmin

public io.reactivex.rxjava3.core.Maybe<Response> bzpopmin(List<String> args)

Redis command BZPOPMIN.

Parameters:: args -
Returns:: fluent self

rxBzpopmin

public io.reactivex.rxjava3.core.Maybe<Response> rxBzpopmin(List<String> args)

Redis command BZPOPMIN.

Parameters:: args -
Returns:: fluent self

cfAdd

public io.reactivex.rxjava3.core.Maybe<Response> cfAdd(List<String> args)

Redis command CF.ADD.

Parameters:: args -
Returns:: fluent self

rxCfAdd

public io.reactivex.rxjava3.core.Maybe<Response> rxCfAdd(List<String> args)

Redis command CF.ADD.

Parameters:: args -
Returns:: fluent self

cfAddnx

public io.reactivex.rxjava3.core.Maybe<Response> cfAddnx(List<String> args)

Redis command CF.ADDNX.

Parameters:: args -
Returns:: fluent self

rxCfAddnx

public io.reactivex.rxjava3.core.Maybe<Response> rxCfAddnx(List<String> args)

Redis command CF.ADDNX.

Parameters:: args -
Returns:: fluent self

cfCompact

public io.reactivex.rxjava3.core.Maybe<Response> cfCompact(List<String> args)

Redis command CF.COMPACT.

Parameters:: args -
Returns:: fluent self

rxCfCompact

public io.reactivex.rxjava3.core.Maybe<Response> rxCfCompact(List<String> args)

Redis command CF.COMPACT.

Parameters:: args -
Returns:: fluent self

cfCount

public io.reactivex.rxjava3.core.Maybe<Response> cfCount(List<String> args)

Redis command CF.COUNT.

Parameters:: args -
Returns:: fluent self

rxCfCount

public io.reactivex.rxjava3.core.Maybe<Response> rxCfCount(List<String> args)

Redis command CF.COUNT.

Parameters:: args -
Returns:: fluent self

cfDebug

public io.reactivex.rxjava3.core.Maybe<Response> cfDebug(List<String> args)

Redis command CF.DEBUG.

Parameters:: args -
Returns:: fluent self

rxCfDebug

public io.reactivex.rxjava3.core.Maybe<Response> rxCfDebug(List<String> args)

Redis command CF.DEBUG.

Parameters:: args -
Returns:: fluent self

cfDel

public io.reactivex.rxjava3.core.Maybe<Response> cfDel(List<String> args)

Redis command CF.DEL.

Parameters:: args -
Returns:: fluent self

rxCfDel

public io.reactivex.rxjava3.core.Maybe<Response> rxCfDel(List<String> args)

Redis command CF.DEL.

Parameters:: args -
Returns:: fluent self

cfExists

public io.reactivex.rxjava3.core.Maybe<Response> cfExists(List<String> args)

Redis command CF.EXISTS.

Parameters:: args -
Returns:: fluent self

rxCfExists

public io.reactivex.rxjava3.core.Maybe<Response> rxCfExists(List<String> args)

Redis command CF.EXISTS.

Parameters:: args -
Returns:: fluent self

cfInfo

public io.reactivex.rxjava3.core.Maybe<Response> cfInfo(List<String> args)

Redis command CF.INFO.

Parameters:: args -
Returns:: fluent self

rxCfInfo

public io.reactivex.rxjava3.core.Maybe<Response> rxCfInfo(List<String> args)

Redis command CF.INFO.

Parameters:: args -
Returns:: fluent self

cfInsert

public io.reactivex.rxjava3.core.Maybe<Response> cfInsert(List<String> args)

Redis command CF.INSERT.

Parameters:: args -
Returns:: fluent self

rxCfInsert

public io.reactivex.rxjava3.core.Maybe<Response> rxCfInsert(List<String> args)

Redis command CF.INSERT.

Parameters:: args -
Returns:: fluent self

cfInsertnx

public io.reactivex.rxjava3.core.Maybe<Response> cfInsertnx(List<String> args)

Redis command CF.INSERTNX.

Parameters:: args -
Returns:: fluent self

rxCfInsertnx

public io.reactivex.rxjava3.core.Maybe<Response> rxCfInsertnx(List<String> args)

Redis command CF.INSERTNX.

Parameters:: args -
Returns:: fluent self

cfLoadchunk

public io.reactivex.rxjava3.core.Maybe<Response> cfLoadchunk(List<String> args)

Redis command CF.LOADCHUNK.

Parameters:: args -
Returns:: fluent self

rxCfLoadchunk

public io.reactivex.rxjava3.core.Maybe<Response> rxCfLoadchunk(List<String> args)

Redis command CF.LOADCHUNK.

Parameters:: args -
Returns:: fluent self

cfMexists

public io.reactivex.rxjava3.core.Maybe<Response> cfMexists(List<String> args)

Redis command CF.MEXISTS.

Parameters:: args -
Returns:: fluent self

rxCfMexists

public io.reactivex.rxjava3.core.Maybe<Response> rxCfMexists(List<String> args)

Redis command CF.MEXISTS.

Parameters:: args -
Returns:: fluent self

cfReserve

public io.reactivex.rxjava3.core.Maybe<Response> cfReserve(List<String> args)

Redis command CF.RESERVE.

Parameters:: args -
Returns:: fluent self

rxCfReserve

public io.reactivex.rxjava3.core.Maybe<Response> rxCfReserve(List<String> args)

Redis command CF.RESERVE.

Parameters:: args -
Returns:: fluent self

cfScandump

public io.reactivex.rxjava3.core.Maybe<Response> cfScandump(List<String> args)

Redis command CF.SCANDUMP.

Parameters:: args -
Returns:: fluent self

rxCfScandump

public io.reactivex.rxjava3.core.Maybe<Response> rxCfScandump(List<String> args)

Redis command CF.SCANDUMP.

Parameters:: args -
Returns:: fluent self

client

public io.reactivex.rxjava3.core.Maybe<Response> client(List<String> args)

Redis command CLIENT.

Parameters:: args -
Returns:: fluent self

rxClient

public io.reactivex.rxjava3.core.Maybe<Response> rxClient(List<String> args)

Redis command CLIENT.

Parameters:: args -
Returns:: fluent self

cluster

public io.reactivex.rxjava3.core.Maybe<Response> cluster(List<String> args)

Redis command CLUSTER.

Parameters:: args -
Returns:: fluent self

rxCluster

public io.reactivex.rxjava3.core.Maybe<Response> rxCluster(List<String> args)

Redis command CLUSTER.

Parameters:: args -
Returns:: fluent self

cmsIncrby

public io.reactivex.rxjava3.core.Maybe<Response> cmsIncrby(List<String> args)

Redis command CMS.INCRBY.

Parameters:: args -
Returns:: fluent self

rxCmsIncrby

public io.reactivex.rxjava3.core.Maybe<Response> rxCmsIncrby(List<String> args)

Redis command CMS.INCRBY.

Parameters:: args -
Returns:: fluent self

cmsInfo

public io.reactivex.rxjava3.core.Maybe<Response> cmsInfo(List<String> args)

Redis command CMS.INFO.

Parameters:: args -
Returns:: fluent self

rxCmsInfo

public io.reactivex.rxjava3.core.Maybe<Response> rxCmsInfo(List<String> args)

Redis command CMS.INFO.

Parameters:: args -
Returns:: fluent self

cmsInitbydim

public io.reactivex.rxjava3.core.Maybe<Response> cmsInitbydim(List<String> args)

Redis command CMS.INITBYDIM.

Parameters:: args -
Returns:: fluent self

rxCmsInitbydim

public io.reactivex.rxjava3.core.Maybe<Response> rxCmsInitbydim(List<String> args)

Redis command CMS.INITBYDIM.

Parameters:: args -
Returns:: fluent self

cmsInitbyprob

public io.reactivex.rxjava3.core.Maybe<Response> cmsInitbyprob(List<String> args)

Redis command CMS.INITBYPROB.

Parameters:: args -
Returns:: fluent self

rxCmsInitbyprob

public io.reactivex.rxjava3.core.Maybe<Response> rxCmsInitbyprob(List<String> args)

Redis command CMS.INITBYPROB.

Parameters:: args -
Returns:: fluent self

cmsMerge

public io.reactivex.rxjava3.core.Maybe<Response> cmsMerge(List<String> args)

Redis command CMS.MERGE.

Parameters:: args -
Returns:: fluent self

rxCmsMerge

public io.reactivex.rxjava3.core.Maybe<Response> rxCmsMerge(List<String> args)

Redis command CMS.MERGE.

Parameters:: args -
Returns:: fluent self

cmsQuery

public io.reactivex.rxjava3.core.Maybe<Response> cmsQuery(List<String> args)

Redis command CMS.QUERY.

Parameters:: args -
Returns:: fluent self

rxCmsQuery

public io.reactivex.rxjava3.core.Maybe<Response> rxCmsQuery(List<String> args)

Redis command CMS.QUERY.

Parameters:: args -
Returns:: fluent self

command

public io.reactivex.rxjava3.core.Maybe<Response> command(List<String> args)

Redis command COMMAND.

Parameters:: args -
Returns:: fluent self

rxCommand

public io.reactivex.rxjava3.core.Maybe<Response> rxCommand(List<String> args)

Redis command COMMAND.

Parameters:: args -
Returns:: fluent self

config

public io.reactivex.rxjava3.core.Maybe<Response> config(List<String> args)

Redis command CONFIG.

Parameters:: args -
Returns:: fluent self

rxConfig

public io.reactivex.rxjava3.core.Maybe<Response> rxConfig(List<String> args)

Redis command CONFIG.

Parameters:: args -
Returns:: fluent self

copy

public io.reactivex.rxjava3.core.Maybe<Response> copy(List<String> args)

Redis command COPY.

Parameters:: args -
Returns:: fluent self

rxCopy

public io.reactivex.rxjava3.core.Maybe<Response> rxCopy(List<String> args)

Redis command COPY.

Parameters:: args -
Returns:: fluent self

dbsize

public io.reactivex.rxjava3.core.Maybe<Response> dbsize()

Redis command DBSIZE.

Returns:: fluent self

rxDbsize

public io.reactivex.rxjava3.core.Maybe<Response> rxDbsize()

Redis command DBSIZE.

Returns:: fluent self

debug

public io.reactivex.rxjava3.core.Maybe<Response> debug(List<String> args)

Redis command DEBUG.

Parameters:: args -
Returns:: fluent self

rxDebug

public io.reactivex.rxjava3.core.Maybe<Response> rxDebug(List<String> args)

Redis command DEBUG.

Parameters:: args -
Returns:: fluent self

decr

public io.reactivex.rxjava3.core.Maybe<Response> decr(String arg0)

Redis command DECR.

Parameters:: arg0 -
Returns:: fluent self

rxDecr

public io.reactivex.rxjava3.core.Maybe<Response> rxDecr(String arg0)

Redis command DECR.

Parameters:: arg0 -
Returns:: fluent self

decrby

public io.reactivex.rxjava3.core.Maybe<Response> decrby(String arg0,
                                                        String arg1)

Redis command DECRBY.

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

rxDecrby

public io.reactivex.rxjava3.core.Maybe<Response> rxDecrby(String arg0,
                                                          String arg1)

Redis command DECRBY.

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

del

public io.reactivex.rxjava3.core.Maybe<Response> del(List<String> args)

Redis command DEL.

Parameters:: args -
Returns:: fluent self

rxDel

public io.reactivex.rxjava3.core.Maybe<Response> rxDel(List<String> args)

Redis command DEL.

Parameters:: args -
Returns:: fluent self

discard

public io.reactivex.rxjava3.core.Maybe<Response> discard()

Redis command DISCARD.

Returns:: fluent self

rxDiscard

public io.reactivex.rxjava3.core.Maybe<Response> rxDiscard()

Redis command DISCARD.

Returns:: fluent self

dump

public io.reactivex.rxjava3.core.Maybe<Response> dump(String arg0)

Redis command DUMP.

Parameters:: arg0 -
Returns:: fluent self

rxDump

public io.reactivex.rxjava3.core.Maybe<Response> rxDump(String arg0)

Redis command DUMP.

Parameters:: arg0 -
Returns:: fluent self

echo

public io.reactivex.rxjava3.core.Maybe<Response> echo(String arg0)

Redis command ECHO.

Parameters:: arg0 -
Returns:: fluent self

rxEcho

public io.reactivex.rxjava3.core.Maybe<Response> rxEcho(String arg0)

Redis command ECHO.

Parameters:: arg0 -
Returns:: fluent self

eval

public io.reactivex.rxjava3.core.Maybe<Response> eval(List<String> args)

Redis command EVAL.

Parameters:: args -
Returns:: fluent self

rxEval

public io.reactivex.rxjava3.core.Maybe<Response> rxEval(List<String> args)

Redis command EVAL.

Parameters:: args -
Returns:: fluent self

evalRo

public io.reactivex.rxjava3.core.Maybe<Response> evalRo(List<String> args)

Redis command EVAL_RO.

Parameters:: args -
Returns:: fluent self

rxEvalRo

public io.reactivex.rxjava3.core.Maybe<Response> rxEvalRo(List<String> args)

Redis command EVAL_RO.

Parameters:: args -
Returns:: fluent self

evalsha

public io.reactivex.rxjava3.core.Maybe<Response> evalsha(List<String> args)

Redis command EVALSHA.

Parameters:: args -
Returns:: fluent self

rxEvalsha

public io.reactivex.rxjava3.core.Maybe<Response> rxEvalsha(List<String> args)

Redis command EVALSHA.

Parameters:: args -
Returns:: fluent self

evalshaRo

public io.reactivex.rxjava3.core.Maybe<Response> evalshaRo(List<String> args)

Redis command EVALSHA_RO.

Parameters:: args -
Returns:: fluent self

rxEvalshaRo

public io.reactivex.rxjava3.core.Maybe<Response> rxEvalshaRo(List<String> args)

Redis command EVALSHA_RO.

Parameters:: args -
Returns:: fluent self

exec

public io.reactivex.rxjava3.core.Maybe<Response> exec()

Redis command EXEC.

Returns:: fluent self

rxExec

public io.reactivex.rxjava3.core.Maybe<Response> rxExec()

Redis command EXEC.

Returns:: fluent self

exists

public io.reactivex.rxjava3.core.Maybe<Response> exists(List<String> args)

Redis command EXISTS.

Parameters:: args -
Returns:: fluent self

rxExists

public io.reactivex.rxjava3.core.Maybe<Response> rxExists(List<String> args)

Redis command EXISTS.

Parameters:: args -
Returns:: fluent self

expire

public io.reactivex.rxjava3.core.Maybe<Response> expire(List<String> args)

Redis command EXPIRE.

Parameters:: args -
Returns:: fluent self

rxExpire

public io.reactivex.rxjava3.core.Maybe<Response> rxExpire(List<String> args)

Redis command EXPIRE.

Parameters:: args -
Returns:: fluent self

expireat

public io.reactivex.rxjava3.core.Maybe<Response> expireat(List<String> args)

Redis command EXPIREAT.

Parameters:: args -
Returns:: fluent self

rxExpireat

public io.reactivex.rxjava3.core.Maybe<Response> rxExpireat(List<String> args)

Redis command EXPIREAT.

Parameters:: args -
Returns:: fluent self

expiretime

public io.reactivex.rxjava3.core.Maybe<Response> expiretime(String arg0)

Redis command EXPIRETIME.

Parameters:: arg0 -
Returns:: fluent self

rxExpiretime

public io.reactivex.rxjava3.core.Maybe<Response> rxExpiretime(String arg0)

Redis command EXPIRETIME.

Parameters:: arg0 -
Returns:: fluent self

failover

public io.reactivex.rxjava3.core.Maybe<Response> failover(List<String> args)

Redis command FAILOVER.

Parameters:: args -
Returns:: fluent self

rxFailover

public io.reactivex.rxjava3.core.Maybe<Response> rxFailover(List<String> args)

Redis command FAILOVER.

Parameters:: args -
Returns:: fluent self

fcall

public io.reactivex.rxjava3.core.Maybe<Response> fcall(List<String> args)

Redis command FCALL.

Parameters:: args -
Returns:: fluent self

rxFcall

public io.reactivex.rxjava3.core.Maybe<Response> rxFcall(List<String> args)

Redis command FCALL.

Parameters:: args -
Returns:: fluent self

fcallRo

public io.reactivex.rxjava3.core.Maybe<Response> fcallRo(List<String> args)

Redis command FCALL_RO.

Parameters:: args -
Returns:: fluent self

rxFcallRo

public io.reactivex.rxjava3.core.Maybe<Response> rxFcallRo(List<String> args)

Redis command FCALL_RO.

Parameters:: args -
Returns:: fluent self

flushall

public io.reactivex.rxjava3.core.Maybe<Response> flushall(List<String> args)

Redis command FLUSHALL.

Parameters:: args -
Returns:: fluent self

rxFlushall

public io.reactivex.rxjava3.core.Maybe<Response> rxFlushall(List<String> args)

Redis command FLUSHALL.

Parameters:: args -
Returns:: fluent self

flushdb

public io.reactivex.rxjava3.core.Maybe<Response> flushdb(List<String> args)

Redis command FLUSHDB.

Parameters:: args -
Returns:: fluent self

rxFlushdb

public io.reactivex.rxjava3.core.Maybe<Response> rxFlushdb(List<String> args)

Redis command FLUSHDB.

Parameters:: args -
Returns:: fluent self

function

public io.reactivex.rxjava3.core.Maybe<Response> function(List<String> args)

Redis command FUNCTION.

Parameters:: args -
Returns:: fluent self

rxFunction

public io.reactivex.rxjava3.core.Maybe<Response> rxFunction(List<String> args)

Redis command FUNCTION.

Parameters:: args -
Returns:: fluent self

geoadd

public io.reactivex.rxjava3.core.Maybe<Response> geoadd(List<String> args)

Redis command GEOADD.

Parameters:: args -
Returns:: fluent self

rxGeoadd

public io.reactivex.rxjava3.core.Maybe<Response> rxGeoadd(List<String> args)

Redis command GEOADD.

Parameters:: args -
Returns:: fluent self

geodist

public io.reactivex.rxjava3.core.Maybe<Response> geodist(List<String> args)

Redis command GEODIST.

Parameters:: args -
Returns:: fluent self

rxGeodist

public io.reactivex.rxjava3.core.Maybe<Response> rxGeodist(List<String> args)

Redis command GEODIST.

Parameters:: args -
Returns:: fluent self

geohash

public io.reactivex.rxjava3.core.Maybe<Response> geohash(List<String> args)

Redis command GEOHASH.

Parameters:: args -
Returns:: fluent self

rxGeohash

public io.reactivex.rxjava3.core.Maybe<Response> rxGeohash(List<String> args)

Redis command GEOHASH.

Parameters:: args -
Returns:: fluent self

geopos

public io.reactivex.rxjava3.core.Maybe<Response> geopos(List<String> args)

Redis command GEOPOS.

Parameters:: args -
Returns:: fluent self

rxGeopos

public io.reactivex.rxjava3.core.Maybe<Response> rxGeopos(List<String> args)

Redis command GEOPOS.

Parameters:: args -
Returns:: fluent self

georadius

public io.reactivex.rxjava3.core.Maybe<Response> georadius(List<String> args)

Redis command GEORADIUS.

Parameters:: args -
Returns:: fluent self

rxGeoradius

public io.reactivex.rxjava3.core.Maybe<Response> rxGeoradius(List<String> args)

Redis command GEORADIUS.

Parameters:: args -
Returns:: fluent self

georadiusRo

public io.reactivex.rxjava3.core.Maybe<Response> georadiusRo(List<String> args)

Redis command GEORADIUS_RO.

Parameters:: args -
Returns:: fluent self

rxGeoradiusRo

public io.reactivex.rxjava3.core.Maybe<Response> rxGeoradiusRo(List<String> args)

Redis command GEORADIUS_RO.

Parameters:: args -
Returns:: fluent self

georadiusbymember

public io.reactivex.rxjava3.core.Maybe<Response> georadiusbymember(List<String> args)

Redis command GEORADIUSBYMEMBER.

Parameters:: args -
Returns:: fluent self

rxGeoradiusbymember

public io.reactivex.rxjava3.core.Maybe<Response> rxGeoradiusbymember(List<String> args)

Redis command GEORADIUSBYMEMBER.

Parameters:: args -
Returns:: fluent self

georadiusbymemberRo

public io.reactivex.rxjava3.core.Maybe<Response> georadiusbymemberRo(List<String> args)

Redis command GEORADIUSBYMEMBER_RO.

Parameters:: args -
Returns:: fluent self

rxGeoradiusbymemberRo

public io.reactivex.rxjava3.core.Maybe<Response> rxGeoradiusbymemberRo(List<String> args)

Redis command GEORADIUSBYMEMBER_RO.

Parameters:: args -
Returns:: fluent self

geosearch

public io.reactivex.rxjava3.core.Maybe<Response> geosearch(List<String> args)

Redis command GEOSEARCH.

Parameters:: args -
Returns:: fluent self

rxGeosearch

public io.reactivex.rxjava3.core.Maybe<Response> rxGeosearch(List<String> args)

Redis command GEOSEARCH.

Parameters:: args -
Returns:: fluent self

geosearchstore

public io.reactivex.rxjava3.core.Maybe<Response> geosearchstore(List<String> args)

Redis command GEOSEARCHSTORE.

Parameters:: args -
Returns:: fluent self

rxGeosearchstore

public io.reactivex.rxjava3.core.Maybe<Response> rxGeosearchstore(List<String> args)

Redis command GEOSEARCHSTORE.

Parameters:: args -
Returns:: fluent self

get

public io.reactivex.rxjava3.core.Maybe<Response> get(String arg0)

Redis command GET.

Parameters:: arg0 -
Returns:: fluent self

rxGet

public io.reactivex.rxjava3.core.Maybe<Response> rxGet(String arg0)

Redis command GET.

Parameters:: arg0 -
Returns:: fluent self

getbit

public io.reactivex.rxjava3.core.Maybe<Response> getbit(String arg0,
                                                        String arg1)

Redis command GETBIT.

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

rxGetbit

public io.reactivex.rxjava3.core.Maybe<Response> rxGetbit(String arg0,
                                                          String arg1)

Redis command GETBIT.

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

getdel

public io.reactivex.rxjava3.core.Maybe<Response> getdel(String arg0)

Redis command GETDEL.

Parameters:: arg0 -
Returns:: fluent self

rxGetdel

public io.reactivex.rxjava3.core.Maybe<Response> rxGetdel(String arg0)

Redis command GETDEL.

Parameters:: arg0 -
Returns:: fluent self

getex

public io.reactivex.rxjava3.core.Maybe<Response> getex(List<String> args)

Redis command GETEX.

Parameters:: args -
Returns:: fluent self

rxGetex

public io.reactivex.rxjava3.core.Maybe<Response> rxGetex(List<String> args)

Redis command GETEX.

Parameters:: args -
Returns:: fluent self

getrange

public io.reactivex.rxjava3.core.Maybe<Response> getrange(String arg0,
                                                          String arg1,
                                                          String arg2)

Redis command GETRANGE.

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

rxGetrange

public io.reactivex.rxjava3.core.Maybe<Response> rxGetrange(String arg0,
                                                            String arg1,
                                                            String arg2)

Redis command GETRANGE.

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

getset

public io.reactivex.rxjava3.core.Maybe<Response> getset(String arg0,
                                                        String arg1)

Redis command GETSET.

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

rxGetset

public io.reactivex.rxjava3.core.Maybe<Response> rxGetset(String arg0,
                                                          String arg1)

Redis command GETSET.

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

graphBulk

public io.reactivex.rxjava3.core.Maybe<Response> graphBulk(List<String> args)

Redis command GRAPH.BULK.

Parameters:: args -
Returns:: fluent self

rxGraphBulk

public io.reactivex.rxjava3.core.Maybe<Response> rxGraphBulk(List<String> args)

Redis command GRAPH.BULK.

Parameters:: args -
Returns:: fluent self

graphConfig

public io.reactivex.rxjava3.core.Maybe<Response> graphConfig(List<String> args)

Redis command GRAPH.CONFIG.

Parameters:: args -
Returns:: fluent self

rxGraphConfig

public io.reactivex.rxjava3.core.Maybe<Response> rxGraphConfig(List<String> args)

Redis command GRAPH.CONFIG.

Parameters:: args -
Returns:: fluent self

graphDebug

public io.reactivex.rxjava3.core.Maybe<Response> graphDebug(List<String> args)

Redis command GRAPH.DEBUG.

Parameters:: args -
Returns:: fluent self

rxGraphDebug

public io.reactivex.rxjava3.core.Maybe<Response> rxGraphDebug(List<String> args)

Redis command GRAPH.DEBUG.

Parameters:: args -
Returns:: fluent self

graphDelete

public io.reactivex.rxjava3.core.Maybe<Response> graphDelete(List<String> args)

Redis command GRAPH.DELETE.

Parameters:: args -
Returns:: fluent self

rxGraphDelete

public io.reactivex.rxjava3.core.Maybe<Response> rxGraphDelete(List<String> args)

Redis command GRAPH.DELETE.

Parameters:: args -
Returns:: fluent self

graphExplain

public io.reactivex.rxjava3.core.Maybe<Response> graphExplain(List<String> args)

Redis command GRAPH.EXPLAIN.

Parameters:: args -
Returns:: fluent self

rxGraphExplain

public io.reactivex.rxjava3.core.Maybe<Response> rxGraphExplain(List<String> args)

Redis command GRAPH.EXPLAIN.

Parameters:: args -
Returns:: fluent self

graphList

public io.reactivex.rxjava3.core.Maybe<Response> graphList(List<String> args)

Redis command GRAPH.LIST.

Parameters:: args -
Returns:: fluent self

rxGraphList

public io.reactivex.rxjava3.core.Maybe<Response> rxGraphList(List<String> args)

Redis command GRAPH.LIST.

Parameters:: args -
Returns:: fluent self

graphProfile

public io.reactivex.rxjava3.core.Maybe<Response> graphProfile(List<String> args)

Redis command GRAPH.PROFILE.

Parameters:: args -
Returns:: fluent self

rxGraphProfile

public io.reactivex.rxjava3.core.Maybe<Response> rxGraphProfile(List<String> args)

Redis command GRAPH.PROFILE.

Parameters:: args -
Returns:: fluent self

graphQuery

public io.reactivex.rxjava3.core.Maybe<Response> graphQuery(List<String> args)

Redis command GRAPH.QUERY.

Parameters:: args -
Returns:: fluent self

rxGraphQuery

public io.reactivex.rxjava3.core.Maybe<Response> rxGraphQuery(List<String> args)

Redis command GRAPH.QUERY.

Parameters:: args -
Returns:: fluent self

graphRoQuery

public io.reactivex.rxjava3.core.Maybe<Response> graphRoQuery(List<String> args)

Redis command GRAPH.RO_QUERY.

Parameters:: args -
Returns:: fluent self

rxGraphRoQuery

public io.reactivex.rxjava3.core.Maybe<Response> rxGraphRoQuery(List<String> args)

Redis command GRAPH.RO_QUERY.

Parameters:: args -
Returns:: fluent self

graphSlowlog

public io.reactivex.rxjava3.core.Maybe<Response> graphSlowlog(List<String> args)

Redis command GRAPH.SLOWLOG.

Parameters:: args -
Returns:: fluent self

rxGraphSlowlog

public io.reactivex.rxjava3.core.Maybe<Response> rxGraphSlowlog(List<String> args)

Redis command GRAPH.SLOWLOG.

Parameters:: args -
Returns:: fluent self

hdel

public io.reactivex.rxjava3.core.Maybe<Response> hdel(List<String> args)

Redis command HDEL.

Parameters:: args -
Returns:: fluent self

rxHdel

public io.reactivex.rxjava3.core.Maybe<Response> rxHdel(List<String> args)

Redis command HDEL.

Parameters:: args -
Returns:: fluent self

hello

public io.reactivex.rxjava3.core.Maybe<Response> hello(List<String> args)

Redis command HELLO.

Parameters:: args -
Returns:: fluent self

rxHello

public io.reactivex.rxjava3.core.Maybe<Response> rxHello(List<String> args)

Redis command HELLO.

Parameters:: args -
Returns:: fluent self

hexists

public io.reactivex.rxjava3.core.Maybe<Response> hexists(String arg0,
                                                         String arg1)

Redis command HEXISTS.

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

rxHexists

public io.reactivex.rxjava3.core.Maybe<Response> rxHexists(String arg0,
                                                           String arg1)

Redis command HEXISTS.

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

hget

public io.reactivex.rxjava3.core.Maybe<Response> hget(String arg0,
                                                      String arg1)

Redis command HGET.

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

rxHget

public io.reactivex.rxjava3.core.Maybe<Response> rxHget(String arg0,
                                                        String arg1)

Redis command HGET.

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

hgetall

public io.reactivex.rxjava3.core.Maybe<Response> hgetall(String arg0)

Redis command HGETALL.

Parameters:: arg0 -
Returns:: fluent self

rxHgetall

public io.reactivex.rxjava3.core.Maybe<Response> rxHgetall(String arg0)

Redis command HGETALL.

Parameters:: arg0 -
Returns:: fluent self

hincrby

public io.reactivex.rxjava3.core.Maybe<Response> hincrby(String arg0,
                                                         String arg1,
                                                         String arg2)

Redis command HINCRBY.

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

rxHincrby

public io.reactivex.rxjava3.core.Maybe<Response> rxHincrby(String arg0,
                                                           String arg1,
                                                           String arg2)

Redis command HINCRBY.

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

hincrbyfloat

public io.reactivex.rxjava3.core.Maybe<Response> hincrbyfloat(String arg0,
                                                              String arg1,
                                                              String arg2)

Redis command HINCRBYFLOAT.

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

rxHincrbyfloat

public io.reactivex.rxjava3.core.Maybe<Response> rxHincrbyfloat(String arg0,
                                                                String arg1,
                                                                String arg2)

Redis command HINCRBYFLOAT.

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

hkeys

public io.reactivex.rxjava3.core.Maybe<Response> hkeys(String arg0)

Redis command HKEYS.

Parameters:: arg0 -
Returns:: fluent self

rxHkeys

public io.reactivex.rxjava3.core.Maybe<Response> rxHkeys(String arg0)

Redis command HKEYS.

Parameters:: arg0 -
Returns:: fluent self

hlen

public io.reactivex.rxjava3.core.Maybe<Response> hlen(String arg0)

Redis command HLEN.

Parameters:: arg0 -
Returns:: fluent self

rxHlen

public io.reactivex.rxjava3.core.Maybe<Response> rxHlen(String arg0)

Redis command HLEN.

Parameters:: arg0 -
Returns:: fluent self

hmget

public io.reactivex.rxjava3.core.Maybe<Response> hmget(List<String> args)

Redis command HMGET.

Parameters:: args -
Returns:: fluent self

rxHmget

public io.reactivex.rxjava3.core.Maybe<Response> rxHmget(List<String> args)

Redis command HMGET.

Parameters:: args -
Returns:: fluent self

hmset

public io.reactivex.rxjava3.core.Maybe<Response> hmset(List<String> args)

Redis command HMSET.

Parameters:: args -
Returns:: fluent self

rxHmset

public io.reactivex.rxjava3.core.Maybe<Response> rxHmset(List<String> args)

Redis command HMSET.

Parameters:: args -
Returns:: fluent self

hrandfield

public io.reactivex.rxjava3.core.Maybe<Response> hrandfield(List<String> args)

Redis command HRANDFIELD.

Parameters:: args -
Returns:: fluent self

rxHrandfield

public io.reactivex.rxjava3.core.Maybe<Response> rxHrandfield(List<String> args)

Redis command HRANDFIELD.

Parameters:: args -
Returns:: fluent self

hscan

public io.reactivex.rxjava3.core.Maybe<Response> hscan(List<String> args)

Redis command HSCAN.

Parameters:: args -
Returns:: fluent self

rxHscan

public io.reactivex.rxjava3.core.Maybe<Response> rxHscan(List<String> args)

Redis command HSCAN.

Parameters:: args -
Returns:: fluent self

hset

public io.reactivex.rxjava3.core.Maybe<Response> hset(List<String> args)

Redis command HSET.

Parameters:: args -
Returns:: fluent self

rxHset

public io.reactivex.rxjava3.core.Maybe<Response> rxHset(List<String> args)

Redis command HSET.

Parameters:: args -
Returns:: fluent self

hsetnx

public io.reactivex.rxjava3.core.Maybe<Response> hsetnx(String arg0,
                                                        String arg1,
                                                        String arg2)

Redis command HSETNX.

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

rxHsetnx

public io.reactivex.rxjava3.core.Maybe<Response> rxHsetnx(String arg0,
                                                          String arg1,
                                                          String arg2)

Redis command HSETNX.

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

hstrlen

public io.reactivex.rxjava3.core.Maybe<Response> hstrlen(String arg0,
                                                         String arg1)

Redis command HSTRLEN.

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

rxHstrlen

public io.reactivex.rxjava3.core.Maybe<Response> rxHstrlen(String arg0,
                                                           String arg1)

Redis command HSTRLEN.

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

hvals

public io.reactivex.rxjava3.core.Maybe<Response> hvals(String arg0)

Redis command HVALS.

Parameters:: arg0 -
Returns:: fluent self

rxHvals

public io.reactivex.rxjava3.core.Maybe<Response> rxHvals(String arg0)

Redis command HVALS.

Parameters:: arg0 -
Returns:: fluent self

incr

public io.reactivex.rxjava3.core.Maybe<Response> incr(String arg0)

Redis command INCR.

Parameters:: arg0 -
Returns:: fluent self

rxIncr

public io.reactivex.rxjava3.core.Maybe<Response> rxIncr(String arg0)

Redis command INCR.

Parameters:: arg0 -
Returns:: fluent self

incrby

public io.reactivex.rxjava3.core.Maybe<Response> incrby(String arg0,
                                                        String arg1)

Redis command INCRBY.

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

rxIncrby

public io.reactivex.rxjava3.core.Maybe<Response> rxIncrby(String arg0,
                                                          String arg1)

Redis command INCRBY.

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

incrbyfloat

public io.reactivex.rxjava3.core.Maybe<Response> incrbyfloat(String arg0,
                                                             String arg1)

Redis command INCRBYFLOAT.

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

rxIncrbyfloat

public io.reactivex.rxjava3.core.Maybe<Response> rxIncrbyfloat(String arg0,
                                                               String arg1)

Redis command INCRBYFLOAT.

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

info

public io.reactivex.rxjava3.core.Maybe<Response> info(List<String> args)

Redis command INFO.

Parameters:: args -
Returns:: fluent self

rxInfo

public io.reactivex.rxjava3.core.Maybe<Response> rxInfo(List<String> args)

Redis command INFO.

Parameters:: args -
Returns:: fluent self

jsonArrappend

public io.reactivex.rxjava3.core.Maybe<Response> jsonArrappend(List<String> args)

Redis command JSON.ARRAPPEND.

Parameters:: args -
Returns:: fluent self

rxJsonArrappend

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonArrappend(List<String> args)

Redis command JSON.ARRAPPEND.

Parameters:: args -
Returns:: fluent self

jsonArrindex

public io.reactivex.rxjava3.core.Maybe<Response> jsonArrindex(List<String> args)

Redis command JSON.ARRINDEX.

Parameters:: args -
Returns:: fluent self

rxJsonArrindex

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonArrindex(List<String> args)

Redis command JSON.ARRINDEX.

Parameters:: args -
Returns:: fluent self

jsonArrinsert

public io.reactivex.rxjava3.core.Maybe<Response> jsonArrinsert(List<String> args)

Redis command JSON.ARRINSERT.

Parameters:: args -
Returns:: fluent self

rxJsonArrinsert

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonArrinsert(List<String> args)

Redis command JSON.ARRINSERT.

Parameters:: args -
Returns:: fluent self

jsonArrlen

public io.reactivex.rxjava3.core.Maybe<Response> jsonArrlen(List<String> args)

Redis command JSON.ARRLEN.

Parameters:: args -
Returns:: fluent self

rxJsonArrlen

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonArrlen(List<String> args)

Redis command JSON.ARRLEN.

Parameters:: args -
Returns:: fluent self

jsonArrpop

public io.reactivex.rxjava3.core.Maybe<Response> jsonArrpop(List<String> args)

Redis command JSON.ARRPOP.

Parameters:: args -
Returns:: fluent self

rxJsonArrpop

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonArrpop(List<String> args)

Redis command JSON.ARRPOP.

Parameters:: args -
Returns:: fluent self

jsonArrtrim

public io.reactivex.rxjava3.core.Maybe<Response> jsonArrtrim(List<String> args)

Redis command JSON.ARRTRIM.

Parameters:: args -
Returns:: fluent self

rxJsonArrtrim

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonArrtrim(List<String> args)

Redis command JSON.ARRTRIM.

Parameters:: args -
Returns:: fluent self

jsonClear

public io.reactivex.rxjava3.core.Maybe<Response> jsonClear(List<String> args)

Redis command JSON.CLEAR.

Parameters:: args -
Returns:: fluent self

rxJsonClear

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonClear(List<String> args)

Redis command JSON.CLEAR.

Parameters:: args -
Returns:: fluent self

jsonDebug

public io.reactivex.rxjava3.core.Maybe<Response> jsonDebug(List<String> args)

Redis command JSON.DEBUG.

Parameters:: args -
Returns:: fluent self

rxJsonDebug

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonDebug(List<String> args)

Redis command JSON.DEBUG.

Parameters:: args -
Returns:: fluent self

jsonDel

public io.reactivex.rxjava3.core.Maybe<Response> jsonDel(List<String> args)

Redis command JSON.DEL.

Parameters:: args -
Returns:: fluent self

rxJsonDel

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonDel(List<String> args)

Redis command JSON.DEL.

Parameters:: args -
Returns:: fluent self

jsonForget

public io.reactivex.rxjava3.core.Maybe<Response> jsonForget(List<String> args)

Redis command JSON.FORGET.

Parameters:: args -
Returns:: fluent self

rxJsonForget

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonForget(List<String> args)

Redis command JSON.FORGET.

Parameters:: args -
Returns:: fluent self

jsonGet

public io.reactivex.rxjava3.core.Maybe<Response> jsonGet(List<String> args)

Redis command JSON.GET.

Parameters:: args -
Returns:: fluent self

rxJsonGet

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonGet(List<String> args)

Redis command JSON.GET.

Parameters:: args -
Returns:: fluent self

jsonMget

public io.reactivex.rxjava3.core.Maybe<Response> jsonMget(List<String> args)

Redis command JSON.MGET.

Parameters:: args -
Returns:: fluent self

rxJsonMget

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonMget(List<String> args)

Redis command JSON.MGET.

Parameters:: args -
Returns:: fluent self

jsonNumincrby

public io.reactivex.rxjava3.core.Maybe<Response> jsonNumincrby(List<String> args)

Redis command JSON.NUMINCRBY.

Parameters:: args -
Returns:: fluent self

rxJsonNumincrby

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonNumincrby(List<String> args)

Redis command JSON.NUMINCRBY.

Parameters:: args -
Returns:: fluent self

jsonNummultby

public io.reactivex.rxjava3.core.Maybe<Response> jsonNummultby(List<String> args)

Redis command JSON.NUMMULTBY.

Parameters:: args -
Returns:: fluent self

rxJsonNummultby

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonNummultby(List<String> args)

Redis command JSON.NUMMULTBY.

Parameters:: args -
Returns:: fluent self

jsonNumpowby

public io.reactivex.rxjava3.core.Maybe<Response> jsonNumpowby(List<String> args)

Redis command JSON.NUMPOWBY.

Parameters:: args -
Returns:: fluent self

rxJsonNumpowby

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonNumpowby(List<String> args)

Redis command JSON.NUMPOWBY.

Parameters:: args -
Returns:: fluent self

jsonObjkeys

public io.reactivex.rxjava3.core.Maybe<Response> jsonObjkeys(List<String> args)

Redis command JSON.OBJKEYS.

Parameters:: args -
Returns:: fluent self

rxJsonObjkeys

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonObjkeys(List<String> args)

Redis command JSON.OBJKEYS.

Parameters:: args -
Returns:: fluent self

jsonObjlen

public io.reactivex.rxjava3.core.Maybe<Response> jsonObjlen(List<String> args)

Redis command JSON.OBJLEN.

Parameters:: args -
Returns:: fluent self

rxJsonObjlen

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonObjlen(List<String> args)

Redis command JSON.OBJLEN.

Parameters:: args -
Returns:: fluent self

jsonResp

public io.reactivex.rxjava3.core.Maybe<Response> jsonResp(List<String> args)

Redis command JSON.RESP.

Parameters:: args -
Returns:: fluent self

rxJsonResp

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonResp(List<String> args)

Redis command JSON.RESP.

Parameters:: args -
Returns:: fluent self

jsonSet

public io.reactivex.rxjava3.core.Maybe<Response> jsonSet(List<String> args)

Redis command JSON.SET.

Parameters:: args -
Returns:: fluent self

rxJsonSet

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonSet(List<String> args)

Redis command JSON.SET.

Parameters:: args -
Returns:: fluent self

jsonStrappend

public io.reactivex.rxjava3.core.Maybe<Response> jsonStrappend(List<String> args)

Redis command JSON.STRAPPEND.

Parameters:: args -
Returns:: fluent self

rxJsonStrappend

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonStrappend(List<String> args)

Redis command JSON.STRAPPEND.

Parameters:: args -
Returns:: fluent self

jsonStrlen

public io.reactivex.rxjava3.core.Maybe<Response> jsonStrlen(List<String> args)

Redis command JSON.STRLEN.

Parameters:: args -
Returns:: fluent self

rxJsonStrlen

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonStrlen(List<String> args)

Redis command JSON.STRLEN.

Parameters:: args -
Returns:: fluent self

jsonToggle

public io.reactivex.rxjava3.core.Maybe<Response> jsonToggle(List<String> args)

Redis command JSON.TOGGLE.

Parameters:: args -
Returns:: fluent self

rxJsonToggle

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonToggle(List<String> args)

Redis command JSON.TOGGLE.

Parameters:: args -
Returns:: fluent self

jsonType

public io.reactivex.rxjava3.core.Maybe<Response> jsonType(List<String> args)

Redis command JSON.TYPE.

Parameters:: args -
Returns:: fluent self

rxJsonType

public io.reactivex.rxjava3.core.Maybe<Response> rxJsonType(List<String> args)

Redis command JSON.TYPE.

Parameters:: args -
Returns:: fluent self

keys

public io.reactivex.rxjava3.core.Maybe<Response> keys(String arg0)

Redis command KEYS.

Parameters:: arg0 -
Returns:: fluent self

rxKeys

public io.reactivex.rxjava3.core.Maybe<Response> rxKeys(String arg0)

Redis command KEYS.

Parameters:: arg0 -
Returns:: fluent self

lastsave

public io.reactivex.rxjava3.core.Maybe<Response> lastsave()

Redis command LASTSAVE.

Returns:: fluent self

rxLastsave

public io.reactivex.rxjava3.core.Maybe<Response> rxLastsave()

Redis command LASTSAVE.

Returns:: fluent self

latency

public io.reactivex.rxjava3.core.Maybe<Response> latency(List<String> args)

Redis command LATENCY.

Parameters:: args -
Returns:: fluent self

rxLatency

public io.reactivex.rxjava3.core.Maybe<Response> rxLatency(List<String> args)

Redis command LATENCY.

Parameters:: args -
Returns:: fluent self

lcs

public io.reactivex.rxjava3.core.Maybe<Response> lcs(List<String> args)

Redis command LCS.

Parameters:: args -
Returns:: fluent self

rxLcs

public io.reactivex.rxjava3.core.Maybe<Response> rxLcs(List<String> args)

Redis command LCS.

Parameters:: args -
Returns:: fluent self

lindex

public io.reactivex.rxjava3.core.Maybe<Response> lindex(String arg0,
                                                        String arg1)

Redis command LINDEX.

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

rxLindex

public io.reactivex.rxjava3.core.Maybe<Response> rxLindex(String arg0,
                                                          String arg1)

Redis command LINDEX.

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

linsert

public io.reactivex.rxjava3.core.Maybe<Response> linsert(String arg0,
                                                         String arg1,
                                                         String arg2,
                                                         String arg3)

Redis command LINSERT.

Parameters:: arg0 -; arg1 -; arg2 -; arg3 -
Returns:: fluent self

rxLinsert

public io.reactivex.rxjava3.core.Maybe<Response> rxLinsert(String arg0,
                                                           String arg1,
                                                           String arg2,
                                                           String arg3)

Redis command LINSERT.

Parameters:: arg0 -; arg1 -; arg2 -; arg3 -
Returns:: fluent self

llen

public io.reactivex.rxjava3.core.Maybe<Response> llen(String arg0)

Redis command LLEN.

Parameters:: arg0 -
Returns:: fluent self

rxLlen

public io.reactivex.rxjava3.core.Maybe<Response> rxLlen(String arg0)

Redis command LLEN.

Parameters:: arg0 -
Returns:: fluent self

lmove

public io.reactivex.rxjava3.core.Maybe<Response> lmove(String arg0,
                                                       String arg1,
                                                       String arg2,
                                                       String arg3)

Redis command LMOVE.

Parameters:: arg0 -; arg1 -; arg2 -; arg3 -
Returns:: fluent self

rxLmove

public io.reactivex.rxjava3.core.Maybe<Response> rxLmove(String arg0,
                                                         String arg1,
                                                         String arg2,
                                                         String arg3)

Redis command LMOVE.

Parameters:: arg0 -; arg1 -; arg2 -; arg3 -
Returns:: fluent self

lmpop

public io.reactivex.rxjava3.core.Maybe<Response> lmpop(List<String> args)

Redis command LMPOP.

Parameters:: args -
Returns:: fluent self

rxLmpop

public io.reactivex.rxjava3.core.Maybe<Response> rxLmpop(List<String> args)

Redis command LMPOP.

Parameters:: args -
Returns:: fluent self

lolwut

public io.reactivex.rxjava3.core.Maybe<Response> lolwut(List<String> args)

Redis command LOLWUT.

Parameters:: args -
Returns:: fluent self

rxLolwut

public io.reactivex.rxjava3.core.Maybe<Response> rxLolwut(List<String> args)

Redis command LOLWUT.

Parameters:: args -
Returns:: fluent self

lpop

public io.reactivex.rxjava3.core.Maybe<Response> lpop(List<String> args)

Redis command LPOP.

Parameters:: args -
Returns:: fluent self

rxLpop

public io.reactivex.rxjava3.core.Maybe<Response> rxLpop(List<String> args)

Redis command LPOP.

Parameters:: args -
Returns:: fluent self

lpos

public io.reactivex.rxjava3.core.Maybe<Response> lpos(List<String> args)

Redis command LPOS.

Parameters:: args -
Returns:: fluent self

rxLpos

public io.reactivex.rxjava3.core.Maybe<Response> rxLpos(List<String> args)

Redis command LPOS.

Parameters:: args -
Returns:: fluent self

lpush

public io.reactivex.rxjava3.core.Maybe<Response> lpush(List<String> args)

Redis command LPUSH.

Parameters:: args -
Returns:: fluent self

rxLpush

public io.reactivex.rxjava3.core.Maybe<Response> rxLpush(List<String> args)

Redis command LPUSH.

Parameters:: args -
Returns:: fluent self

lpushx

public io.reactivex.rxjava3.core.Maybe<Response> lpushx(List<String> args)

Redis command LPUSHX.

Parameters:: args -
Returns:: fluent self

rxLpushx

public io.reactivex.rxjava3.core.Maybe<Response> rxLpushx(List<String> args)

Redis command LPUSHX.

Parameters:: args -
Returns:: fluent self

lrange

public io.reactivex.rxjava3.core.Maybe<Response> lrange(String arg0,
                                                        String arg1,
                                                        String arg2)

Redis command LRANGE.

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

rxLrange

public io.reactivex.rxjava3.core.Maybe<Response> rxLrange(String arg0,
                                                          String arg1,
                                                          String arg2)

Redis command LRANGE.

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

lrem

public io.reactivex.rxjava3.core.Maybe<Response> lrem(String arg0,
                                                      String arg1,
                                                      String arg2)

Redis command LREM.

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

rxLrem

public io.reactivex.rxjava3.core.Maybe<Response> rxLrem(String arg0,
                                                        String arg1,
                                                        String arg2)

Redis command LREM.

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

lset

public io.reactivex.rxjava3.core.Maybe<Response> lset(String arg0,
                                                      String arg1,
                                                      String arg2)

Redis command LSET.

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

rxLset

public io.reactivex.rxjava3.core.Maybe<Response> rxLset(String arg0,
                                                        String arg1,
                                                        String arg2)

Redis command LSET.

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

ltrim

public io.reactivex.rxjava3.core.Maybe<Response> ltrim(String arg0,
                                                       String arg1,
                                                       String arg2)

Redis command LTRIM.

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

rxLtrim

public io.reactivex.rxjava3.core.Maybe<Response> rxLtrim(String arg0,
                                                         String arg1,
                                                         String arg2)

Redis command LTRIM.

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

memory

public io.reactivex.rxjava3.core.Maybe<Response> memory(List<String> args)

Redis command MEMORY.

Parameters:: args -
Returns:: fluent self

rxMemory

public io.reactivex.rxjava3.core.Maybe<Response> rxMemory(List<String> args)

Redis command MEMORY.

Parameters:: args -
Returns:: fluent self

mget

public io.reactivex.rxjava3.core.Maybe<Response> mget(List<String> args)

Redis command MGET.

Parameters:: args -
Returns:: fluent self

rxMget

public io.reactivex.rxjava3.core.Maybe<Response> rxMget(List<String> args)

Redis command MGET.

Parameters:: args -
Returns:: fluent self

migrate

public io.reactivex.rxjava3.core.Maybe<Response> migrate(List<String> args)

Redis command MIGRATE.

Parameters:: args -
Returns:: fluent self

rxMigrate

public io.reactivex.rxjava3.core.Maybe<Response> rxMigrate(List<String> args)

Redis command MIGRATE.

Parameters:: args -
Returns:: fluent self

module

public io.reactivex.rxjava3.core.Maybe<Response> module(List<String> args)

Redis command MODULE.

Parameters:: args -
Returns:: fluent self

rxModule

public io.reactivex.rxjava3.core.Maybe<Response> rxModule(List<String> args)

Redis command MODULE.

Parameters:: args -
Returns:: fluent self

monitor

public io.reactivex.rxjava3.core.Maybe<Response> monitor()

Redis command MONITOR.

Returns:: fluent self

rxMonitor

public io.reactivex.rxjava3.core.Maybe<Response> rxMonitor()

Redis command MONITOR.

Returns:: fluent self

move

public io.reactivex.rxjava3.core.Maybe<Response> move(String arg0,
                                                      String arg1)

Redis command MOVE.

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

rxMove

public io.reactivex.rxjava3.core.Maybe<Response> rxMove(String arg0,
                                                        String arg1)

Redis command MOVE.

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

mset

public io.reactivex.rxjava3.core.Maybe<Response> mset(List<String> args)

Redis command MSET.

Parameters:: args -
Returns:: fluent self

rxMset

public io.reactivex.rxjava3.core.Maybe<Response> rxMset(List<String> args)

Redis command MSET.

Parameters:: args -
Returns:: fluent self

msetnx

public io.reactivex.rxjava3.core.Maybe<Response> msetnx(List<String> args)

Redis command MSETNX.

Parameters:: args -
Returns:: fluent self

rxMsetnx

public io.reactivex.rxjava3.core.Maybe<Response> rxMsetnx(List<String> args)

Redis command MSETNX.

Parameters:: args -
Returns:: fluent self

multi

public io.reactivex.rxjava3.core.Maybe<Response> multi()

Redis command MULTI.

Returns:: fluent self

rxMulti

public io.reactivex.rxjava3.core.Maybe<Response> rxMulti()

Redis command MULTI.

Returns:: fluent self

object

public io.reactivex.rxjava3.core.Maybe<Response> object(List<String> args)

Redis command OBJECT.

Parameters:: args -
Returns:: fluent self

rxObject

public io.reactivex.rxjava3.core.Maybe<Response> rxObject(List<String> args)

Redis command OBJECT.

Parameters:: args -
Returns:: fluent self

persist

public io.reactivex.rxjava3.core.Maybe<Response> persist(String arg0)

Redis command PERSIST.

Parameters:: arg0 -
Returns:: fluent self

rxPersist

public io.reactivex.rxjava3.core.Maybe<Response> rxPersist(String arg0)

Redis command PERSIST.

Parameters:: arg0 -
Returns:: fluent self

pexpire

public io.reactivex.rxjava3.core.Maybe<Response> pexpire(List<String> args)

Redis command PEXPIRE.

Parameters:: args -
Returns:: fluent self

rxPexpire

public io.reactivex.rxjava3.core.Maybe<Response> rxPexpire(List<String> args)

Redis command PEXPIRE.

Parameters:: args -
Returns:: fluent self

pexpireat

public io.reactivex.rxjava3.core.Maybe<Response> pexpireat(List<String> args)

Redis command PEXPIREAT.

Parameters:: args -
Returns:: fluent self

rxPexpireat

public io.reactivex.rxjava3.core.Maybe<Response> rxPexpireat(List<String> args)

Redis command PEXPIREAT.

Parameters:: args -
Returns:: fluent self

pexpiretime

public io.reactivex.rxjava3.core.Maybe<Response> pexpiretime(String arg0)

Redis command PEXPIRETIME.

Parameters:: arg0 -
Returns:: fluent self

rxPexpiretime

public io.reactivex.rxjava3.core.Maybe<Response> rxPexpiretime(String arg0)

Redis command PEXPIRETIME.

Parameters:: arg0 -
Returns:: fluent self

pfadd

public io.reactivex.rxjava3.core.Maybe<Response> pfadd(List<String> args)

Redis command PFADD.

Parameters:: args -
Returns:: fluent self

rxPfadd

public io.reactivex.rxjava3.core.Maybe<Response> rxPfadd(List<String> args)

Redis command PFADD.

Parameters:: args -
Returns:: fluent self

pfcount

public io.reactivex.rxjava3.core.Maybe<Response> pfcount(List<String> args)

Redis command PFCOUNT.

Parameters:: args -
Returns:: fluent self

rxPfcount

public io.reactivex.rxjava3.core.Maybe<Response> rxPfcount(List<String> args)

Redis command PFCOUNT.

Parameters:: args -
Returns:: fluent self

pfdebug

public io.reactivex.rxjava3.core.Maybe<Response> pfdebug(String arg0,
                                                         String arg1)

Redis command PFDEBUG.

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

rxPfdebug

public io.reactivex.rxjava3.core.Maybe<Response> rxPfdebug(String arg0,
                                                           String arg1)

Redis command PFDEBUG.

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

pfmerge

public io.reactivex.rxjava3.core.Maybe<Response> pfmerge(List<String> args)

Redis command PFMERGE.

Parameters:: args -
Returns:: fluent self

rxPfmerge

public io.reactivex.rxjava3.core.Maybe<Response> rxPfmerge(List<String> args)

Redis command PFMERGE.

Parameters:: args -
Returns:: fluent self

pfselftest

public io.reactivex.rxjava3.core.Maybe<Response> pfselftest()

Redis command PFSELFTEST.

Returns:: fluent self

rxPfselftest

public io.reactivex.rxjava3.core.Maybe<Response> rxPfselftest()

Redis command PFSELFTEST.

Returns:: fluent self

ping

public io.reactivex.rxjava3.core.Maybe<Response> ping(List<String> args)

Redis command PING.

Parameters:: args -
Returns:: fluent self

rxPing

public io.reactivex.rxjava3.core.Maybe<Response> rxPing(List<String> args)

Redis command PING.

Parameters:: args -
Returns:: fluent self

psetex

public io.reactivex.rxjava3.core.Maybe<Response> psetex(String arg0,
                                                        String arg1,
                                                        String arg2)

Redis command PSETEX.

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

rxPsetex

public io.reactivex.rxjava3.core.Maybe<Response> rxPsetex(String arg0,
                                                          String arg1,
                                                          String arg2)

Redis command PSETEX.

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

psubscribe

public io.reactivex.rxjava3.core.Maybe<Response> psubscribe(List<String> args)

Redis command PSUBSCRIBE.

Parameters:: args -
Returns:: fluent self

rxPsubscribe

public io.reactivex.rxjava3.core.Maybe<Response> rxPsubscribe(List<String> args)

Redis command PSUBSCRIBE.

Parameters:: args -
Returns:: fluent self

psync

public io.reactivex.rxjava3.core.Maybe<Response> psync(List<String> args)

Redis command PSYNC.

Parameters:: args -
Returns:: fluent self

rxPsync

public io.reactivex.rxjava3.core.Maybe<Response> rxPsync(List<String> args)

Redis command PSYNC.

Parameters:: args -
Returns:: fluent self

pttl

public io.reactivex.rxjava3.core.Maybe<Response> pttl(String arg0)

Redis command PTTL.

Parameters:: arg0 -
Returns:: fluent self

rxPttl

public io.reactivex.rxjava3.core.Maybe<Response> rxPttl(String arg0)

Redis command PTTL.

Parameters:: arg0 -
Returns:: fluent self

publish

public io.reactivex.rxjava3.core.Maybe<Response> publish(String arg0,
                                                         String arg1)

Redis command PUBLISH.

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

rxPublish

public io.reactivex.rxjava3.core.Maybe<Response> rxPublish(String arg0,
                                                           String arg1)

Redis command PUBLISH.

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

pubsub

public io.reactivex.rxjava3.core.Maybe<Response> pubsub(List<String> args)

Redis command PUBSUB.

Parameters:: args -
Returns:: fluent self

rxPubsub

public io.reactivex.rxjava3.core.Maybe<Response> rxPubsub(List<String> args)

Redis command PUBSUB.

Parameters:: args -
Returns:: fluent self

punsubscribe

public io.reactivex.rxjava3.core.Maybe<Response> punsubscribe(List<String> args)

Redis command PUNSUBSCRIBE.

Parameters:: args -
Returns:: fluent self

rxPunsubscribe

public io.reactivex.rxjava3.core.Maybe<Response> rxPunsubscribe(List<String> args)

Redis command PUNSUBSCRIBE.

Parameters:: args -
Returns:: fluent self

quit

public io.reactivex.rxjava3.core.Maybe<Response> quit(List<String> args)

Redis command QUIT.

Parameters:: args -
Returns:: fluent self

rxQuit

public io.reactivex.rxjava3.core.Maybe<Response> rxQuit(List<String> args)

Redis command QUIT.

Parameters:: args -
Returns:: fluent self

randomkey

public io.reactivex.rxjava3.core.Maybe<Response> randomkey()

Redis command RANDOMKEY.

Returns:: fluent self

rxRandomkey

public io.reactivex.rxjava3.core.Maybe<Response> rxRandomkey()

Redis command RANDOMKEY.

Returns:: fluent self

readonly

public io.reactivex.rxjava3.core.Maybe<Response> readonly()

Redis command READONLY.

Returns:: fluent self

rxReadonly

public io.reactivex.rxjava3.core.Maybe<Response> rxReadonly()

Redis command READONLY.

Returns:: fluent self

readwrite

public io.reactivex.rxjava3.core.Maybe<Response> readwrite()

Redis command READWRITE.

Returns:: fluent self

rxReadwrite

public io.reactivex.rxjava3.core.Maybe<Response> rxReadwrite()

Redis command READWRITE.

Returns:: fluent self

rename

public io.reactivex.rxjava3.core.Maybe<Response> rename(String arg0,
                                                        String arg1)

Redis command RENAME.

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

rxRename

public io.reactivex.rxjava3.core.Maybe<Response> rxRename(String arg0,
                                                          String arg1)

Redis command RENAME.

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

renamenx

public io.reactivex.rxjava3.core.Maybe<Response> renamenx(String arg0,
                                                          String arg1)

Redis command RENAMENX.

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

rxRenamenx

public io.reactivex.rxjava3.core.Maybe<Response> rxRenamenx(String arg0,
                                                            String arg1)

Redis command RENAMENX.

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

replconf

public io.reactivex.rxjava3.core.Maybe<Response> replconf(List<String> args)

Redis command REPLCONF.

Parameters:: args -
Returns:: fluent self

rxReplconf

public io.reactivex.rxjava3.core.Maybe<Response> rxReplconf(List<String> args)

Redis command REPLCONF.

Parameters:: args -
Returns:: fluent self

replicaof

public io.reactivex.rxjava3.core.Maybe<Response> replicaof(String arg0,
                                                           String arg1)

Redis command REPLICAOF.

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

rxReplicaof

public io.reactivex.rxjava3.core.Maybe<Response> rxReplicaof(String arg0,
                                                             String arg1)

Redis command REPLICAOF.

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

reset

public io.reactivex.rxjava3.core.Maybe<Response> reset()

Redis command RESET.

Returns:: fluent self

rxReset

public io.reactivex.rxjava3.core.Maybe<Response> rxReset()

Redis command RESET.

Returns:: fluent self

restore

public io.reactivex.rxjava3.core.Maybe<Response> restore(List<String> args)

Redis command RESTORE.

Parameters:: args -
Returns:: fluent self

rxRestore

public io.reactivex.rxjava3.core.Maybe<Response> rxRestore(List<String> args)

Redis command RESTORE.

Parameters:: args -
Returns:: fluent self

restoreAsking

public io.reactivex.rxjava3.core.Maybe<Response> restoreAsking(List<String> args)

Redis command RESTORE-ASKING.

Parameters:: args -
Returns:: fluent self

rxRestoreAsking

public io.reactivex.rxjava3.core.Maybe<Response> rxRestoreAsking(List<String> args)

Redis command RESTORE-ASKING.

Parameters:: args -
Returns:: fluent self

role

public io.reactivex.rxjava3.core.Maybe<Response> role()

Redis command ROLE.

Returns:: fluent self

rxRole

public io.reactivex.rxjava3.core.Maybe<Response> rxRole()

Redis command ROLE.

Returns:: fluent self

rpop

public io.reactivex.rxjava3.core.Maybe<Response> rpop(List<String> args)

Redis command RPOP.

Parameters:: args -
Returns:: fluent self

rxRpop

public io.reactivex.rxjava3.core.Maybe<Response> rxRpop(List<String> args)

Redis command RPOP.

Parameters:: args -
Returns:: fluent self

rpoplpush

public io.reactivex.rxjava3.core.Maybe<Response> rpoplpush(String arg0,
                                                           String arg1)

Redis command RPOPLPUSH.

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

rxRpoplpush

public io.reactivex.rxjava3.core.Maybe<Response> rxRpoplpush(String arg0,
                                                             String arg1)

Redis command RPOPLPUSH.

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

rpush

public io.reactivex.rxjava3.core.Maybe<Response> rpush(List<String> args)

Redis command RPUSH.

Parameters:: args -
Returns:: fluent self

rxRpush

public io.reactivex.rxjava3.core.Maybe<Response> rxRpush(List<String> args)

Redis command RPUSH.

Parameters:: args -
Returns:: fluent self

rpushx

public io.reactivex.rxjava3.core.Maybe<Response> rpushx(List<String> args)

Redis command RPUSHX.

Parameters:: args -
Returns:: fluent self

rxRpushx

public io.reactivex.rxjava3.core.Maybe<Response> rxRpushx(List<String> args)

Redis command RPUSHX.

Parameters:: args -
Returns:: fluent self

sadd

public io.reactivex.rxjava3.core.Maybe<Response> sadd(List<String> args)

Redis command SADD.

Parameters:: args -
Returns:: fluent self

rxSadd

public io.reactivex.rxjava3.core.Maybe<Response> rxSadd(List<String> args)

Redis command SADD.

Parameters:: args -
Returns:: fluent self

save

public io.reactivex.rxjava3.core.Maybe<Response> save()

Redis command SAVE.

Returns:: fluent self

rxSave

public io.reactivex.rxjava3.core.Maybe<Response> rxSave()

Redis command SAVE.

Returns:: fluent self

scan

public io.reactivex.rxjava3.core.Maybe<Response> scan(List<String> args)

Redis command SCAN.

Parameters:: args -
Returns:: fluent self

rxScan

public io.reactivex.rxjava3.core.Maybe<Response> rxScan(List<String> args)

Redis command SCAN.

Parameters:: args -
Returns:: fluent self

scard

public io.reactivex.rxjava3.core.Maybe<Response> scard(String arg0)

Redis command SCARD.

Parameters:: arg0 -
Returns:: fluent self

rxScard

public io.reactivex.rxjava3.core.Maybe<Response> rxScard(String arg0)

Redis command SCARD.

Parameters:: arg0 -
Returns:: fluent self

script

public io.reactivex.rxjava3.core.Maybe<Response> script(List<String> args)

Redis command SCRIPT.

Parameters:: args -
Returns:: fluent self

rxScript

public io.reactivex.rxjava3.core.Maybe<Response> rxScript(List<String> args)

Redis command SCRIPT.

Parameters:: args -
Returns:: fluent self

sdiff

public io.reactivex.rxjava3.core.Maybe<Response> sdiff(List<String> args)

Redis command SDIFF.

Parameters:: args -
Returns:: fluent self

rxSdiff

public io.reactivex.rxjava3.core.Maybe<Response> rxSdiff(List<String> args)

Redis command SDIFF.

Parameters:: args -
Returns:: fluent self

sdiffstore

public io.reactivex.rxjava3.core.Maybe<Response> sdiffstore(List<String> args)

Redis command SDIFFSTORE.

Parameters:: args -
Returns:: fluent self

rxSdiffstore

public io.reactivex.rxjava3.core.Maybe<Response> rxSdiffstore(List<String> args)

Redis command SDIFFSTORE.

Parameters:: args -
Returns:: fluent self

select

public io.reactivex.rxjava3.core.Maybe<Response> select(String arg0)

Redis command SELECT.

Parameters:: arg0 -
Returns:: fluent self

rxSelect

public io.reactivex.rxjava3.core.Maybe<Response> rxSelect(String arg0)

Redis command SELECT.

Parameters:: arg0 -
Returns:: fluent self

set

public io.reactivex.rxjava3.core.Maybe<Response> set(List<String> args)

Redis command SET.

Parameters:: args -
Returns:: fluent self

rxSet

public io.reactivex.rxjava3.core.Maybe<Response> rxSet(List<String> args)

Redis command SET.

Parameters:: args -
Returns:: fluent self

setbit

public io.reactivex.rxjava3.core.Maybe<Response> setbit(String arg0,
                                                        String arg1,
                                                        String arg2)

Redis command SETBIT.

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

rxSetbit

public io.reactivex.rxjava3.core.Maybe<Response> rxSetbit(String arg0,
                                                          String arg1,
                                                          String arg2)

Redis command SETBIT.

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

setex

public io.reactivex.rxjava3.core.Maybe<Response> setex(String arg0,
                                                       String arg1,
                                                       String arg2)

Redis command SETEX.

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

rxSetex

public io.reactivex.rxjava3.core.Maybe<Response> rxSetex(String arg0,
                                                         String arg1,
                                                         String arg2)

Redis command SETEX.

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

setnx

public io.reactivex.rxjava3.core.Maybe<Response> setnx(String arg0,
                                                       String arg1)

Redis command SETNX.

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

rxSetnx

public io.reactivex.rxjava3.core.Maybe<Response> rxSetnx(String arg0,
                                                         String arg1)

Redis command SETNX.

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

setrange

public io.reactivex.rxjava3.core.Maybe<Response> setrange(String arg0,
                                                          String arg1,
                                                          String arg2)

Redis command SETRANGE.

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

rxSetrange

public io.reactivex.rxjava3.core.Maybe<Response> rxSetrange(String arg0,
                                                            String arg1,
                                                            String arg2)

Redis command SETRANGE.

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

shutdown

public io.reactivex.rxjava3.core.Maybe<Response> shutdown(List<String> args)

Redis command SHUTDOWN.

Parameters:: args -
Returns:: fluent self

rxShutdown

public io.reactivex.rxjava3.core.Maybe<Response> rxShutdown(List<String> args)

Redis command SHUTDOWN.

Parameters:: args -
Returns:: fluent self

sinter

public io.reactivex.rxjava3.core.Maybe<Response> sinter(List<String> args)

Redis command SINTER.

Parameters:: args -
Returns:: fluent self

rxSinter

public io.reactivex.rxjava3.core.Maybe<Response> rxSinter(List<String> args)

Redis command SINTER.

Parameters:: args -
Returns:: fluent self

sintercard

public io.reactivex.rxjava3.core.Maybe<Response> sintercard(List<String> args)

Redis command SINTERCARD.

Parameters:: args -
Returns:: fluent self

rxSintercard

public io.reactivex.rxjava3.core.Maybe<Response> rxSintercard(List<String> args)

Redis command SINTERCARD.

Parameters:: args -
Returns:: fluent self

sinterstore

public io.reactivex.rxjava3.core.Maybe<Response> sinterstore(List<String> args)

Redis command SINTERSTORE.

Parameters:: args -
Returns:: fluent self

rxSinterstore

public io.reactivex.rxjava3.core.Maybe<Response> rxSinterstore(List<String> args)

Redis command SINTERSTORE.

Parameters:: args -
Returns:: fluent self

sismember

public io.reactivex.rxjava3.core.Maybe<Response> sismember(String arg0,
                                                           String arg1)

Redis command SISMEMBER.

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

rxSismember

public io.reactivex.rxjava3.core.Maybe<Response> rxSismember(String arg0,
                                                             String arg1)

Redis command SISMEMBER.

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

slaveof

public io.reactivex.rxjava3.core.Maybe<Response> slaveof(String arg0,
                                                         String arg1)

Redis command SLAVEOF.

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

rxSlaveof

public io.reactivex.rxjava3.core.Maybe<Response> rxSlaveof(String arg0,
                                                           String arg1)

Redis command SLAVEOF.

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

slowlog

public io.reactivex.rxjava3.core.Maybe<Response> slowlog(List<String> args)

Redis command SLOWLOG.

Parameters:: args -
Returns:: fluent self

rxSlowlog

public io.reactivex.rxjava3.core.Maybe<Response> rxSlowlog(List<String> args)

Redis command SLOWLOG.

Parameters:: args -
Returns:: fluent self

smembers

public io.reactivex.rxjava3.core.Maybe<Response> smembers(String arg0)

Redis command SMEMBERS.

Parameters:: arg0 -
Returns:: fluent self

rxSmembers

public io.reactivex.rxjava3.core.Maybe<Response> rxSmembers(String arg0)

Redis command SMEMBERS.

Parameters:: arg0 -
Returns:: fluent self

smismember

public io.reactivex.rxjava3.core.Maybe<Response> smismember(List<String> args)

Redis command SMISMEMBER.

Parameters:: args -
Returns:: fluent self

rxSmismember

public io.reactivex.rxjava3.core.Maybe<Response> rxSmismember(List<String> args)

Redis command SMISMEMBER.

Parameters:: args -
Returns:: fluent self

smove

public io.reactivex.rxjava3.core.Maybe<Response> smove(String arg0,
                                                       String arg1,
                                                       String arg2)

Redis command SMOVE.

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

rxSmove

public io.reactivex.rxjava3.core.Maybe<Response> rxSmove(String arg0,
                                                         String arg1,
                                                         String arg2)

Redis command SMOVE.

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

sort

public io.reactivex.rxjava3.core.Maybe<Response> sort(List<String> args)

Redis command SORT.

Parameters:: args -
Returns:: fluent self

rxSort

public io.reactivex.rxjava3.core.Maybe<Response> rxSort(List<String> args)

Redis command SORT.

Parameters:: args -
Returns:: fluent self

sortRo

public io.reactivex.rxjava3.core.Maybe<Response> sortRo(List<String> args)

Redis command SORT_RO.

Parameters:: args -
Returns:: fluent self

rxSortRo

public io.reactivex.rxjava3.core.Maybe<Response> rxSortRo(List<String> args)

Redis command SORT_RO.

Parameters:: args -
Returns:: fluent self

spop

public io.reactivex.rxjava3.core.Maybe<Response> spop(List<String> args)

Redis command SPOP.

Parameters:: args -
Returns:: fluent self

rxSpop

public io.reactivex.rxjava3.core.Maybe<Response> rxSpop(List<String> args)

Redis command SPOP.

Parameters:: args -
Returns:: fluent self

spublish

public io.reactivex.rxjava3.core.Maybe<Response> spublish(String arg0,
                                                          String arg1)

Redis command SPUBLISH.

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

rxSpublish

public io.reactivex.rxjava3.core.Maybe<Response> rxSpublish(String arg0,
                                                            String arg1)

Redis command SPUBLISH.

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

srandmember

public io.reactivex.rxjava3.core.Maybe<Response> srandmember(List<String> args)

Redis command SRANDMEMBER.

Parameters:: args -
Returns:: fluent self

rxSrandmember

public io.reactivex.rxjava3.core.Maybe<Response> rxSrandmember(List<String> args)

Redis command SRANDMEMBER.

Parameters:: args -
Returns:: fluent self

srem

public io.reactivex.rxjava3.core.Maybe<Response> srem(List<String> args)

Redis command SREM.

Parameters:: args -
Returns:: fluent self

rxSrem

public io.reactivex.rxjava3.core.Maybe<Response> rxSrem(List<String> args)

Redis command SREM.

Parameters:: args -
Returns:: fluent self

sscan

public io.reactivex.rxjava3.core.Maybe<Response> sscan(List<String> args)

Redis command SSCAN.

Parameters:: args -
Returns:: fluent self

rxSscan

public io.reactivex.rxjava3.core.Maybe<Response> rxSscan(List<String> args)

Redis command SSCAN.

Parameters:: args -
Returns:: fluent self

ssubscribe

public io.reactivex.rxjava3.core.Maybe<Response> ssubscribe(List<String> args)

Redis command SSUBSCRIBE.

Parameters:: args -
Returns:: fluent self

rxSsubscribe

public io.reactivex.rxjava3.core.Maybe<Response> rxSsubscribe(List<String> args)

Redis command SSUBSCRIBE.

Parameters:: args -
Returns:: fluent self

strlen

public io.reactivex.rxjava3.core.Maybe<Response> strlen(String arg0)

Redis command STRLEN.

Parameters:: arg0 -
Returns:: fluent self

rxStrlen

public io.reactivex.rxjava3.core.Maybe<Response> rxStrlen(String arg0)

Redis command STRLEN.

Parameters:: arg0 -
Returns:: fluent self

subscribe

public io.reactivex.rxjava3.core.Maybe<Response> subscribe(List<String> args)

Redis command SUBSCRIBE.

Parameters:: args -
Returns:: fluent self

rxSubscribe

public io.reactivex.rxjava3.core.Maybe<Response> rxSubscribe(List<String> args)

Redis command SUBSCRIBE.

Parameters:: args -
Returns:: fluent self

substr

public io.reactivex.rxjava3.core.Maybe<Response> substr(String arg0,
                                                        String arg1,
                                                        String arg2)

Redis command SUBSTR.

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

rxSubstr

public io.reactivex.rxjava3.core.Maybe<Response> rxSubstr(String arg0,
                                                          String arg1,
                                                          String arg2)

Redis command SUBSTR.

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

sunion

public io.reactivex.rxjava3.core.Maybe<Response> sunion(List<String> args)

Redis command SUNION.

Parameters:: args -
Returns:: fluent self

rxSunion

public io.reactivex.rxjava3.core.Maybe<Response> rxSunion(List<String> args)

Redis command SUNION.

Parameters:: args -
Returns:: fluent self

sunionstore

public io.reactivex.rxjava3.core.Maybe<Response> sunionstore(List<String> args)

Redis command SUNIONSTORE.

Parameters:: args -
Returns:: fluent self

rxSunionstore

public io.reactivex.rxjava3.core.Maybe<Response> rxSunionstore(List<String> args)

Redis command SUNIONSTORE.

Parameters:: args -
Returns:: fluent self

sunsubscribe

public io.reactivex.rxjava3.core.Maybe<Response> sunsubscribe(List<String> args)

Redis command SUNSUBSCRIBE.

Parameters:: args -
Returns:: fluent self

rxSunsubscribe

public io.reactivex.rxjava3.core.Maybe<Response> rxSunsubscribe(List<String> args)

Redis command SUNSUBSCRIBE.

Parameters:: args -
Returns:: fluent self

swapdb

public io.reactivex.rxjava3.core.Maybe<Response> swapdb(String arg0,
                                                        String arg1)

Redis command SWAPDB.

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

rxSwapdb

public io.reactivex.rxjava3.core.Maybe<Response> rxSwapdb(String arg0,
                                                          String arg1)

Redis command SWAPDB.

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

sync

public io.reactivex.rxjava3.core.Maybe<Response> sync()

Redis command SYNC.

Returns:: fluent self

rxSync

public io.reactivex.rxjava3.core.Maybe<Response> rxSync()

Redis command SYNC.

Returns:: fluent self

tdigestAdd

public io.reactivex.rxjava3.core.Maybe<Response> tdigestAdd(List<String> args)

Redis command TDIGEST.ADD.

Parameters:: args -
Returns:: fluent self

rxTdigestAdd

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestAdd(List<String> args)

Redis command TDIGEST.ADD.

Parameters:: args -
Returns:: fluent self

tdigestByrank

public io.reactivex.rxjava3.core.Maybe<Response> tdigestByrank(List<String> args)

Redis command TDIGEST.BYRANK.

Parameters:: args -
Returns:: fluent self

rxTdigestByrank

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestByrank(List<String> args)

Redis command TDIGEST.BYRANK.

Parameters:: args -
Returns:: fluent self

tdigestByrevrank

public io.reactivex.rxjava3.core.Maybe<Response> tdigestByrevrank(List<String> args)

Redis command TDIGEST.BYREVRANK.

Parameters:: args -
Returns:: fluent self

rxTdigestByrevrank

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestByrevrank(List<String> args)

Redis command TDIGEST.BYREVRANK.

Parameters:: args -
Returns:: fluent self

tdigestCdf

public io.reactivex.rxjava3.core.Maybe<Response> tdigestCdf(List<String> args)

Redis command TDIGEST.CDF.

Parameters:: args -
Returns:: fluent self

rxTdigestCdf

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestCdf(List<String> args)

Redis command TDIGEST.CDF.

Parameters:: args -
Returns:: fluent self

tdigestCreate

public io.reactivex.rxjava3.core.Maybe<Response> tdigestCreate(List<String> args)

Redis command TDIGEST.CREATE.

Parameters:: args -
Returns:: fluent self

rxTdigestCreate

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestCreate(List<String> args)

Redis command TDIGEST.CREATE.

Parameters:: args -
Returns:: fluent self

tdigestInfo

public io.reactivex.rxjava3.core.Maybe<Response> tdigestInfo(List<String> args)

Redis command TDIGEST.INFO.

Parameters:: args -
Returns:: fluent self

rxTdigestInfo

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestInfo(List<String> args)

Redis command TDIGEST.INFO.

Parameters:: args -
Returns:: fluent self

tdigestMax

public io.reactivex.rxjava3.core.Maybe<Response> tdigestMax(List<String> args)

Redis command TDIGEST.MAX.

Parameters:: args -
Returns:: fluent self

rxTdigestMax

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestMax(List<String> args)

Redis command TDIGEST.MAX.

Parameters:: args -
Returns:: fluent self

tdigestMerge

public io.reactivex.rxjava3.core.Maybe<Response> tdigestMerge(List<String> args)

Redis command TDIGEST.MERGE.

Parameters:: args -
Returns:: fluent self

rxTdigestMerge

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestMerge(List<String> args)

Redis command TDIGEST.MERGE.

Parameters:: args -
Returns:: fluent self

tdigestMin

public io.reactivex.rxjava3.core.Maybe<Response> tdigestMin(List<String> args)

Redis command TDIGEST.MIN.

Parameters:: args -
Returns:: fluent self

rxTdigestMin

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestMin(List<String> args)

Redis command TDIGEST.MIN.

Parameters:: args -
Returns:: fluent self

tdigestQuantile

public io.reactivex.rxjava3.core.Maybe<Response> tdigestQuantile(List<String> args)

Redis command TDIGEST.QUANTILE.

Parameters:: args -
Returns:: fluent self

rxTdigestQuantile

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestQuantile(List<String> args)

Redis command TDIGEST.QUANTILE.

Parameters:: args -
Returns:: fluent self

tdigestRank

public io.reactivex.rxjava3.core.Maybe<Response> tdigestRank(List<String> args)

Redis command TDIGEST.RANK.

Parameters:: args -
Returns:: fluent self

rxTdigestRank

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestRank(List<String> args)

Redis command TDIGEST.RANK.

Parameters:: args -
Returns:: fluent self

tdigestReset

public io.reactivex.rxjava3.core.Maybe<Response> tdigestReset(List<String> args)

Redis command TDIGEST.RESET.

Parameters:: args -
Returns:: fluent self

rxTdigestReset

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestReset(List<String> args)

Redis command TDIGEST.RESET.

Parameters:: args -
Returns:: fluent self

tdigestRevrank

public io.reactivex.rxjava3.core.Maybe<Response> tdigestRevrank(List<String> args)

Redis command TDIGEST.REVRANK.

Parameters:: args -
Returns:: fluent self

rxTdigestRevrank

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestRevrank(List<String> args)

Redis command TDIGEST.REVRANK.

Parameters:: args -
Returns:: fluent self

tdigestTrimmedMean

public io.reactivex.rxjava3.core.Maybe<Response> tdigestTrimmedMean(List<String> args)

Redis command TDIGEST.TRIMMED_MEAN.

Parameters:: args -
Returns:: fluent self

rxTdigestTrimmedMean

public io.reactivex.rxjava3.core.Maybe<Response> rxTdigestTrimmedMean(List<String> args)

Redis command TDIGEST.TRIMMED_MEAN.

Parameters:: args -
Returns:: fluent self

time

public io.reactivex.rxjava3.core.Maybe<Response> time()

Redis command TIME.

Returns:: fluent self

rxTime

public io.reactivex.rxjava3.core.Maybe<Response> rxTime()

Redis command TIME.

Returns:: fluent self

timeseriesClusterset

public io.reactivex.rxjava3.core.Maybe<Response> timeseriesClusterset(List<String> args)

Redis command TIMESERIES.CLUSTERSET.

Parameters:: args -
Returns:: fluent self

rxTimeseriesClusterset

public io.reactivex.rxjava3.core.Maybe<Response> rxTimeseriesClusterset(List<String> args)

Redis command TIMESERIES.CLUSTERSET.

Parameters:: args -
Returns:: fluent self

timeseriesClustersetfromshard
```
public io.reactivex.rxjava3.core.Maybe<Response> timeseriesClustersetfromshard(List<String> args)
```
Redis command TIMESERIES.CLUSTERSETFROMSHARD.

Parameters:

args -

Returns:

fluent self

rxTimeseriesClustersetfromshard
```
public io.reactivex.rxjava3.core.Maybe<Response> rxTimeseriesClustersetfromshard(List<String> args)
```
Redis command TIMESERIES.CLUSTERSETFROMSHARD.

Parameters:

args -

Returns:

fluent self

timeseriesHello

public io.reactivex.rxjava3.core.Maybe<Response> timeseriesHello(List<String> args)

Redis command TIMESERIES.HELLO.

Parameters:: args -
Returns:: fluent self

rxTimeseriesHello

public io.reactivex.rxjava3.core.Maybe<Response> rxTimeseriesHello(List<String> args)

Redis command TIMESERIES.HELLO.

Parameters:: args -
Returns:: fluent self

timeseriesInfocluster

public io.reactivex.rxjava3.core.Maybe<Response> timeseriesInfocluster(List<String> args)

Redis command TIMESERIES.INFOCLUSTER.

Parameters:: args -
Returns:: fluent self

rxTimeseriesInfocluster

public io.reactivex.rxjava3.core.Maybe<Response> rxTimeseriesInfocluster(List<String> args)

Redis command TIMESERIES.INFOCLUSTER.

Parameters:: args -
Returns:: fluent self

timeseriesInnercommunication
```
public io.reactivex.rxjava3.core.Maybe<Response> timeseriesInnercommunication(List<String> args)
```
Redis command TIMESERIES.INNERCOMMUNICATION.

Parameters:

args -

Returns:

fluent self

rxTimeseriesInnercommunication
```
public io.reactivex.rxjava3.core.Maybe<Response> rxTimeseriesInnercommunication(List<String> args)
```
Redis command TIMESERIES.INNERCOMMUNICATION.

Parameters:

args -

Returns:

fluent self

timeseriesNetworktest

public io.reactivex.rxjava3.core.Maybe<Response> timeseriesNetworktest(List<String> args)

Redis command TIMESERIES.NETWORKTEST.

Parameters:: args -
Returns:: fluent self

rxTimeseriesNetworktest

public io.reactivex.rxjava3.core.Maybe<Response> rxTimeseriesNetworktest(List<String> args)

Redis command TIMESERIES.NETWORKTEST.

Parameters:: args -
Returns:: fluent self

timeseriesRefreshcluster

public io.reactivex.rxjava3.core.Maybe<Response> timeseriesRefreshcluster(List<String> args)

Redis command TIMESERIES.REFRESHCLUSTER.

Parameters:: args -
Returns:: fluent self

rxTimeseriesRefreshcluster

public io.reactivex.rxjava3.core.Maybe<Response> rxTimeseriesRefreshcluster(List<String> args)

Redis command TIMESERIES.REFRESHCLUSTER.

Parameters:: args -
Returns:: fluent self

topkAdd

public io.reactivex.rxjava3.core.Maybe<Response> topkAdd(List<String> args)

Redis command TOPK.ADD.

Parameters:: args -
Returns:: fluent self

rxTopkAdd

public io.reactivex.rxjava3.core.Maybe<Response> rxTopkAdd(List<String> args)

Redis command TOPK.ADD.

Parameters:: args -
Returns:: fluent self

topkCount

public io.reactivex.rxjava3.core.Maybe<Response> topkCount(List<String> args)

Redis command TOPK.COUNT.

Parameters:: args -
Returns:: fluent self

rxTopkCount

public io.reactivex.rxjava3.core.Maybe<Response> rxTopkCount(List<String> args)

Redis command TOPK.COUNT.

Parameters:: args -
Returns:: fluent self

topkIncrby

public io.reactivex.rxjava3.core.Maybe<Response> topkIncrby(List<String> args)

Redis command TOPK.INCRBY.

Parameters:: args -
Returns:: fluent self

rxTopkIncrby

public io.reactivex.rxjava3.core.Maybe<Response> rxTopkIncrby(List<String> args)

Redis command TOPK.INCRBY.

Parameters:: args -
Returns:: fluent self

topkInfo

public io.reactivex.rxjava3.core.Maybe<Response> topkInfo(List<String> args)

Redis command TOPK.INFO.

Parameters:: args -
Returns:: fluent self

rxTopkInfo

public io.reactivex.rxjava3.core.Maybe<Response> rxTopkInfo(List<String> args)

Redis command TOPK.INFO.

Parameters:: args -
Returns:: fluent self

topkList

public io.reactivex.rxjava3.core.Maybe<Response> topkList(List<String> args)

Redis command TOPK.LIST.

Parameters:: args -
Returns:: fluent self

rxTopkList

public io.reactivex.rxjava3.core.Maybe<Response> rxTopkList(List<String> args)

Redis command TOPK.LIST.

Parameters:: args -
Returns:: fluent self

topkQuery

public io.reactivex.rxjava3.core.Maybe<Response> topkQuery(List<String> args)

Redis command TOPK.QUERY.

Parameters:: args -
Returns:: fluent self

rxTopkQuery

public io.reactivex.rxjava3.core.Maybe<Response> rxTopkQuery(List<String> args)

Redis command TOPK.QUERY.

Parameters:: args -
Returns:: fluent self

topkReserve

public io.reactivex.rxjava3.core.Maybe<Response> topkReserve(List<String> args)

Redis command TOPK.RESERVE.

Parameters:: args -
Returns:: fluent self

rxTopkReserve

public io.reactivex.rxjava3.core.Maybe<Response> rxTopkReserve(List<String> args)

Redis command TOPK.RESERVE.

Parameters:: args -
Returns:: fluent self

touch

public io.reactivex.rxjava3.core.Maybe<Response> touch(List<String> args)

Redis command TOUCH.

Parameters:: args -
Returns:: fluent self

rxTouch

public io.reactivex.rxjava3.core.Maybe<Response> rxTouch(List<String> args)

Redis command TOUCH.

Parameters:: args -
Returns:: fluent self

tsAdd

public io.reactivex.rxjava3.core.Maybe<Response> tsAdd(List<String> args)

Redis command TS.ADD.

Parameters:: args -
Returns:: fluent self

rxTsAdd

public io.reactivex.rxjava3.core.Maybe<Response> rxTsAdd(List<String> args)

Redis command TS.ADD.

Parameters:: args -
Returns:: fluent self

tsAlter

public io.reactivex.rxjava3.core.Maybe<Response> tsAlter(List<String> args)

Redis command TS.ALTER.

Parameters:: args -
Returns:: fluent self

rxTsAlter

public io.reactivex.rxjava3.core.Maybe<Response> rxTsAlter(List<String> args)

Redis command TS.ALTER.

Parameters:: args -
Returns:: fluent self

tsCreate

public io.reactivex.rxjava3.core.Maybe<Response> tsCreate(List<String> args)

Redis command TS.CREATE.

Parameters:: args -
Returns:: fluent self

rxTsCreate

public io.reactivex.rxjava3.core.Maybe<Response> rxTsCreate(List<String> args)

Redis command TS.CREATE.

Parameters:: args -
Returns:: fluent self

tsCreaterule

public io.reactivex.rxjava3.core.Maybe<Response> tsCreaterule(List<String> args)

Redis command TS.CREATERULE.

Parameters:: args -
Returns:: fluent self

rxTsCreaterule

public io.reactivex.rxjava3.core.Maybe<Response> rxTsCreaterule(List<String> args)

Redis command TS.CREATERULE.

Parameters:: args -
Returns:: fluent self

tsDecrby

public io.reactivex.rxjava3.core.Maybe<Response> tsDecrby(List<String> args)

Redis command TS.DECRBY.

Parameters:: args -
Returns:: fluent self

rxTsDecrby

public io.reactivex.rxjava3.core.Maybe<Response> rxTsDecrby(List<String> args)

Redis command TS.DECRBY.

Parameters:: args -
Returns:: fluent self

tsDel

public io.reactivex.rxjava3.core.Maybe<Response> tsDel(List<String> args)

Redis command TS.DEL.

Parameters:: args -
Returns:: fluent self

rxTsDel

public io.reactivex.rxjava3.core.Maybe<Response> rxTsDel(List<String> args)

Redis command TS.DEL.

Parameters:: args -
Returns:: fluent self

tsDeleterule

public io.reactivex.rxjava3.core.Maybe<Response> tsDeleterule(List<String> args)

Redis command TS.DELETERULE.

Parameters:: args -
Returns:: fluent self

rxTsDeleterule

public io.reactivex.rxjava3.core.Maybe<Response> rxTsDeleterule(List<String> args)

Redis command TS.DELETERULE.

Parameters:: args -
Returns:: fluent self

tsGet

public io.reactivex.rxjava3.core.Maybe<Response> tsGet(List<String> args)

Redis command TS.GET.

Parameters:: args -
Returns:: fluent self

rxTsGet

public io.reactivex.rxjava3.core.Maybe<Response> rxTsGet(List<String> args)

Redis command TS.GET.

Parameters:: args -
Returns:: fluent self

tsIncrby

public io.reactivex.rxjava3.core.Maybe<Response> tsIncrby(List<String> args)

Redis command TS.INCRBY.

Parameters:: args -
Returns:: fluent self

rxTsIncrby

public io.reactivex.rxjava3.core.Maybe<Response> rxTsIncrby(List<String> args)

Redis command TS.INCRBY.

Parameters:: args -
Returns:: fluent self

tsInfo

public io.reactivex.rxjava3.core.Maybe<Response> tsInfo(List<String> args)

Redis command TS.INFO.

Parameters:: args -
Returns:: fluent self

rxTsInfo

public io.reactivex.rxjava3.core.Maybe<Response> rxTsInfo(List<String> args)

Redis command TS.INFO.

Parameters:: args -
Returns:: fluent self

tsMadd

public io.reactivex.rxjava3.core.Maybe<Response> tsMadd(List<String> args)

Redis command TS.MADD.

Parameters:: args -
Returns:: fluent self

rxTsMadd

public io.reactivex.rxjava3.core.Maybe<Response> rxTsMadd(List<String> args)

Redis command TS.MADD.

Parameters:: args -
Returns:: fluent self

tsMget

public io.reactivex.rxjava3.core.Maybe<Response> tsMget(List<String> args)

Redis command TS.MGET.

Parameters:: args -
Returns:: fluent self

rxTsMget

public io.reactivex.rxjava3.core.Maybe<Response> rxTsMget(List<String> args)

Redis command TS.MGET.

Parameters:: args -
Returns:: fluent self

tsMrange

public io.reactivex.rxjava3.core.Maybe<Response> tsMrange(List<String> args)

Redis command TS.MRANGE.

Parameters:: args -
Returns:: fluent self

rxTsMrange

public io.reactivex.rxjava3.core.Maybe<Response> rxTsMrange(List<String> args)

Redis command TS.MRANGE.

Parameters:: args -
Returns:: fluent self

tsMrevrange

public io.reactivex.rxjava3.core.Maybe<Response> tsMrevrange(List<String> args)

Redis command TS.MREVRANGE.

Parameters:: args -
Returns:: fluent self

rxTsMrevrange

public io.reactivex.rxjava3.core.Maybe<Response> rxTsMrevrange(List<String> args)

Redis command TS.MREVRANGE.

Parameters:: args -
Returns:: fluent self

tsQueryindex

public io.reactivex.rxjava3.core.Maybe<Response> tsQueryindex(List<String> args)

Redis command TS.QUERYINDEX.

Parameters:: args -
Returns:: fluent self

rxTsQueryindex

public io.reactivex.rxjava3.core.Maybe<Response> rxTsQueryindex(List<String> args)

Redis command TS.QUERYINDEX.

Parameters:: args -
Returns:: fluent self

tsRange

public io.reactivex.rxjava3.core.Maybe<Response> tsRange(List<String> args)

Redis command TS.RANGE.

Parameters:: args -
Returns:: fluent self

rxTsRange

public io.reactivex.rxjava3.core.Maybe<Response> rxTsRange(List<String> args)

Redis command TS.RANGE.

Parameters:: args -
Returns:: fluent self

tsRevrange

public io.reactivex.rxjava3.core.Maybe<Response> tsRevrange(List<String> args)

Redis command TS.REVRANGE.

Parameters:: args -
Returns:: fluent self

rxTsRevrange

public io.reactivex.rxjava3.core.Maybe<Response> rxTsRevrange(List<String> args)

Redis command TS.REVRANGE.

Parameters:: args -
Returns:: fluent self

ttl

public io.reactivex.rxjava3.core.Maybe<Response> ttl(String arg0)

Redis command TTL.

Parameters:: arg0 -
Returns:: fluent self

rxTtl

public io.reactivex.rxjava3.core.Maybe<Response> rxTtl(String arg0)

Redis command TTL.

Parameters:: arg0 -
Returns:: fluent self

type

public io.reactivex.rxjava3.core.Maybe<Response> type(String arg0)

Redis command TYPE.

Parameters:: arg0 -
Returns:: fluent self

rxType

public io.reactivex.rxjava3.core.Maybe<Response> rxType(String arg0)

Redis command TYPE.

Parameters:: arg0 -
Returns:: fluent self

unlink

public io.reactivex.rxjava3.core.Maybe<Response> unlink(List<String> args)

Redis command UNLINK.

Parameters:: args -
Returns:: fluent self

rxUnlink

public io.reactivex.rxjava3.core.Maybe<Response> rxUnlink(List<String> args)

Redis command UNLINK.

Parameters:: args -
Returns:: fluent self

unsubscribe

public io.reactivex.rxjava3.core.Maybe<Response> unsubscribe(List<String> args)

Redis command UNSUBSCRIBE.

Parameters:: args -
Returns:: fluent self

rxUnsubscribe

public io.reactivex.rxjava3.core.Maybe<Response> rxUnsubscribe(List<String> args)

Redis command UNSUBSCRIBE.

Parameters:: args -
Returns:: fluent self

unwatch

public io.reactivex.rxjava3.core.Maybe<Response> unwatch()

Redis command UNWATCH.

Returns:: fluent self

rxUnwatch

public io.reactivex.rxjava3.core.Maybe<Response> rxUnwatch()

Redis command UNWATCH.

Returns:: fluent self

wait

public io.reactivex.rxjava3.core.Maybe<Response> wait(String arg0,
                                                      String arg1)

Redis command WAIT.

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

rxWait

public io.reactivex.rxjava3.core.Maybe<Response> rxWait(String arg0,
                                                        String arg1)

Redis command WAIT.

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

watch

public io.reactivex.rxjava3.core.Maybe<Response> watch(List<String> args)

Redis command WATCH.

Parameters:: args -
Returns:: fluent self

rxWatch

public io.reactivex.rxjava3.core.Maybe<Response> rxWatch(List<String> args)

Redis command WATCH.

Parameters:: args -
Returns:: fluent self

xack

public io.reactivex.rxjava3.core.Maybe<Response> xack(List<String> args)

Redis command XACK.

Parameters:: args -
Returns:: fluent self

rxXack

public io.reactivex.rxjava3.core.Maybe<Response> rxXack(List<String> args)

Redis command XACK.

Parameters:: args -
Returns:: fluent self

xadd

public io.reactivex.rxjava3.core.Maybe<Response> xadd(List<String> args)

Redis command XADD.

Parameters:: args -
Returns:: fluent self

rxXadd

public io.reactivex.rxjava3.core.Maybe<Response> rxXadd(List<String> args)

Redis command XADD.

Parameters:: args -
Returns:: fluent self

xautoclaim

public io.reactivex.rxjava3.core.Maybe<Response> xautoclaim(List<String> args)

Redis command XAUTOCLAIM.

Parameters:: args -
Returns:: fluent self

rxXautoclaim

public io.reactivex.rxjava3.core.Maybe<Response> rxXautoclaim(List<String> args)

Redis command XAUTOCLAIM.

Parameters:: args -
Returns:: fluent self

xclaim

public io.reactivex.rxjava3.core.Maybe<Response> xclaim(List<String> args)

Redis command XCLAIM.

Parameters:: args -
Returns:: fluent self

rxXclaim

public io.reactivex.rxjava3.core.Maybe<Response> rxXclaim(List<String> args)

Redis command XCLAIM.

Parameters:: args -
Returns:: fluent self

xdel

public io.reactivex.rxjava3.core.Maybe<Response> xdel(List<String> args)

Redis command XDEL.

Parameters:: args -
Returns:: fluent self

rxXdel

public io.reactivex.rxjava3.core.Maybe<Response> rxXdel(List<String> args)

Redis command XDEL.

Parameters:: args -
Returns:: fluent self

xgroup

public io.reactivex.rxjava3.core.Maybe<Response> xgroup(List<String> args)

Redis command XGROUP.

Parameters:: args -
Returns:: fluent self

rxXgroup

public io.reactivex.rxjava3.core.Maybe<Response> rxXgroup(List<String> args)

Redis command XGROUP.

Parameters:: args -
Returns:: fluent self

xinfo

public io.reactivex.rxjava3.core.Maybe<Response> xinfo(List<String> args)

Redis command XINFO.

Parameters:: args -
Returns:: fluent self

rxXinfo

public io.reactivex.rxjava3.core.Maybe<Response> rxXinfo(List<String> args)

Redis command XINFO.

Parameters:: args -
Returns:: fluent self

xlen

public io.reactivex.rxjava3.core.Maybe<Response> xlen(String arg0)

Redis command XLEN.

Parameters:: arg0 -
Returns:: fluent self

rxXlen

public io.reactivex.rxjava3.core.Maybe<Response> rxXlen(String arg0)

Redis command XLEN.

Parameters:: arg0 -
Returns:: fluent self

xpending

public io.reactivex.rxjava3.core.Maybe<Response> xpending(List<String> args)

Redis command XPENDING.

Parameters:: args -
Returns:: fluent self

rxXpending

public io.reactivex.rxjava3.core.Maybe<Response> rxXpending(List<String> args)

Redis command XPENDING.

Parameters:: args -
Returns:: fluent self

xrange

public io.reactivex.rxjava3.core.Maybe<Response> xrange(List<String> args)

Redis command XRANGE.

Parameters:: args -
Returns:: fluent self

rxXrange

public io.reactivex.rxjava3.core.Maybe<Response> rxXrange(List<String> args)

Redis command XRANGE.

Parameters:: args -
Returns:: fluent self

xread

public io.reactivex.rxjava3.core.Maybe<Response> xread(List<String> args)

Redis command XREAD.

Parameters:: args -
Returns:: fluent self

rxXread

public io.reactivex.rxjava3.core.Maybe<Response> rxXread(List<String> args)

Redis command XREAD.

Parameters:: args -
Returns:: fluent self

xreadgroup

public io.reactivex.rxjava3.core.Maybe<Response> xreadgroup(List<String> args)

Redis command XREADGROUP.

Parameters:: args -
Returns:: fluent self

rxXreadgroup

public io.reactivex.rxjava3.core.Maybe<Response> rxXreadgroup(List<String> args)

Redis command XREADGROUP.

Parameters:: args -
Returns:: fluent self

xrevrange

public io.reactivex.rxjava3.core.Maybe<Response> xrevrange(List<String> args)

Redis command XREVRANGE.

Parameters:: args -
Returns:: fluent self

rxXrevrange

public io.reactivex.rxjava3.core.Maybe<Response> rxXrevrange(List<String> args)

Redis command XREVRANGE.

Parameters:: args -
Returns:: fluent self

xsetid

public io.reactivex.rxjava3.core.Maybe<Response> xsetid(List<String> args)

Redis command XSETID.

Parameters:: args -
Returns:: fluent self

rxXsetid

public io.reactivex.rxjava3.core.Maybe<Response> rxXsetid(List<String> args)

Redis command XSETID.

Parameters:: args -
Returns:: fluent self

xtrim

public io.reactivex.rxjava3.core.Maybe<Response> xtrim(List<String> args)

Redis command XTRIM.

Parameters:: args -
Returns:: fluent self

rxXtrim

public io.reactivex.rxjava3.core.Maybe<Response> rxXtrim(List<String> args)

Redis command XTRIM.

Parameters:: args -
Returns:: fluent self

zadd

public io.reactivex.rxjava3.core.Maybe<Response> zadd(List<String> args)

Redis command ZADD.

Parameters:: args -
Returns:: fluent self

rxZadd

public io.reactivex.rxjava3.core.Maybe<Response> rxZadd(List<String> args)

Redis command ZADD.

Parameters:: args -
Returns:: fluent self

zcard

public io.reactivex.rxjava3.core.Maybe<Response> zcard(String arg0)

Redis command ZCARD.

Parameters:: arg0 -
Returns:: fluent self

rxZcard

public io.reactivex.rxjava3.core.Maybe<Response> rxZcard(String arg0)

Redis command ZCARD.

Parameters:: arg0 -
Returns:: fluent self

zcount

public io.reactivex.rxjava3.core.Maybe<Response> zcount(String arg0,
                                                        String arg1,
                                                        String arg2)

Redis command ZCOUNT.

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

rxZcount

public io.reactivex.rxjava3.core.Maybe<Response> rxZcount(String arg0,
                                                          String arg1,
                                                          String arg2)

Redis command ZCOUNT.

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

zdiff

public io.reactivex.rxjava3.core.Maybe<Response> zdiff(List<String> args)

Redis command ZDIFF.

Parameters:: args -
Returns:: fluent self

rxZdiff

public io.reactivex.rxjava3.core.Maybe<Response> rxZdiff(List<String> args)

Redis command ZDIFF.

Parameters:: args -
Returns:: fluent self

zdiffstore

public io.reactivex.rxjava3.core.Maybe<Response> zdiffstore(List<String> args)

Redis command ZDIFFSTORE.

Parameters:: args -
Returns:: fluent self

rxZdiffstore

public io.reactivex.rxjava3.core.Maybe<Response> rxZdiffstore(List<String> args)

Redis command ZDIFFSTORE.

Parameters:: args -
Returns:: fluent self

zincrby

public io.reactivex.rxjava3.core.Maybe<Response> zincrby(String arg0,
                                                         String arg1,
                                                         String arg2)

Redis command ZINCRBY.

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

rxZincrby

public io.reactivex.rxjava3.core.Maybe<Response> rxZincrby(String arg0,
                                                           String arg1,
                                                           String arg2)

Redis command ZINCRBY.

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

zinter

public io.reactivex.rxjava3.core.Maybe<Response> zinter(List<String> args)

Redis command ZINTER.

Parameters:: args -
Returns:: fluent self

rxZinter

public io.reactivex.rxjava3.core.Maybe<Response> rxZinter(List<String> args)

Redis command ZINTER.

Parameters:: args -
Returns:: fluent self

zintercard

public io.reactivex.rxjava3.core.Maybe<Response> zintercard(List<String> args)

Redis command ZINTERCARD.

Parameters:: args -
Returns:: fluent self

rxZintercard

public io.reactivex.rxjava3.core.Maybe<Response> rxZintercard(List<String> args)

Redis command ZINTERCARD.

Parameters:: args -
Returns:: fluent self

zinterstore

public io.reactivex.rxjava3.core.Maybe<Response> zinterstore(List<String> args)

Redis command ZINTERSTORE.

Parameters:: args -
Returns:: fluent self

rxZinterstore

public io.reactivex.rxjava3.core.Maybe<Response> rxZinterstore(List<String> args)

Redis command ZINTERSTORE.

Parameters:: args -
Returns:: fluent self

zlexcount

public io.reactivex.rxjava3.core.Maybe<Response> zlexcount(String arg0,
                                                           String arg1,
                                                           String arg2)

Redis command ZLEXCOUNT.

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

rxZlexcount

public io.reactivex.rxjava3.core.Maybe<Response> rxZlexcount(String arg0,
                                                             String arg1,
                                                             String arg2)

Redis command ZLEXCOUNT.

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

zmpop

public io.reactivex.rxjava3.core.Maybe<Response> zmpop(List<String> args)

Redis command ZMPOP.

Parameters:: args -
Returns:: fluent self

rxZmpop

public io.reactivex.rxjava3.core.Maybe<Response> rxZmpop(List<String> args)

Redis command ZMPOP.

Parameters:: args -
Returns:: fluent self

zmscore

public io.reactivex.rxjava3.core.Maybe<Response> zmscore(List<String> args)

Redis command ZMSCORE.

Parameters:: args -
Returns:: fluent self

rxZmscore

public io.reactivex.rxjava3.core.Maybe<Response> rxZmscore(List<String> args)

Redis command ZMSCORE.

Parameters:: args -
Returns:: fluent self

zpopmax

public io.reactivex.rxjava3.core.Maybe<Response> zpopmax(List<String> args)

Redis command ZPOPMAX.

Parameters:: args -
Returns:: fluent self

rxZpopmax

public io.reactivex.rxjava3.core.Maybe<Response> rxZpopmax(List<String> args)

Redis command ZPOPMAX.

Parameters:: args -
Returns:: fluent self

zpopmin

public io.reactivex.rxjava3.core.Maybe<Response> zpopmin(List<String> args)

Redis command ZPOPMIN.

Parameters:: args -
Returns:: fluent self

rxZpopmin

public io.reactivex.rxjava3.core.Maybe<Response> rxZpopmin(List<String> args)

Redis command ZPOPMIN.

Parameters:: args -
Returns:: fluent self

zrandmember

public io.reactivex.rxjava3.core.Maybe<Response> zrandmember(List<String> args)

Redis command ZRANDMEMBER.

Parameters:: args -
Returns:: fluent self

rxZrandmember

public io.reactivex.rxjava3.core.Maybe<Response> rxZrandmember(List<String> args)

Redis command ZRANDMEMBER.

Parameters:: args -
Returns:: fluent self

zrange

public io.reactivex.rxjava3.core.Maybe<Response> zrange(List<String> args)

Redis command ZRANGE.

Parameters:: args -
Returns:: fluent self

rxZrange

public io.reactivex.rxjava3.core.Maybe<Response> rxZrange(List<String> args)

Redis command ZRANGE.

Parameters:: args -
Returns:: fluent self

zrangebylex

public io.reactivex.rxjava3.core.Maybe<Response> zrangebylex(List<String> args)

Redis command ZRANGEBYLEX.

Parameters:: args -
Returns:: fluent self

rxZrangebylex

public io.reactivex.rxjava3.core.Maybe<Response> rxZrangebylex(List<String> args)

Redis command ZRANGEBYLEX.

Parameters:: args -
Returns:: fluent self

zrangebyscore

public io.reactivex.rxjava3.core.Maybe<Response> zrangebyscore(List<String> args)

Redis command ZRANGEBYSCORE.

Parameters:: args -
Returns:: fluent self

rxZrangebyscore

public io.reactivex.rxjava3.core.Maybe<Response> rxZrangebyscore(List<String> args)

Redis command ZRANGEBYSCORE.

Parameters:: args -
Returns:: fluent self

zrangestore

public io.reactivex.rxjava3.core.Maybe<Response> zrangestore(List<String> args)

Redis command ZRANGESTORE.

Parameters:: args -
Returns:: fluent self

rxZrangestore

public io.reactivex.rxjava3.core.Maybe<Response> rxZrangestore(List<String> args)

Redis command ZRANGESTORE.

Parameters:: args -
Returns:: fluent self

zrank

public io.reactivex.rxjava3.core.Maybe<Response> zrank(String arg0,
                                                       String arg1)

Redis command ZRANK.

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

rxZrank

public io.reactivex.rxjava3.core.Maybe<Response> rxZrank(String arg0,
                                                         String arg1)

Redis command ZRANK.

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

zrem

public io.reactivex.rxjava3.core.Maybe<Response> zrem(List<String> args)

Redis command ZREM.

Parameters:: args -
Returns:: fluent self

rxZrem

public io.reactivex.rxjava3.core.Maybe<Response> rxZrem(List<String> args)

Redis command ZREM.

Parameters:: args -
Returns:: fluent self

zremrangebylex

public io.reactivex.rxjava3.core.Maybe<Response> zremrangebylex(String arg0,
                                                                String arg1,
                                                                String arg2)

Redis command ZREMRANGEBYLEX.

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

rxZremrangebylex

public io.reactivex.rxjava3.core.Maybe<Response> rxZremrangebylex(String arg0,
                                                                  String arg1,
                                                                  String arg2)

Redis command ZREMRANGEBYLEX.

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

zremrangebyrank

public io.reactivex.rxjava3.core.Maybe<Response> zremrangebyrank(String arg0,
                                                                 String arg1,
                                                                 String arg2)

Redis command ZREMRANGEBYRANK.

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

rxZremrangebyrank

public io.reactivex.rxjava3.core.Maybe<Response> rxZremrangebyrank(String arg0,
                                                                   String arg1,
                                                                   String arg2)

Redis command ZREMRANGEBYRANK.

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

zremrangebyscore

public io.reactivex.rxjava3.core.Maybe<Response> zremrangebyscore(String arg0,
                                                                  String arg1,
                                                                  String arg2)

Redis command ZREMRANGEBYSCORE.

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

rxZremrangebyscore

public io.reactivex.rxjava3.core.Maybe<Response> rxZremrangebyscore(String arg0,
                                                                    String arg1,
                                                                    String arg2)

Redis command ZREMRANGEBYSCORE.

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

zrevrange

public io.reactivex.rxjava3.core.Maybe<Response> zrevrange(List<String> args)

Redis command ZREVRANGE.

Parameters:: args -
Returns:: fluent self

rxZrevrange

public io.reactivex.rxjava3.core.Maybe<Response> rxZrevrange(List<String> args)