Package io.vertx.reactivex.redis.client

Class RedisAPI

java.lang.Object

io.vertx.reactivex.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(io.vertx.redis.client.RedisAPI delegate)
RedisAPI(Object delegate)

Method Summary

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

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

__TYPE_ARG

public static final TypeArg<RedisAPI> __TYPE_ARG

Constructor Detail

RedisAPI

public RedisAPI(io.vertx.redis.client.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 io.vertx.redis.client.RedisAPI getDelegate()

close

public void close()

ftAdd

public RedisAPI ftAdd(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.ADD.

Parameters:

args -

handler -

Returns:

fluent self

ftAdd

public RedisAPI ftAdd(List<String> args)

Redis command FT.ADD.

Parameters:

args -

Returns:

fluent self

rxFtAdd

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

Redis command FT.ADD.

Parameters:

args -

Returns:

fluent self

ftAggregate

public RedisAPI ftAggregate(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.AGGREGATE.

Parameters:

args -

handler -

Returns:

fluent self

ftAggregate

public RedisAPI ftAggregate(List<String> args)

Redis command FT.AGGREGATE.

Parameters:

args -

Returns:

fluent self

rxFtAggregate

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

Redis command FT.AGGREGATE.

Parameters:

args -

Returns:

fluent self

ftAliasadd

public RedisAPI ftAliasadd(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.ALIASADD.

Parameters:

args -

handler -

Returns:

fluent self

ftAliasadd

public RedisAPI ftAliasadd(List<String> args)

Redis command FT.ALIASADD.

Parameters:

args -

Returns:

fluent self

rxFtAliasadd

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

Redis command FT.ALIASADD.

Parameters:

args -

Returns:

fluent self

ftAliasdel

public RedisAPI ftAliasdel(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.ALIASDEL.

Parameters:

args -

handler -

Returns:

fluent self

ftAliasdel

public RedisAPI ftAliasdel(List<String> args)

Redis command FT.ALIASDEL.

Parameters:

args -

Returns:

fluent self

rxFtAliasdel

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

Redis command FT.ALIASDEL.

Parameters:

args -

Returns:

fluent self

ftAliasupdate

public RedisAPI ftAliasupdate(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.ALIASUPDATE.

Parameters:

args -

handler -

Returns:

fluent self

ftAliasupdate

public RedisAPI ftAliasupdate(List<String> args)

Redis command FT.ALIASUPDATE.

Parameters:

args -

Returns:

fluent self

rxFtAliasupdate

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

Redis command FT.ALIASUPDATE.

Parameters:

args -

Returns:

fluent self

ftAlter

public RedisAPI ftAlter(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.ALTER.

Parameters:

args -

handler -

Returns:

fluent self

ftAlter

public RedisAPI ftAlter(List<String> args)

Redis command FT.ALTER.

Parameters:

args -

Returns:

fluent self

rxFtAlter

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

Redis command FT.ALTER.

Parameters:

args -

Returns:

fluent self

ftConfig

public RedisAPI ftConfig(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.CONFIG.

Parameters:

args -

handler -

Returns:

fluent self

ftConfig

public RedisAPI ftConfig(List<String> args)

Redis command FT.CONFIG.

Parameters:

args -

Returns:

fluent self

rxFtConfig

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

Redis command FT.CONFIG.

Parameters:

args -

Returns:

fluent self

ftCreate

public RedisAPI ftCreate(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.CREATE.

Parameters:

args -

handler -

Returns:

fluent self

ftCreate

public RedisAPI ftCreate(List<String> args)

Redis command FT.CREATE.

Parameters:

args -

Returns:

fluent self

rxFtCreate

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

Redis command FT.CREATE.

Parameters:

args -

Returns:

fluent self

ftCursor

public RedisAPI ftCursor(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.CURSOR.

Parameters:

args -

handler -

Returns:

fluent self

ftCursor

public RedisAPI ftCursor(List<String> args)

Redis command FT.CURSOR.

Parameters:

args -

Returns:

fluent self

rxFtCursor

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

Redis command FT.CURSOR.

Parameters:

args -

Returns:

fluent self

ftDebug

public RedisAPI ftDebug(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.DEBUG.

Parameters:

args -

handler -

Returns:

fluent self

ftDebug

public RedisAPI ftDebug(List<String> args)

Redis command FT.DEBUG.

Parameters:

args -

Returns:

fluent self

rxFtDebug

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

Redis command FT.DEBUG.

Parameters:

args -

Returns:

fluent self

ftDel

public RedisAPI ftDel(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.DEL.

Parameters:

args -

handler -

Returns:

fluent self

ftDel

public RedisAPI ftDel(List<String> args)

Redis command FT.DEL.

Parameters:

args -

Returns:

fluent self

rxFtDel

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

Redis command FT.DEL.

Parameters:

args -

Returns:

fluent self

ftDictadd

public RedisAPI ftDictadd(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.DICTADD.

Parameters:

args -

handler -

Returns:

fluent self

ftDictadd

public RedisAPI ftDictadd(List<String> args)

Redis command FT.DICTADD.

Parameters:

args -

Returns:

fluent self

rxFtDictadd

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

Redis command FT.DICTADD.

Parameters:

args -

Returns:

fluent self

ftDictdel

public RedisAPI ftDictdel(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.DICTDEL.

Parameters:

args -

handler -

Returns:

fluent self

ftDictdel

public RedisAPI ftDictdel(List<String> args)

Redis command FT.DICTDEL.

Parameters:

args -

Returns:

fluent self

rxFtDictdel

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

Redis command FT.DICTDEL.

Parameters:

args -

Returns:

fluent self

ftDictdump

public RedisAPI ftDictdump(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.DICTDUMP.

Parameters:

args -

handler -

Returns:

fluent self

ftDictdump

public RedisAPI ftDictdump(List<String> args)

Redis command FT.DICTDUMP.

Parameters:

args -

Returns:

fluent self

rxFtDictdump

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

Redis command FT.DICTDUMP.

Parameters:

args -

Returns:

fluent self

ftDrop

public RedisAPI ftDrop(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.DROP.

Parameters:

args -

handler -

Returns:

fluent self

ftDrop

public RedisAPI ftDrop(List<String> args)

Redis command FT.DROP.

Parameters:

args -

Returns:

fluent self

rxFtDrop

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

Redis command FT.DROP.

Parameters:

args -

Returns:

fluent self

ftDropindex

public RedisAPI ftDropindex(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.DROPINDEX.

Parameters:

args -

handler -

Returns:

fluent self

ftDropindex

public RedisAPI ftDropindex(List<String> args)

Redis command FT.DROPINDEX.

Parameters:

args -

Returns:

fluent self

rxFtDropindex

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

Redis command FT.DROPINDEX.

Parameters:

args -

Returns:

fluent self

ftExplain

public RedisAPI ftExplain(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.EXPLAIN.

Parameters:

args -

handler -

Returns:

fluent self

ftExplain

public RedisAPI ftExplain(List<String> args)

Redis command FT.EXPLAIN.

Parameters:

args -

Returns:

fluent self

rxFtExplain

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

Redis command FT.EXPLAIN.

Parameters:

args -

Returns:

fluent self

ftExplaincli

public RedisAPI ftExplaincli(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.EXPLAINCLI.

Parameters:

args -

handler -

Returns:

fluent self

ftExplaincli

public RedisAPI ftExplaincli(List<String> args)

Redis command FT.EXPLAINCLI.

Parameters:

args -

Returns:

fluent self

rxFtExplaincli

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

Redis command FT.EXPLAINCLI.

Parameters:

args -

Returns:

fluent self

ftGet

public RedisAPI ftGet(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.GET.

Parameters:

args -

handler -

Returns:

fluent self

ftGet

public RedisAPI ftGet(List<String> args)

Redis command FT.GET.

Parameters:

args -

Returns:

fluent self

rxFtGet

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

Redis command FT.GET.

Parameters:

args -

Returns:

fluent self

ftInfo

public RedisAPI ftInfo(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.INFO.

Parameters:

args -

handler -

Returns:

fluent self

ftInfo

public RedisAPI ftInfo(List<String> args)

Redis command FT.INFO.

Parameters:

args -

Returns:

fluent self

rxFtInfo

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

Redis command FT.INFO.

Parameters:

args -

Returns:

fluent self

ftMget

public RedisAPI ftMget(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.MGET.

Parameters:

args -

handler -

Returns:

fluent self

ftMget

public RedisAPI ftMget(List<String> args)

Redis command FT.MGET.

Parameters:

args -

Returns:

fluent self

rxFtMget

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

Redis command FT.MGET.

Parameters:

args -

Returns:

fluent self

ftProfile

public RedisAPI ftProfile(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.PROFILE.

Parameters:

args -

handler -

Returns:

fluent self

ftProfile

public RedisAPI ftProfile(List<String> args)

Redis command FT.PROFILE.

Parameters:

args -

Returns:

fluent self

rxFtProfile

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

Redis command FT.PROFILE.

Parameters:

args -

Returns:

fluent self

ftSafeadd

public RedisAPI ftSafeadd(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.SAFEADD.

Parameters:

args -

handler -

Returns:

fluent self

ftSafeadd

public RedisAPI ftSafeadd(List<String> args)

Redis command FT.SAFEADD.

Parameters:

args -

Returns:

fluent self

rxFtSafeadd

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

Redis command FT.SAFEADD.

Parameters:

args -

Returns:

fluent self

ftSearch

public RedisAPI ftSearch(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.SEARCH.

Parameters:

args -

handler -

Returns:

fluent self

ftSearch

public RedisAPI ftSearch(List<String> args)

Redis command FT.SEARCH.

Parameters:

args -

Returns:

fluent self

rxFtSearch

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

Redis command FT.SEARCH.

Parameters:

args -

Returns:

fluent self

ftSpellcheck

public RedisAPI ftSpellcheck(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.SPELLCHECK.

Parameters:

args -

handler -

Returns:

fluent self

ftSpellcheck

public RedisAPI ftSpellcheck(List<String> args)

Redis command FT.SPELLCHECK.

Parameters:

args -

Returns:

fluent self

rxFtSpellcheck

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

Redis command FT.SPELLCHECK.

Parameters:

args -

Returns:

fluent self

ftSugadd

public RedisAPI ftSugadd(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.SUGADD.

Parameters:

args -

handler -

Returns:

fluent self

ftSugadd

public RedisAPI ftSugadd(List<String> args)

Redis command FT.SUGADD.

Parameters:

args -

Returns:

fluent self

rxFtSugadd

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

Redis command FT.SUGADD.

Parameters:

args -

Returns:

fluent self

ftSugdel

public RedisAPI ftSugdel(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.SUGDEL.

Parameters:

args -

handler -

Returns:

fluent self

ftSugdel

public RedisAPI ftSugdel(List<String> args)

Redis command FT.SUGDEL.

Parameters:

args -

Returns:

fluent self

rxFtSugdel

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

Redis command FT.SUGDEL.

Parameters:

args -

Returns:

fluent self

ftSugget

public RedisAPI ftSugget(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.SUGGET.

Parameters:

args -

handler -

Returns:

fluent self

ftSugget

public RedisAPI ftSugget(List<String> args)

Redis command FT.SUGGET.

Parameters:

args -

Returns:

fluent self

rxFtSugget

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

Redis command FT.SUGGET.

Parameters:

args -

Returns:

fluent self

ftSuglen

public RedisAPI ftSuglen(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.SUGLEN.

Parameters:

args -

handler -

Returns:

fluent self

ftSuglen

public RedisAPI ftSuglen(List<String> args)

Redis command FT.SUGLEN.

Parameters:

args -

Returns:

fluent self

rxFtSuglen

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

Redis command FT.SUGLEN.

Parameters:

args -

Returns:

fluent self

ftSynadd

public RedisAPI ftSynadd(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.SYNADD.

Parameters:

args -

handler -

Returns:

fluent self

ftSynadd

public RedisAPI ftSynadd(List<String> args)

Redis command FT.SYNADD.

Parameters:

args -

Returns:

fluent self

rxFtSynadd

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

Redis command FT.SYNADD.

Parameters:

args -

Returns:

fluent self

ftSyndump

public RedisAPI ftSyndump(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.SYNDUMP.

Parameters:

args -

handler -

Returns:

fluent self

ftSyndump

public RedisAPI ftSyndump(List<String> args)

Redis command FT.SYNDUMP.

Parameters:

args -

Returns:

fluent self

rxFtSyndump

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

Redis command FT.SYNDUMP.

Parameters:

args -

Returns:

fluent self

ftSynupdate

public RedisAPI ftSynupdate(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.SYNUPDATE.

Parameters:

args -

handler -

Returns:

fluent self

ftSynupdate

public RedisAPI ftSynupdate(List<String> args)

Redis command FT.SYNUPDATE.

Parameters:

args -

Returns:

fluent self

rxFtSynupdate

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

Redis command FT.SYNUPDATE.

Parameters:

args -

Returns:

fluent self

ftTagvals

public RedisAPI ftTagvals(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT.TAGVALS.

Parameters:

args -

handler -

Returns:

fluent self

ftTagvals

public RedisAPI ftTagvals(List<String> args)

Redis command FT.TAGVALS.

Parameters:

args -

Returns:

fluent self

rxFtTagvals

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

Redis command FT.TAGVALS.

Parameters:

args -

Returns:

fluent self

ftAliasaddifnx

public RedisAPI ftAliasaddifnx(List<String> args,
                               io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT._ALIASADDIFNX.

Parameters:

args -

handler -

Returns:

fluent self

ftAliasaddifnx

public RedisAPI ftAliasaddifnx(List<String> args)

Redis command FT._ALIASADDIFNX.

Parameters:

args -

Returns:

fluent self

rxFtAliasaddifnx

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

Redis command FT._ALIASADDIFNX.

Parameters:

args -

Returns:

fluent self

ftAliasdelifx

public RedisAPI ftAliasdelifx(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT._ALIASDELIFX.

Parameters:

args -

handler -

Returns:

fluent self

ftAliasdelifx

public RedisAPI ftAliasdelifx(List<String> args)

Redis command FT._ALIASDELIFX.

Parameters:

args -

Returns:

fluent self

rxFtAliasdelifx

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

Redis command FT._ALIASDELIFX.

Parameters:

args -

Returns:

fluent self

ftAlterifnx

public RedisAPI ftAlterifnx(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT._ALTERIFNX.

Parameters:

args -

handler -

Returns:

fluent self

ftAlterifnx

public RedisAPI ftAlterifnx(List<String> args)

Redis command FT._ALTERIFNX.

Parameters:

args -

Returns:

fluent self

rxFtAlterifnx

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

Redis command FT._ALTERIFNX.

Parameters:

args -

Returns:

fluent self

ftCreateifnx

public RedisAPI ftCreateifnx(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT._CREATEIFNX.

Parameters:

args -

handler -

Returns:

fluent self

ftCreateifnx

public RedisAPI ftCreateifnx(List<String> args)

Redis command FT._CREATEIFNX.

Parameters:

args -

Returns:

fluent self

rxFtCreateifnx

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

Redis command FT._CREATEIFNX.

Parameters:

args -

Returns:

fluent self

ftDropifx

public RedisAPI ftDropifx(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT._DROPIFX.

Parameters:

args -

handler -

Returns:

fluent self

ftDropifx

public RedisAPI ftDropifx(List<String> args)

Redis command FT._DROPIFX.

Parameters:

args -

Returns:

fluent self

rxFtDropifx

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

Redis command FT._DROPIFX.

Parameters:

args -

Returns:

fluent self

ftDropindexifx

public RedisAPI ftDropindexifx(List<String> args,
                               io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT._DROPINDEXIFX.

Parameters:

args -

handler -

Returns:

fluent self

ftDropindexifx

public RedisAPI ftDropindexifx(List<String> args)

Redis command FT._DROPINDEXIFX.

Parameters:

args -

Returns:

fluent self

rxFtDropindexifx

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

Redis command FT._DROPINDEXIFX.

Parameters:

args -

Returns:

fluent self

ftList

public RedisAPI ftList(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FT._LIST.

Parameters:

args -

handler -

Returns:

fluent self

ftList

public RedisAPI ftList(List<String> args)

Redis command FT._LIST.

Parameters:

args -

Returns:

fluent self

rxFtList

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

Redis command FT._LIST.

Parameters:

args -

Returns:

fluent self

acl

public RedisAPI acl(List<String> args,
                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ACL.

Parameters:

args -

handler -

Returns:

fluent self

acl

public RedisAPI acl(List<String> args)

Redis command ACL.

Parameters:

args -

Returns:

fluent self

rxAcl

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

Redis command ACL.

Parameters:

args -

Returns:

fluent self

append

public RedisAPI append(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command APPEND.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

append

public RedisAPI append(String arg0,
                       String arg1)

Redis command APPEND.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxAppend

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

Redis command APPEND.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

asking

public RedisAPI asking(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ASKING.

Parameters:

handler -

Returns:

fluent self

asking

public RedisAPI asking()

Redis command ASKING.

Returns:

fluent self

rxAsking

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

Redis command ASKING.

Returns:

fluent self

auth

public RedisAPI auth(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command AUTH.

Parameters:

args -

handler -

Returns:

fluent self

auth

public RedisAPI auth(List<String> args)

Redis command AUTH.

Parameters:

args -

Returns:

fluent self

rxAuth

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

Redis command AUTH.

Parameters:

args -

Returns:

fluent self

bfAdd

public RedisAPI bfAdd(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BF.ADD.

Parameters:

args -

handler -

Returns:

fluent self

bfAdd

public RedisAPI bfAdd(List<String> args)

Redis command BF.ADD.

Parameters:

args -

Returns:

fluent self

rxBfAdd

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

Redis command BF.ADD.

Parameters:

args -

Returns:

fluent self

bfCard

public RedisAPI bfCard(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BF.CARD.

Parameters:

args -

handler -

Returns:

fluent self

bfCard

public RedisAPI bfCard(List<String> args)

Redis command BF.CARD.

Parameters:

args -

Returns:

fluent self

rxBfCard

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

Redis command BF.CARD.

Parameters:

args -

Returns:

fluent self

bfDebug

public RedisAPI bfDebug(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BF.DEBUG.

Parameters:

args -

handler -

Returns:

fluent self

bfDebug

public RedisAPI bfDebug(List<String> args)

Redis command BF.DEBUG.

Parameters:

args -

Returns:

fluent self

rxBfDebug

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

Redis command BF.DEBUG.

Parameters:

args -

Returns:

fluent self

bfExists

public RedisAPI bfExists(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BF.EXISTS.

Parameters:

args -

handler -

Returns:

fluent self

bfExists

public RedisAPI bfExists(List<String> args)

Redis command BF.EXISTS.

Parameters:

args -

Returns:

fluent self

rxBfExists

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

Redis command BF.EXISTS.

Parameters:

args -

Returns:

fluent self

bfInfo

public RedisAPI bfInfo(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BF.INFO.

Parameters:

args -

handler -

Returns:

fluent self

bfInfo

public RedisAPI bfInfo(List<String> args)

Redis command BF.INFO.

Parameters:

args -

Returns:

fluent self

rxBfInfo

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

Redis command BF.INFO.

Parameters:

args -

Returns:

fluent self

bfInsert

public RedisAPI bfInsert(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BF.INSERT.

Parameters:

args -

handler -

Returns:

fluent self

bfInsert

public RedisAPI bfInsert(List<String> args)

Redis command BF.INSERT.

Parameters:

args -

Returns:

fluent self

rxBfInsert

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

Redis command BF.INSERT.

Parameters:

args -

Returns:

fluent self

bfLoadchunk

public RedisAPI bfLoadchunk(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BF.LOADCHUNK.

Parameters:

args -

handler -

Returns:

fluent self

bfLoadchunk

public RedisAPI bfLoadchunk(List<String> args)

Redis command BF.LOADCHUNK.

Parameters:

args -

Returns:

fluent self

rxBfLoadchunk

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

Redis command BF.LOADCHUNK.

Parameters:

args -

Returns:

fluent self

bfMadd

public RedisAPI bfMadd(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BF.MADD.

Parameters:

args -

handler -

Returns:

fluent self

bfMadd

public RedisAPI bfMadd(List<String> args)

Redis command BF.MADD.

Parameters:

args -

Returns:

fluent self

rxBfMadd

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

Redis command BF.MADD.

Parameters:

args -

Returns:

fluent self

bfMexists

public RedisAPI bfMexists(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BF.MEXISTS.

Parameters:

args -

handler -

Returns:

fluent self

bfMexists

public RedisAPI bfMexists(List<String> args)

Redis command BF.MEXISTS.

Parameters:

args -

Returns:

fluent self

rxBfMexists

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

Redis command BF.MEXISTS.

Parameters:

args -

Returns:

fluent self

bfReserve

public RedisAPI bfReserve(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BF.RESERVE.

Parameters:

args -

handler -

Returns:

fluent self

bfReserve

public RedisAPI bfReserve(List<String> args)

Redis command BF.RESERVE.

Parameters:

args -

Returns:

fluent self

rxBfReserve

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

Redis command BF.RESERVE.

Parameters:

args -

Returns:

fluent self

bfScandump

public RedisAPI bfScandump(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BF.SCANDUMP.

Parameters:

args -

handler -

Returns:

fluent self

bfScandump

public RedisAPI bfScandump(List<String> args)

Redis command BF.SCANDUMP.

Parameters:

args -

Returns:

fluent self

rxBfScandump

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

Redis command BF.SCANDUMP.

Parameters:

args -

Returns:

fluent self

bgrewriteaof

public RedisAPI bgrewriteaof(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BGREWRITEAOF.

Parameters:

handler -

Returns:

fluent self

bgrewriteaof

public RedisAPI bgrewriteaof()

Redis command BGREWRITEAOF.

Returns:

fluent self

rxBgrewriteaof

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

Redis command BGREWRITEAOF.

Returns:

fluent self

bgsave

public RedisAPI bgsave(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BGSAVE.

Parameters:

args -

handler -

Returns:

fluent self

bgsave

public RedisAPI bgsave(List<String> args)

Redis command BGSAVE.

Parameters:

args -

Returns:

fluent self

rxBgsave

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

Redis command BGSAVE.

Parameters:

args -

Returns:

fluent self

bitcount

public RedisAPI bitcount(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BITCOUNT.

Parameters:

args -

handler -

Returns:

fluent self

bitcount

public RedisAPI bitcount(List<String> args)

Redis command BITCOUNT.

Parameters:

args -

Returns:

fluent self

rxBitcount

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

Redis command BITCOUNT.

Parameters:

args -

Returns:

fluent self

bitfield

public RedisAPI bitfield(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BITFIELD.

Parameters:

args -

handler -

Returns:

fluent self

bitfield

public RedisAPI bitfield(List<String> args)

Redis command BITFIELD.

Parameters:

args -

Returns:

fluent self

rxBitfield

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

Redis command BITFIELD.

Parameters:

args -

Returns:

fluent self

bitfieldRo

public RedisAPI bitfieldRo(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BITFIELD_RO.

Parameters:

args -

handler -

Returns:

fluent self

bitfieldRo

public RedisAPI bitfieldRo(List<String> args)

Redis command BITFIELD_RO.

Parameters:

args -

Returns:

fluent self

rxBitfieldRo

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

Redis command BITFIELD_RO.

Parameters:

args -

Returns:

fluent self

bitop

public RedisAPI bitop(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BITOP.

Parameters:

args -

handler -

Returns:

fluent self

bitop

public RedisAPI bitop(List<String> args)

Redis command BITOP.

Parameters:

args -

Returns:

fluent self

rxBitop

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

Redis command BITOP.

Parameters:

args -

Returns:

fluent self

bitpos

public RedisAPI bitpos(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BITPOS.

Parameters:

args -

handler -

Returns:

fluent self

bitpos

public RedisAPI bitpos(List<String> args)

Redis command BITPOS.

Parameters:

args -

Returns:

fluent self

rxBitpos

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

Redis command BITPOS.

Parameters:

args -

Returns:

fluent self

blmove

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

Redis command BLMOVE.

Parameters:

arg0 -

arg1 -

arg2 -

arg3 -

arg4 -

handler -

Returns:

fluent self

blmove

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

Redis command BLMOVE.

Parameters:

arg0 -

arg1 -

arg2 -

arg3 -

arg4 -

Returns:

fluent self

rxBlmove

public io.reactivex.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 RedisAPI blmpop(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BLMPOP.

Parameters:

args -

handler -

Returns:

fluent self

blmpop

public RedisAPI blmpop(List<String> args)

Redis command BLMPOP.

Parameters:

args -

Returns:

fluent self

rxBlmpop

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

Redis command BLMPOP.

Parameters:

args -

Returns:

fluent self

blpop

public RedisAPI blpop(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BLPOP.

Parameters:

args -

handler -

Returns:

fluent self

blpop

public RedisAPI blpop(List<String> args)

Redis command BLPOP.

Parameters:

args -

Returns:

fluent self

rxBlpop

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

Redis command BLPOP.

Parameters:

args -

Returns:

fluent self

brpop

public RedisAPI brpop(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BRPOP.

Parameters:

args -

handler -

Returns:

fluent self

brpop

public RedisAPI brpop(List<String> args)

Redis command BRPOP.

Parameters:

args -

Returns:

fluent self

rxBrpop

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

Redis command BRPOP.

Parameters:

args -

Returns:

fluent self

brpoplpush

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

Redis command BRPOPLPUSH.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

brpoplpush

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

Redis command BRPOPLPUSH.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxBrpoplpush

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

Redis command BRPOPLPUSH.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

bzmpop

public RedisAPI bzmpop(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BZMPOP.

Parameters:

args -

handler -

Returns:

fluent self

bzmpop

public RedisAPI bzmpop(List<String> args)

Redis command BZMPOP.

Parameters:

args -

Returns:

fluent self

rxBzmpop

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

Redis command BZMPOP.

Parameters:

args -

Returns:

fluent self

bzpopmax

public RedisAPI bzpopmax(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BZPOPMAX.

Parameters:

args -

handler -

Returns:

fluent self

bzpopmax

public RedisAPI bzpopmax(List<String> args)

Redis command BZPOPMAX.

Parameters:

args -

Returns:

fluent self

rxBzpopmax

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

Redis command BZPOPMAX.

Parameters:

args -

Returns:

fluent self

bzpopmin

public RedisAPI bzpopmin(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command BZPOPMIN.

Parameters:

args -

handler -

Returns:

fluent self

bzpopmin

public RedisAPI bzpopmin(List<String> args)

Redis command BZPOPMIN.

Parameters:

args -

Returns:

fluent self

rxBzpopmin

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

Redis command BZPOPMIN.

Parameters:

args -

Returns:

fluent self

cfAdd

public RedisAPI cfAdd(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.ADD.

Parameters:

args -

handler -

Returns:

fluent self

cfAdd

public RedisAPI cfAdd(List<String> args)

Redis command CF.ADD.

Parameters:

args -

Returns:

fluent self

rxCfAdd

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

Redis command CF.ADD.

Parameters:

args -

Returns:

fluent self

cfAddnx

public RedisAPI cfAddnx(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.ADDNX.

Parameters:

args -

handler -

Returns:

fluent self

cfAddnx

public RedisAPI cfAddnx(List<String> args)

Redis command CF.ADDNX.

Parameters:

args -

Returns:

fluent self

rxCfAddnx

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

Redis command CF.ADDNX.

Parameters:

args -

Returns:

fluent self

cfCompact

public RedisAPI cfCompact(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.COMPACT.

Parameters:

args -

handler -

Returns:

fluent self

cfCompact

public RedisAPI cfCompact(List<String> args)

Redis command CF.COMPACT.

Parameters:

args -

Returns:

fluent self

rxCfCompact

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

Redis command CF.COMPACT.

Parameters:

args -

Returns:

fluent self

cfCount

public RedisAPI cfCount(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.COUNT.

Parameters:

args -

handler -

Returns:

fluent self

cfCount

public RedisAPI cfCount(List<String> args)

Redis command CF.COUNT.

Parameters:

args -

Returns:

fluent self

rxCfCount

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

Redis command CF.COUNT.

Parameters:

args -

Returns:

fluent self

cfDebug

public RedisAPI cfDebug(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.DEBUG.

Parameters:

args -

handler -

Returns:

fluent self

cfDebug

public RedisAPI cfDebug(List<String> args)

Redis command CF.DEBUG.

Parameters:

args -

Returns:

fluent self

rxCfDebug

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

Redis command CF.DEBUG.

Parameters:

args -

Returns:

fluent self

cfDel

public RedisAPI cfDel(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.DEL.

Parameters:

args -

handler -

Returns:

fluent self

cfDel

public RedisAPI cfDel(List<String> args)

Redis command CF.DEL.

Parameters:

args -

Returns:

fluent self

rxCfDel

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

Redis command CF.DEL.

Parameters:

args -

Returns:

fluent self

cfExists

public RedisAPI cfExists(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.EXISTS.

Parameters:

args -

handler -

Returns:

fluent self

cfExists

public RedisAPI cfExists(List<String> args)

Redis command CF.EXISTS.

Parameters:

args -

Returns:

fluent self

rxCfExists

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

Redis command CF.EXISTS.

Parameters:

args -

Returns:

fluent self

cfInfo

public RedisAPI cfInfo(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.INFO.

Parameters:

args -

handler -

Returns:

fluent self

cfInfo

public RedisAPI cfInfo(List<String> args)

Redis command CF.INFO.

Parameters:

args -

Returns:

fluent self

rxCfInfo

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

Redis command CF.INFO.

Parameters:

args -

Returns:

fluent self

cfInsert

public RedisAPI cfInsert(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.INSERT.

Parameters:

args -

handler -

Returns:

fluent self

cfInsert

public RedisAPI cfInsert(List<String> args)

Redis command CF.INSERT.

Parameters:

args -

Returns:

fluent self

rxCfInsert

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

Redis command CF.INSERT.

Parameters:

args -

Returns:

fluent self

cfInsertnx

public RedisAPI cfInsertnx(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.INSERTNX.

Parameters:

args -

handler -

Returns:

fluent self

cfInsertnx

public RedisAPI cfInsertnx(List<String> args)

Redis command CF.INSERTNX.

Parameters:

args -

Returns:

fluent self

rxCfInsertnx

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

Redis command CF.INSERTNX.

Parameters:

args -

Returns:

fluent self

cfLoadchunk

public RedisAPI cfLoadchunk(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.LOADCHUNK.

Parameters:

args -

handler -

Returns:

fluent self

cfLoadchunk

public RedisAPI cfLoadchunk(List<String> args)

Redis command CF.LOADCHUNK.

Parameters:

args -

Returns:

fluent self

rxCfLoadchunk

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

Redis command CF.LOADCHUNK.

Parameters:

args -

Returns:

fluent self

cfMexists

public RedisAPI cfMexists(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.MEXISTS.

Parameters:

args -

handler -

Returns:

fluent self

cfMexists

public RedisAPI cfMexists(List<String> args)

Redis command CF.MEXISTS.

Parameters:

args -

Returns:

fluent self

rxCfMexists

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

Redis command CF.MEXISTS.

Parameters:

args -

Returns:

fluent self

cfReserve

public RedisAPI cfReserve(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.RESERVE.

Parameters:

args -

handler -

Returns:

fluent self

cfReserve

public RedisAPI cfReserve(List<String> args)

Redis command CF.RESERVE.

Parameters:

args -

Returns:

fluent self

rxCfReserve

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

Redis command CF.RESERVE.

Parameters:

args -

Returns:

fluent self

cfScandump

public RedisAPI cfScandump(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CF.SCANDUMP.

Parameters:

args -

handler -

Returns:

fluent self

cfScandump

public RedisAPI cfScandump(List<String> args)

Redis command CF.SCANDUMP.

Parameters:

args -

Returns:

fluent self

rxCfScandump

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

Redis command CF.SCANDUMP.

Parameters:

args -

Returns:

fluent self

client

public RedisAPI client(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CLIENT.

Parameters:

args -

handler -

Returns:

fluent self

client

public RedisAPI client(List<String> args)

Redis command CLIENT.

Parameters:

args -

Returns:

fluent self

rxClient

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

Redis command CLIENT.

Parameters:

args -

Returns:

fluent self

cluster

public RedisAPI cluster(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CLUSTER.

Parameters:

args -

handler -

Returns:

fluent self

cluster

public RedisAPI cluster(List<String> args)

Redis command CLUSTER.

Parameters:

args -

Returns:

fluent self

rxCluster

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

Redis command CLUSTER.

Parameters:

args -

Returns:

fluent self

cmsIncrby

public RedisAPI cmsIncrby(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CMS.INCRBY.

Parameters:

args -

handler -

Returns:

fluent self

cmsIncrby

public RedisAPI cmsIncrby(List<String> args)

Redis command CMS.INCRBY.

Parameters:

args -

Returns:

fluent self

rxCmsIncrby

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

Redis command CMS.INCRBY.

Parameters:

args -

Returns:

fluent self

cmsInfo

public RedisAPI cmsInfo(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CMS.INFO.

Parameters:

args -

handler -

Returns:

fluent self

cmsInfo

public RedisAPI cmsInfo(List<String> args)

Redis command CMS.INFO.

Parameters:

args -

Returns:

fluent self

rxCmsInfo

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

Redis command CMS.INFO.

Parameters:

args -

Returns:

fluent self

cmsInitbydim

public RedisAPI cmsInitbydim(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CMS.INITBYDIM.

Parameters:

args -

handler -

Returns:

fluent self

cmsInitbydim

public RedisAPI cmsInitbydim(List<String> args)

Redis command CMS.INITBYDIM.

Parameters:

args -

Returns:

fluent self

rxCmsInitbydim

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

Redis command CMS.INITBYDIM.

Parameters:

args -

Returns:

fluent self

cmsInitbyprob

public RedisAPI cmsInitbyprob(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CMS.INITBYPROB.

Parameters:

args -

handler -

Returns:

fluent self

cmsInitbyprob

public RedisAPI cmsInitbyprob(List<String> args)

Redis command CMS.INITBYPROB.

Parameters:

args -

Returns:

fluent self

rxCmsInitbyprob

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

Redis command CMS.INITBYPROB.

Parameters:

args -

Returns:

fluent self

cmsMerge

public RedisAPI cmsMerge(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CMS.MERGE.

Parameters:

args -

handler -

Returns:

fluent self

cmsMerge

public RedisAPI cmsMerge(List<String> args)

Redis command CMS.MERGE.

Parameters:

args -

Returns:

fluent self

rxCmsMerge

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

Redis command CMS.MERGE.

Parameters:

args -

Returns:

fluent self

cmsQuery

public RedisAPI cmsQuery(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CMS.QUERY.

Parameters:

args -

handler -

Returns:

fluent self

cmsQuery

public RedisAPI cmsQuery(List<String> args)

Redis command CMS.QUERY.

Parameters:

args -

Returns:

fluent self

rxCmsQuery

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

Redis command CMS.QUERY.

Parameters:

args -

Returns:

fluent self

command

public RedisAPI command(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command COMMAND.

Parameters:

args -

handler -

Returns:

fluent self

command

public RedisAPI command(List<String> args)

Redis command COMMAND.

Parameters:

args -

Returns:

fluent self

rxCommand

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

Redis command COMMAND.

Parameters:

args -

Returns:

fluent self

config

public RedisAPI config(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command CONFIG.

Parameters:

args -

handler -

Returns:

fluent self

config

public RedisAPI config(List<String> args)

Redis command CONFIG.

Parameters:

args -

Returns:

fluent self

rxConfig

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

Redis command CONFIG.

Parameters:

args -

Returns:

fluent self

copy

public RedisAPI copy(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command COPY.

Parameters:

args -

handler -

Returns:

fluent self

copy

public RedisAPI copy(List<String> args)

Redis command COPY.

Parameters:

args -

Returns:

fluent self

rxCopy

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

Redis command COPY.

Parameters:

args -

Returns:

fluent self

dbsize

public RedisAPI dbsize(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command DBSIZE.

Parameters:

handler -

Returns:

fluent self

dbsize

public RedisAPI dbsize()

Redis command DBSIZE.

Returns:

fluent self

rxDbsize

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

Redis command DBSIZE.

Returns:

fluent self

debug

public RedisAPI debug(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command DEBUG.

Parameters:

args -

handler -

Returns:

fluent self

debug

public RedisAPI debug(List<String> args)

Redis command DEBUG.

Parameters:

args -

Returns:

fluent self

rxDebug

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

Redis command DEBUG.

Parameters:

args -

Returns:

fluent self

decr

public RedisAPI decr(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command DECR.

Parameters:

arg0 -

handler -

Returns:

fluent self

decr

public RedisAPI decr(String arg0)

Redis command DECR.

Parameters:

arg0 -

Returns:

fluent self

rxDecr

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

Redis command DECR.

Parameters:

arg0 -

Returns:

fluent self

decrby

public RedisAPI decrby(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command DECRBY.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

decrby

public RedisAPI decrby(String arg0,
                       String arg1)

Redis command DECRBY.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxDecrby

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

Redis command DECRBY.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

del

public RedisAPI del(List<String> args,
                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command DEL.

Parameters:

args -

handler -

Returns:

fluent self

del

public RedisAPI del(List<String> args)

Redis command DEL.

Parameters:

args -

Returns:

fluent self

rxDel

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

Redis command DEL.

Parameters:

args -

Returns:

fluent self

discard

public RedisAPI discard(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command DISCARD.

Parameters:

handler -

Returns:

fluent self

discard

public RedisAPI discard()

Redis command DISCARD.

Returns:

fluent self

rxDiscard

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

Redis command DISCARD.

Returns:

fluent self

dump

public RedisAPI dump(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command DUMP.

Parameters:

arg0 -

handler -

Returns:

fluent self

dump

public RedisAPI dump(String arg0)

Redis command DUMP.

Parameters:

arg0 -

Returns:

fluent self

rxDump

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

Redis command DUMP.

Parameters:

arg0 -

Returns:

fluent self

echo

public RedisAPI echo(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ECHO.

Parameters:

arg0 -

handler -

Returns:

fluent self

echo

public RedisAPI echo(String arg0)

Redis command ECHO.

Parameters:

arg0 -

Returns:

fluent self

rxEcho

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

Redis command ECHO.

Parameters:

arg0 -

Returns:

fluent self

eval

public RedisAPI eval(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command EVAL.

Parameters:

args -

handler -

Returns:

fluent self

eval

public RedisAPI eval(List<String> args)

Redis command EVAL.

Parameters:

args -

Returns:

fluent self

rxEval

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

Redis command EVAL.

Parameters:

args -

Returns:

fluent self

evalRo

public RedisAPI evalRo(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command EVAL_RO.

Parameters:

args -

handler -

Returns:

fluent self

evalRo

public RedisAPI evalRo(List<String> args)

Redis command EVAL_RO.

Parameters:

args -

Returns:

fluent self

rxEvalRo

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

Redis command EVAL_RO.

Parameters:

args -

Returns:

fluent self

evalsha

public RedisAPI evalsha(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command EVALSHA.

Parameters:

args -

handler -

Returns:

fluent self

evalsha

public RedisAPI evalsha(List<String> args)

Redis command EVALSHA.

Parameters:

args -

Returns:

fluent self

rxEvalsha

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

Redis command EVALSHA.

Parameters:

args -

Returns:

fluent self

evalshaRo

public RedisAPI evalshaRo(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command EVALSHA_RO.

Parameters:

args -

handler -

Returns:

fluent self

evalshaRo

public RedisAPI evalshaRo(List<String> args)

Redis command EVALSHA_RO.

Parameters:

args -

Returns:

fluent self

rxEvalshaRo

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

Redis command EVALSHA_RO.

Parameters:

args -

Returns:

fluent self

exec

public RedisAPI exec(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command EXEC.

Parameters:

handler -

Returns:

fluent self

exec

public RedisAPI exec()

Redis command EXEC.

Returns:

fluent self

rxExec

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

Redis command EXEC.

Returns:

fluent self

exists

public RedisAPI exists(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command EXISTS.

Parameters:

args -

handler -

Returns:

fluent self

exists

public RedisAPI exists(List<String> args)

Redis command EXISTS.

Parameters:

args -

Returns:

fluent self

rxExists

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

Redis command EXISTS.

Parameters:

args -

Returns:

fluent self

expire

public RedisAPI expire(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command EXPIRE.

Parameters:

args -

handler -

Returns:

fluent self

expire

public RedisAPI expire(List<String> args)

Redis command EXPIRE.

Parameters:

args -

Returns:

fluent self

rxExpire

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

Redis command EXPIRE.

Parameters:

args -

Returns:

fluent self

expireat

public RedisAPI expireat(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command EXPIREAT.

Parameters:

args -

handler -

Returns:

fluent self

expireat

public RedisAPI expireat(List<String> args)

Redis command EXPIREAT.

Parameters:

args -

Returns:

fluent self

rxExpireat

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

Redis command EXPIREAT.

Parameters:

args -

Returns:

fluent self

expiretime

public RedisAPI expiretime(String arg0,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command EXPIRETIME.

Parameters:

arg0 -

handler -

Returns:

fluent self

expiretime

public RedisAPI expiretime(String arg0)

Redis command EXPIRETIME.

Parameters:

arg0 -

Returns:

fluent self

rxExpiretime

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

Redis command EXPIRETIME.

Parameters:

arg0 -

Returns:

fluent self

failover

public RedisAPI failover(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FAILOVER.

Parameters:

args -

handler -

Returns:

fluent self

failover

public RedisAPI failover(List<String> args)

Redis command FAILOVER.

Parameters:

args -

Returns:

fluent self

rxFailover

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

Redis command FAILOVER.

Parameters:

args -

Returns:

fluent self

fcall

public RedisAPI fcall(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FCALL.

Parameters:

args -

handler -

Returns:

fluent self

fcall

public RedisAPI fcall(List<String> args)

Redis command FCALL.

Parameters:

args -

Returns:

fluent self

rxFcall

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

Redis command FCALL.

Parameters:

args -

Returns:

fluent self

fcallRo

public RedisAPI fcallRo(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FCALL_RO.

Parameters:

args -

handler -

Returns:

fluent self

fcallRo

public RedisAPI fcallRo(List<String> args)

Redis command FCALL_RO.

Parameters:

args -

Returns:

fluent self

rxFcallRo

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

Redis command FCALL_RO.

Parameters:

args -

Returns:

fluent self

flushall

public RedisAPI flushall(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FLUSHALL.

Parameters:

args -

handler -

Returns:

fluent self

flushall

public RedisAPI flushall(List<String> args)

Redis command FLUSHALL.

Parameters:

args -

Returns:

fluent self

rxFlushall

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

Redis command FLUSHALL.

Parameters:

args -

Returns:

fluent self

flushdb

public RedisAPI flushdb(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FLUSHDB.

Parameters:

args -

handler -

Returns:

fluent self

flushdb

public RedisAPI flushdb(List<String> args)

Redis command FLUSHDB.

Parameters:

args -

Returns:

fluent self

rxFlushdb

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

Redis command FLUSHDB.

Parameters:

args -

Returns:

fluent self

function

public RedisAPI function(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command FUNCTION.

Parameters:

args -

handler -

Returns:

fluent self

function

public RedisAPI function(List<String> args)

Redis command FUNCTION.

Parameters:

args -

Returns:

fluent self

rxFunction

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

Redis command FUNCTION.

Parameters:

args -

Returns:

fluent self

geoadd

public RedisAPI geoadd(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GEOADD.

Parameters:

args -

handler -

Returns:

fluent self

geoadd

public RedisAPI geoadd(List<String> args)

Redis command GEOADD.

Parameters:

args -

Returns:

fluent self

rxGeoadd

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

Redis command GEOADD.

Parameters:

args -

Returns:

fluent self

geodist

public RedisAPI geodist(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GEODIST.

Parameters:

args -

handler -

Returns:

fluent self

geodist

public RedisAPI geodist(List<String> args)

Redis command GEODIST.

Parameters:

args -

Returns:

fluent self

rxGeodist

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

Redis command GEODIST.

Parameters:

args -

Returns:

fluent self

geohash

public RedisAPI geohash(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GEOHASH.

Parameters:

args -

handler -

Returns:

fluent self

geohash

public RedisAPI geohash(List<String> args)

Redis command GEOHASH.

Parameters:

args -

Returns:

fluent self

rxGeohash

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

Redis command GEOHASH.

Parameters:

args -

Returns:

fluent self

geopos

public RedisAPI geopos(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GEOPOS.

Parameters:

args -

handler -

Returns:

fluent self

geopos

public RedisAPI geopos(List<String> args)

Redis command GEOPOS.

Parameters:

args -

Returns:

fluent self

rxGeopos

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

Redis command GEOPOS.

Parameters:

args -

Returns:

fluent self

georadius

public RedisAPI georadius(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GEORADIUS.

Parameters:

args -

handler -

Returns:

fluent self

georadius

public RedisAPI georadius(List<String> args)

Redis command GEORADIUS.

Parameters:

args -

Returns:

fluent self

rxGeoradius

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

Redis command GEORADIUS.

Parameters:

args -

Returns:

fluent self

georadiusRo

public RedisAPI georadiusRo(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GEORADIUS_RO.

Parameters:

args -

handler -

Returns:

fluent self

georadiusRo

public RedisAPI georadiusRo(List<String> args)

Redis command GEORADIUS_RO.

Parameters:

args -

Returns:

fluent self

rxGeoradiusRo

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

Redis command GEORADIUS_RO.

Parameters:

args -

Returns:

fluent self

georadiusbymember

public RedisAPI georadiusbymember(List<String> args,
                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GEORADIUSBYMEMBER.

Parameters:

args -

handler -

Returns:

fluent self

georadiusbymember

public RedisAPI georadiusbymember(List<String> args)

Redis command GEORADIUSBYMEMBER.

Parameters:

args -

Returns:

fluent self

rxGeoradiusbymember

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

Redis command GEORADIUSBYMEMBER.

Parameters:

args -

Returns:

fluent self

georadiusbymemberRo

public RedisAPI georadiusbymemberRo(List<String> args,
                                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GEORADIUSBYMEMBER_RO.

Parameters:

args -

handler -

Returns:

fluent self

georadiusbymemberRo

public RedisAPI georadiusbymemberRo(List<String> args)

Redis command GEORADIUSBYMEMBER_RO.

Parameters:

args -

Returns:

fluent self

rxGeoradiusbymemberRo

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

Redis command GEORADIUSBYMEMBER_RO.

Parameters:

args -

Returns:

fluent self

geosearch

public RedisAPI geosearch(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GEOSEARCH.

Parameters:

args -

handler -

Returns:

fluent self

geosearch

public RedisAPI geosearch(List<String> args)

Redis command GEOSEARCH.

Parameters:

args -

Returns:

fluent self

rxGeosearch

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

Redis command GEOSEARCH.

Parameters:

args -

Returns:

fluent self

geosearchstore

public RedisAPI geosearchstore(List<String> args,
                               io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GEOSEARCHSTORE.

Parameters:

args -

handler -

Returns:

fluent self

geosearchstore

public RedisAPI geosearchstore(List<String> args)

Redis command GEOSEARCHSTORE.

Parameters:

args -

Returns:

fluent self

rxGeosearchstore

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

Redis command GEOSEARCHSTORE.

Parameters:

args -

Returns:

fluent self

get

public RedisAPI get(String arg0,
                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GET.

Parameters:

arg0 -

handler -

Returns:

fluent self

get

public RedisAPI get(String arg0)

Redis command GET.

Parameters:

arg0 -

Returns:

fluent self

rxGet

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

Redis command GET.

Parameters:

arg0 -

Returns:

fluent self

getbit

public RedisAPI getbit(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GETBIT.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

getbit

public RedisAPI getbit(String arg0,
                       String arg1)

Redis command GETBIT.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxGetbit

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

Redis command GETBIT.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

getdel

public RedisAPI getdel(String arg0,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GETDEL.

Parameters:

arg0 -

handler -

Returns:

fluent self

getdel

public RedisAPI getdel(String arg0)

Redis command GETDEL.

Parameters:

arg0 -

Returns:

fluent self

rxGetdel

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

Redis command GETDEL.

Parameters:

arg0 -

Returns:

fluent self

getex

public RedisAPI getex(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GETEX.

Parameters:

args -

handler -

Returns:

fluent self

getex

public RedisAPI getex(List<String> args)

Redis command GETEX.

Parameters:

args -

Returns:

fluent self

rxGetex

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

Redis command GETEX.

Parameters:

args -

Returns:

fluent self

getrange

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

Redis command GETRANGE.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

getrange

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

Redis command GETRANGE.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxGetrange

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

Redis command GETRANGE.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

getset

public RedisAPI getset(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GETSET.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

getset

public RedisAPI getset(String arg0,
                       String arg1)

Redis command GETSET.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxGetset

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

Redis command GETSET.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

graphBulk

public RedisAPI graphBulk(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GRAPH.BULK.

Parameters:

args -

handler -

Returns:

fluent self

graphBulk

public RedisAPI graphBulk(List<String> args)

Redis command GRAPH.BULK.

Parameters:

args -

Returns:

fluent self

rxGraphBulk

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

Redis command GRAPH.BULK.

Parameters:

args -

Returns:

fluent self

graphConfig

public RedisAPI graphConfig(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GRAPH.CONFIG.

Parameters:

args -

handler -

Returns:

fluent self

graphConfig

public RedisAPI graphConfig(List<String> args)

Redis command GRAPH.CONFIG.

Parameters:

args -

Returns:

fluent self

rxGraphConfig

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

Redis command GRAPH.CONFIG.

Parameters:

args -

Returns:

fluent self

graphDebug

public RedisAPI graphDebug(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GRAPH.DEBUG.

Parameters:

args -

handler -

Returns:

fluent self

graphDebug

public RedisAPI graphDebug(List<String> args)

Redis command GRAPH.DEBUG.

Parameters:

args -

Returns:

fluent self

rxGraphDebug

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

Redis command GRAPH.DEBUG.

Parameters:

args -

Returns:

fluent self

graphDelete

public RedisAPI graphDelete(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GRAPH.DELETE.

Parameters:

args -

handler -

Returns:

fluent self

graphDelete

public RedisAPI graphDelete(List<String> args)

Redis command GRAPH.DELETE.

Parameters:

args -

Returns:

fluent self

rxGraphDelete

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

Redis command GRAPH.DELETE.

Parameters:

args -

Returns:

fluent self

graphExplain

public RedisAPI graphExplain(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GRAPH.EXPLAIN.

Parameters:

args -

handler -

Returns:

fluent self

graphExplain

public RedisAPI graphExplain(List<String> args)

Redis command GRAPH.EXPLAIN.

Parameters:

args -

Returns:

fluent self

rxGraphExplain

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

Redis command GRAPH.EXPLAIN.

Parameters:

args -

Returns:

fluent self

graphList

public RedisAPI graphList(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GRAPH.LIST.

Parameters:

args -

handler -

Returns:

fluent self

graphList

public RedisAPI graphList(List<String> args)

Redis command GRAPH.LIST.

Parameters:

args -

Returns:

fluent self

rxGraphList

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

Redis command GRAPH.LIST.

Parameters:

args -

Returns:

fluent self

graphProfile

public RedisAPI graphProfile(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GRAPH.PROFILE.

Parameters:

args -

handler -

Returns:

fluent self

graphProfile

public RedisAPI graphProfile(List<String> args)

Redis command GRAPH.PROFILE.

Parameters:

args -

Returns:

fluent self

rxGraphProfile

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

Redis command GRAPH.PROFILE.

Parameters:

args -

Returns:

fluent self

graphQuery

public RedisAPI graphQuery(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GRAPH.QUERY.

Parameters:

args -

handler -

Returns:

fluent self

graphQuery

public RedisAPI graphQuery(List<String> args)

Redis command GRAPH.QUERY.

Parameters:

args -

Returns:

fluent self

rxGraphQuery

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

Redis command GRAPH.QUERY.

Parameters:

args -

Returns:

fluent self

graphRoQuery

public RedisAPI graphRoQuery(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GRAPH.RO_QUERY.

Parameters:

args -

handler -

Returns:

fluent self

graphRoQuery

public RedisAPI graphRoQuery(List<String> args)

Redis command GRAPH.RO_QUERY.

Parameters:

args -

Returns:

fluent self

rxGraphRoQuery

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

Redis command GRAPH.RO_QUERY.

Parameters:

args -

Returns:

fluent self

graphSlowlog

public RedisAPI graphSlowlog(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command GRAPH.SLOWLOG.

Parameters:

args -

handler -

Returns:

fluent self

graphSlowlog

public RedisAPI graphSlowlog(List<String> args)

Redis command GRAPH.SLOWLOG.

Parameters:

args -

Returns:

fluent self

rxGraphSlowlog

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

Redis command GRAPH.SLOWLOG.

Parameters:

args -

Returns:

fluent self

hdel

public RedisAPI hdel(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HDEL.

Parameters:

args -

handler -

Returns:

fluent self

hdel

public RedisAPI hdel(List<String> args)

Redis command HDEL.

Parameters:

args -

Returns:

fluent self

rxHdel

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

Redis command HDEL.

Parameters:

args -

Returns:

fluent self

hello

public RedisAPI hello(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HELLO.

Parameters:

args -

handler -

Returns:

fluent self

hello

public RedisAPI hello(List<String> args)

Redis command HELLO.

Parameters:

args -

Returns:

fluent self

rxHello

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

Redis command HELLO.

Parameters:

args -

Returns:

fluent self

hexists

public RedisAPI hexists(String arg0,
                        String arg1,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HEXISTS.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

hexists

public RedisAPI hexists(String arg0,
                        String arg1)

Redis command HEXISTS.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxHexists

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

Redis command HEXISTS.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

hget

public RedisAPI hget(String arg0,
                     String arg1,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HGET.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

hget

public RedisAPI hget(String arg0,
                     String arg1)

Redis command HGET.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxHget

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

Redis command HGET.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

hgetall

public RedisAPI hgetall(String arg0,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HGETALL.

Parameters:

arg0 -

handler -

Returns:

fluent self

hgetall

public RedisAPI hgetall(String arg0)

Redis command HGETALL.

Parameters:

arg0 -

Returns:

fluent self

rxHgetall

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

Redis command HGETALL.

Parameters:

arg0 -

Returns:

fluent self

hincrby

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

Redis command HINCRBY.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

hincrby

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

Redis command HINCRBY.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxHincrby

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

Redis command HINCRBY.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

hincrbyfloat

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

Redis command HINCRBYFLOAT.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

hincrbyfloat

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

Redis command HINCRBYFLOAT.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxHincrbyfloat

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

Redis command HINCRBYFLOAT.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

hkeys

public RedisAPI hkeys(String arg0,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HKEYS.

Parameters:

arg0 -

handler -

Returns:

fluent self

hkeys

public RedisAPI hkeys(String arg0)

Redis command HKEYS.

Parameters:

arg0 -

Returns:

fluent self

rxHkeys

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

Redis command HKEYS.

Parameters:

arg0 -

Returns:

fluent self

hlen

public RedisAPI hlen(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HLEN.

Parameters:

arg0 -

handler -

Returns:

fluent self

hlen

public RedisAPI hlen(String arg0)

Redis command HLEN.

Parameters:

arg0 -

Returns:

fluent self

rxHlen

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

Redis command HLEN.

Parameters:

arg0 -

Returns:

fluent self

hmget

public RedisAPI hmget(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HMGET.

Parameters:

args -

handler -

Returns:

fluent self

hmget

public RedisAPI hmget(List<String> args)

Redis command HMGET.

Parameters:

args -

Returns:

fluent self

rxHmget

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

Redis command HMGET.

Parameters:

args -

Returns:

fluent self

hmset

public RedisAPI hmset(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HMSET.

Parameters:

args -

handler -

Returns:

fluent self

hmset

public RedisAPI hmset(List<String> args)

Redis command HMSET.

Parameters:

args -

Returns:

fluent self

rxHmset

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

Redis command HMSET.

Parameters:

args -

Returns:

fluent self

hrandfield

public RedisAPI hrandfield(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HRANDFIELD.

Parameters:

args -

handler -

Returns:

fluent self

hrandfield

public RedisAPI hrandfield(List<String> args)

Redis command HRANDFIELD.

Parameters:

args -

Returns:

fluent self

rxHrandfield

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

Redis command HRANDFIELD.

Parameters:

args -

Returns:

fluent self

hscan

public RedisAPI hscan(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HSCAN.

Parameters:

args -

handler -

Returns:

fluent self

hscan

public RedisAPI hscan(List<String> args)

Redis command HSCAN.

Parameters:

args -

Returns:

fluent self

rxHscan

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

Redis command HSCAN.

Parameters:

args -

Returns:

fluent self

hset

public RedisAPI hset(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HSET.

Parameters:

args -

handler -

Returns:

fluent self

hset

public RedisAPI hset(List<String> args)

Redis command HSET.

Parameters:

args -

Returns:

fluent self

rxHset

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

Redis command HSET.

Parameters:

args -

Returns:

fluent self

hsetnx

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

Redis command HSETNX.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

hsetnx

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

Redis command HSETNX.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxHsetnx

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

Redis command HSETNX.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

hstrlen

public RedisAPI hstrlen(String arg0,
                        String arg1,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HSTRLEN.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

hstrlen

public RedisAPI hstrlen(String arg0,
                        String arg1)

Redis command HSTRLEN.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxHstrlen

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

Redis command HSTRLEN.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

hvals

public RedisAPI hvals(String arg0,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command HVALS.

Parameters:

arg0 -

handler -

Returns:

fluent self

hvals

public RedisAPI hvals(String arg0)

Redis command HVALS.

Parameters:

arg0 -

Returns:

fluent self

rxHvals

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

Redis command HVALS.

Parameters:

arg0 -

Returns:

fluent self

incr

public RedisAPI incr(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command INCR.

Parameters:

arg0 -

handler -

Returns:

fluent self

incr

public RedisAPI incr(String arg0)

Redis command INCR.

Parameters:

arg0 -

Returns:

fluent self

rxIncr

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

Redis command INCR.

Parameters:

arg0 -

Returns:

fluent self

incrby

public RedisAPI incrby(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command INCRBY.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

incrby

public RedisAPI incrby(String arg0,
                       String arg1)

Redis command INCRBY.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxIncrby

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

Redis command INCRBY.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

incrbyfloat

public RedisAPI incrbyfloat(String arg0,
                            String arg1,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command INCRBYFLOAT.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

incrbyfloat

public RedisAPI incrbyfloat(String arg0,
                            String arg1)

Redis command INCRBYFLOAT.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxIncrbyfloat

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

Redis command INCRBYFLOAT.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

info

public RedisAPI info(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command INFO.

Parameters:

args -

handler -

Returns:

fluent self

info

public RedisAPI info(List<String> args)

Redis command INFO.

Parameters:

args -

Returns:

fluent self

rxInfo

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

Redis command INFO.

Parameters:

args -

Returns:

fluent self

jsonArrappend

public RedisAPI jsonArrappend(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.ARRAPPEND.

Parameters:

args -

handler -

Returns:

fluent self

jsonArrappend

public RedisAPI jsonArrappend(List<String> args)

Redis command JSON.ARRAPPEND.

Parameters:

args -

Returns:

fluent self

rxJsonArrappend

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

Redis command JSON.ARRAPPEND.

Parameters:

args -

Returns:

fluent self

jsonArrindex

public RedisAPI jsonArrindex(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.ARRINDEX.

Parameters:

args -

handler -

Returns:

fluent self

jsonArrindex

public RedisAPI jsonArrindex(List<String> args)

Redis command JSON.ARRINDEX.

Parameters:

args -

Returns:

fluent self

rxJsonArrindex

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

Redis command JSON.ARRINDEX.

Parameters:

args -

Returns:

fluent self

jsonArrinsert

public RedisAPI jsonArrinsert(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.ARRINSERT.

Parameters:

args -

handler -

Returns:

fluent self

jsonArrinsert

public RedisAPI jsonArrinsert(List<String> args)

Redis command JSON.ARRINSERT.

Parameters:

args -

Returns:

fluent self

rxJsonArrinsert

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

Redis command JSON.ARRINSERT.

Parameters:

args -

Returns:

fluent self

jsonArrlen

public RedisAPI jsonArrlen(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.ARRLEN.

Parameters:

args -

handler -

Returns:

fluent self

jsonArrlen

public RedisAPI jsonArrlen(List<String> args)

Redis command JSON.ARRLEN.

Parameters:

args -

Returns:

fluent self

rxJsonArrlen

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

Redis command JSON.ARRLEN.

Parameters:

args -

Returns:

fluent self

jsonArrpop

public RedisAPI jsonArrpop(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.ARRPOP.

Parameters:

args -

handler -

Returns:

fluent self

jsonArrpop

public RedisAPI jsonArrpop(List<String> args)

Redis command JSON.ARRPOP.

Parameters:

args -

Returns:

fluent self

rxJsonArrpop

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

Redis command JSON.ARRPOP.

Parameters:

args -

Returns:

fluent self

jsonArrtrim

public RedisAPI jsonArrtrim(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.ARRTRIM.

Parameters:

args -

handler -

Returns:

fluent self

jsonArrtrim

public RedisAPI jsonArrtrim(List<String> args)

Redis command JSON.ARRTRIM.

Parameters:

args -

Returns:

fluent self

rxJsonArrtrim

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

Redis command JSON.ARRTRIM.

Parameters:

args -

Returns:

fluent self

jsonClear

public RedisAPI jsonClear(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.CLEAR.

Parameters:

args -

handler -

Returns:

fluent self

jsonClear

public RedisAPI jsonClear(List<String> args)

Redis command JSON.CLEAR.

Parameters:

args -

Returns:

fluent self

rxJsonClear

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

Redis command JSON.CLEAR.

Parameters:

args -

Returns:

fluent self

jsonDebug

public RedisAPI jsonDebug(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.DEBUG.

Parameters:

args -

handler -

Returns:

fluent self

jsonDebug

public RedisAPI jsonDebug(List<String> args)

Redis command JSON.DEBUG.

Parameters:

args -

Returns:

fluent self

rxJsonDebug

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

Redis command JSON.DEBUG.

Parameters:

args -

Returns:

fluent self

jsonDel

public RedisAPI jsonDel(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.DEL.

Parameters:

args -

handler -

Returns:

fluent self

jsonDel

public RedisAPI jsonDel(List<String> args)

Redis command JSON.DEL.

Parameters:

args -

Returns:

fluent self

rxJsonDel

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

Redis command JSON.DEL.

Parameters:

args -

Returns:

fluent self

jsonForget

public RedisAPI jsonForget(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.FORGET.

Parameters:

args -

handler -

Returns:

fluent self

jsonForget

public RedisAPI jsonForget(List<String> args)

Redis command JSON.FORGET.

Parameters:

args -

Returns:

fluent self

rxJsonForget

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

Redis command JSON.FORGET.

Parameters:

args -

Returns:

fluent self

jsonGet

public RedisAPI jsonGet(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.GET.

Parameters:

args -

handler -

Returns:

fluent self

jsonGet

public RedisAPI jsonGet(List<String> args)

Redis command JSON.GET.

Parameters:

args -

Returns:

fluent self

rxJsonGet

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

Redis command JSON.GET.

Parameters:

args -

Returns:

fluent self

jsonMget

public RedisAPI jsonMget(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.MGET.

Parameters:

args -

handler -

Returns:

fluent self

jsonMget

public RedisAPI jsonMget(List<String> args)

Redis command JSON.MGET.

Parameters:

args -

Returns:

fluent self

rxJsonMget

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

Redis command JSON.MGET.

Parameters:

args -

Returns:

fluent self

jsonNumincrby

public RedisAPI jsonNumincrby(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.NUMINCRBY.

Parameters:

args -

handler -

Returns:

fluent self

jsonNumincrby

public RedisAPI jsonNumincrby(List<String> args)

Redis command JSON.NUMINCRBY.

Parameters:

args -

Returns:

fluent self

rxJsonNumincrby

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

Redis command JSON.NUMINCRBY.

Parameters:

args -

Returns:

fluent self

jsonNummultby

public RedisAPI jsonNummultby(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.NUMMULTBY.

Parameters:

args -

handler -

Returns:

fluent self

jsonNummultby

public RedisAPI jsonNummultby(List<String> args)

Redis command JSON.NUMMULTBY.

Parameters:

args -

Returns:

fluent self

rxJsonNummultby

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

Redis command JSON.NUMMULTBY.

Parameters:

args -

Returns:

fluent self

jsonNumpowby

public RedisAPI jsonNumpowby(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.NUMPOWBY.

Parameters:

args -

handler -

Returns:

fluent self

jsonNumpowby

public RedisAPI jsonNumpowby(List<String> args)

Redis command JSON.NUMPOWBY.

Parameters:

args -

Returns:

fluent self

rxJsonNumpowby

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

Redis command JSON.NUMPOWBY.

Parameters:

args -

Returns:

fluent self

jsonObjkeys

public RedisAPI jsonObjkeys(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.OBJKEYS.

Parameters:

args -

handler -

Returns:

fluent self

jsonObjkeys

public RedisAPI jsonObjkeys(List<String> args)

Redis command JSON.OBJKEYS.

Parameters:

args -

Returns:

fluent self

rxJsonObjkeys

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

Redis command JSON.OBJKEYS.

Parameters:

args -

Returns:

fluent self

jsonObjlen

public RedisAPI jsonObjlen(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.OBJLEN.

Parameters:

args -

handler -

Returns:

fluent self

jsonObjlen

public RedisAPI jsonObjlen(List<String> args)

Redis command JSON.OBJLEN.

Parameters:

args -

Returns:

fluent self

rxJsonObjlen

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

Redis command JSON.OBJLEN.

Parameters:

args -

Returns:

fluent self

jsonResp

public RedisAPI jsonResp(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.RESP.

Parameters:

args -

handler -

Returns:

fluent self

jsonResp

public RedisAPI jsonResp(List<String> args)

Redis command JSON.RESP.

Parameters:

args -

Returns:

fluent self

rxJsonResp

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

Redis command JSON.RESP.

Parameters:

args -

Returns:

fluent self

jsonSet

public RedisAPI jsonSet(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.SET.

Parameters:

args -

handler -

Returns:

fluent self

jsonSet

public RedisAPI jsonSet(List<String> args)

Redis command JSON.SET.

Parameters:

args -

Returns:

fluent self

rxJsonSet

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

Redis command JSON.SET.

Parameters:

args -

Returns:

fluent self

jsonStrappend

public RedisAPI jsonStrappend(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.STRAPPEND.

Parameters:

args -

handler -

Returns:

fluent self

jsonStrappend

public RedisAPI jsonStrappend(List<String> args)

Redis command JSON.STRAPPEND.

Parameters:

args -

Returns:

fluent self

rxJsonStrappend

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

Redis command JSON.STRAPPEND.

Parameters:

args -

Returns:

fluent self

jsonStrlen

public RedisAPI jsonStrlen(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.STRLEN.

Parameters:

args -

handler -

Returns:

fluent self

jsonStrlen

public RedisAPI jsonStrlen(List<String> args)

Redis command JSON.STRLEN.

Parameters:

args -

Returns:

fluent self

rxJsonStrlen

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

Redis command JSON.STRLEN.

Parameters:

args -

Returns:

fluent self

jsonToggle

public RedisAPI jsonToggle(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.TOGGLE.

Parameters:

args -

handler -

Returns:

fluent self

jsonToggle

public RedisAPI jsonToggle(List<String> args)

Redis command JSON.TOGGLE.

Parameters:

args -

Returns:

fluent self

rxJsonToggle

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

Redis command JSON.TOGGLE.

Parameters:

args -

Returns:

fluent self

jsonType

public RedisAPI jsonType(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command JSON.TYPE.

Parameters:

args -

handler -

Returns:

fluent self

jsonType

public RedisAPI jsonType(List<String> args)

Redis command JSON.TYPE.

Parameters:

args -

Returns:

fluent self

rxJsonType

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

Redis command JSON.TYPE.

Parameters:

args -

Returns:

fluent self

keys

public RedisAPI keys(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command KEYS.

Parameters:

arg0 -

handler -

Returns:

fluent self

keys

public RedisAPI keys(String arg0)

Redis command KEYS.

Parameters:

arg0 -

Returns:

fluent self

rxKeys

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

Redis command KEYS.

Parameters:

arg0 -

Returns:

fluent self

lastsave

public RedisAPI lastsave(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LASTSAVE.

Parameters:

handler -

Returns:

fluent self

lastsave

public RedisAPI lastsave()

Redis command LASTSAVE.

Returns:

fluent self

rxLastsave

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

Redis command LASTSAVE.

Returns:

fluent self

latency

public RedisAPI latency(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LATENCY.

Parameters:

args -

handler -

Returns:

fluent self

latency

public RedisAPI latency(List<String> args)

Redis command LATENCY.

Parameters:

args -

Returns:

fluent self

rxLatency

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

Redis command LATENCY.

Parameters:

args -

Returns:

fluent self

lcs

public RedisAPI lcs(List<String> args,
                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LCS.

Parameters:

args -

handler -

Returns:

fluent self

lcs

public RedisAPI lcs(List<String> args)

Redis command LCS.

Parameters:

args -

Returns:

fluent self

rxLcs

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

Redis command LCS.

Parameters:

args -

Returns:

fluent self

lindex

public RedisAPI lindex(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LINDEX.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

lindex

public RedisAPI lindex(String arg0,
                       String arg1)

Redis command LINDEX.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxLindex

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

Redis command LINDEX.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

linsert

public RedisAPI linsert(String arg0,
                        String arg1,
                        String arg2,
                        String arg3,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LINSERT.

Parameters:

arg0 -

arg1 -

arg2 -

arg3 -

handler -

Returns:

fluent self

linsert

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

Redis command LINSERT.

Parameters:

arg0 -

arg1 -

arg2 -

arg3 -

Returns:

fluent self

rxLinsert

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

Redis command LINSERT.

Parameters:

arg0 -

arg1 -

arg2 -

arg3 -

Returns:

fluent self

llen

public RedisAPI llen(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LLEN.

Parameters:

arg0 -

handler -

Returns:

fluent self

llen

public RedisAPI llen(String arg0)

Redis command LLEN.

Parameters:

arg0 -

Returns:

fluent self

rxLlen

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

Redis command LLEN.

Parameters:

arg0 -

Returns:

fluent self

lmove

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

Redis command LMOVE.

Parameters:

arg0 -

arg1 -

arg2 -

arg3 -

handler -

Returns:

fluent self

lmove

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

Redis command LMOVE.

Parameters:

arg0 -

arg1 -

arg2 -

arg3 -

Returns:

fluent self

rxLmove

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

Redis command LMOVE.

Parameters:

arg0 -

arg1 -

arg2 -

arg3 -

Returns:

fluent self

lmpop

public RedisAPI lmpop(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LMPOP.

Parameters:

args -

handler -

Returns:

fluent self

lmpop

public RedisAPI lmpop(List<String> args)

Redis command LMPOP.

Parameters:

args -

Returns:

fluent self

rxLmpop

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

Redis command LMPOP.

Parameters:

args -

Returns:

fluent self

lolwut

public RedisAPI lolwut(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LOLWUT.

Parameters:

args -

handler -

Returns:

fluent self

lolwut

public RedisAPI lolwut(List<String> args)

Redis command LOLWUT.

Parameters:

args -

Returns:

fluent self

rxLolwut

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

Redis command LOLWUT.

Parameters:

args -

Returns:

fluent self

lpop

public RedisAPI lpop(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LPOP.

Parameters:

args -

handler -

Returns:

fluent self

lpop

public RedisAPI lpop(List<String> args)

Redis command LPOP.

Parameters:

args -

Returns:

fluent self

rxLpop

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

Redis command LPOP.

Parameters:

args -

Returns:

fluent self

lpos

public RedisAPI lpos(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LPOS.

Parameters:

args -

handler -

Returns:

fluent self

lpos

public RedisAPI lpos(List<String> args)

Redis command LPOS.

Parameters:

args -

Returns:

fluent self

rxLpos

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

Redis command LPOS.

Parameters:

args -

Returns:

fluent self

lpush

public RedisAPI lpush(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LPUSH.

Parameters:

args -

handler -

Returns:

fluent self

lpush

public RedisAPI lpush(List<String> args)

Redis command LPUSH.

Parameters:

args -

Returns:

fluent self

rxLpush

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

Redis command LPUSH.

Parameters:

args -

Returns:

fluent self

lpushx

public RedisAPI lpushx(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command LPUSHX.

Parameters:

args -

handler -

Returns:

fluent self

lpushx

public RedisAPI lpushx(List<String> args)

Redis command LPUSHX.

Parameters:

args -

Returns:

fluent self

rxLpushx

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

Redis command LPUSHX.

Parameters:

args -

Returns:

fluent self

lrange

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

Redis command LRANGE.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

lrange

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

Redis command LRANGE.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxLrange

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

Redis command LRANGE.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

lrem

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

Redis command LREM.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

lrem

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

Redis command LREM.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxLrem

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

Redis command LREM.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

lset

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

Redis command LSET.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

lset

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

Redis command LSET.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxLset

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

Redis command LSET.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

ltrim

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

Redis command LTRIM.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

ltrim

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

Redis command LTRIM.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxLtrim

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

Redis command LTRIM.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

memory

public RedisAPI memory(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command MEMORY.

Parameters:

args -

handler -

Returns:

fluent self

memory

public RedisAPI memory(List<String> args)

Redis command MEMORY.

Parameters:

args -

Returns:

fluent self

rxMemory

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

Redis command MEMORY.

Parameters:

args -

Returns:

fluent self

mget

public RedisAPI mget(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command MGET.

Parameters:

args -

handler -

Returns:

fluent self

mget

public RedisAPI mget(List<String> args)

Redis command MGET.

Parameters:

args -

Returns:

fluent self

rxMget

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

Redis command MGET.

Parameters:

args -

Returns:

fluent self

migrate

public RedisAPI migrate(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command MIGRATE.

Parameters:

args -

handler -

Returns:

fluent self

migrate

public RedisAPI migrate(List<String> args)

Redis command MIGRATE.

Parameters:

args -

Returns:

fluent self

rxMigrate

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

Redis command MIGRATE.

Parameters:

args -

Returns:

fluent self

module

public RedisAPI module(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command MODULE.

Parameters:

args -

handler -

Returns:

fluent self

module

public RedisAPI module(List<String> args)

Redis command MODULE.

Parameters:

args -

Returns:

fluent self

rxModule

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

Redis command MODULE.

Parameters:

args -

Returns:

fluent self

monitor

public RedisAPI monitor(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command MONITOR.

Parameters:

handler -

Returns:

fluent self

monitor

public RedisAPI monitor()

Redis command MONITOR.

Returns:

fluent self

rxMonitor

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

Redis command MONITOR.

Returns:

fluent self

move

public RedisAPI move(String arg0,
                     String arg1,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command MOVE.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

move

public RedisAPI move(String arg0,
                     String arg1)

Redis command MOVE.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxMove

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

Redis command MOVE.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

mset

public RedisAPI mset(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command MSET.

Parameters:

args -

handler -

Returns:

fluent self

mset

public RedisAPI mset(List<String> args)

Redis command MSET.

Parameters:

args -

Returns:

fluent self

rxMset

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

Redis command MSET.

Parameters:

args -

Returns:

fluent self

msetnx

public RedisAPI msetnx(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command MSETNX.

Parameters:

args -

handler -

Returns:

fluent self

msetnx

public RedisAPI msetnx(List<String> args)

Redis command MSETNX.

Parameters:

args -

Returns:

fluent self

rxMsetnx

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

Redis command MSETNX.

Parameters:

args -

Returns:

fluent self

multi

public RedisAPI multi(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command MULTI.

Parameters:

handler -

Returns:

fluent self

multi

public RedisAPI multi()

Redis command MULTI.

Returns:

fluent self

rxMulti

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

Redis command MULTI.

Returns:

fluent self

object

public RedisAPI object(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command OBJECT.

Parameters:

args -

handler -

Returns:

fluent self

object

public RedisAPI object(List<String> args)

Redis command OBJECT.

Parameters:

args -

Returns:

fluent self

rxObject

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

Redis command OBJECT.

Parameters:

args -

Returns:

fluent self

persist

public RedisAPI persist(String arg0,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PERSIST.

Parameters:

arg0 -

handler -

Returns:

fluent self

persist

public RedisAPI persist(String arg0)

Redis command PERSIST.

Parameters:

arg0 -

Returns:

fluent self

rxPersist

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

Redis command PERSIST.

Parameters:

arg0 -

Returns:

fluent self

pexpire

public RedisAPI pexpire(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PEXPIRE.

Parameters:

args -

handler -

Returns:

fluent self

pexpire

public RedisAPI pexpire(List<String> args)

Redis command PEXPIRE.

Parameters:

args -

Returns:

fluent self

rxPexpire

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

Redis command PEXPIRE.

Parameters:

args -

Returns:

fluent self

pexpireat

public RedisAPI pexpireat(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PEXPIREAT.

Parameters:

args -

handler -

Returns:

fluent self

pexpireat

public RedisAPI pexpireat(List<String> args)

Redis command PEXPIREAT.

Parameters:

args -

Returns:

fluent self

rxPexpireat

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

Redis command PEXPIREAT.

Parameters:

args -

Returns:

fluent self

pexpiretime

public RedisAPI pexpiretime(String arg0,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PEXPIRETIME.

Parameters:

arg0 -

handler -

Returns:

fluent self

pexpiretime

public RedisAPI pexpiretime(String arg0)

Redis command PEXPIRETIME.

Parameters:

arg0 -

Returns:

fluent self

rxPexpiretime

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

Redis command PEXPIRETIME.

Parameters:

arg0 -

Returns:

fluent self

pfadd

public RedisAPI pfadd(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PFADD.

Parameters:

args -

handler -

Returns:

fluent self

pfadd

public RedisAPI pfadd(List<String> args)

Redis command PFADD.

Parameters:

args -

Returns:

fluent self

rxPfadd

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

Redis command PFADD.

Parameters:

args -

Returns:

fluent self

pfcount

public RedisAPI pfcount(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PFCOUNT.

Parameters:

args -

handler -

Returns:

fluent self

pfcount

public RedisAPI pfcount(List<String> args)

Redis command PFCOUNT.

Parameters:

args -

Returns:

fluent self

rxPfcount

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

Redis command PFCOUNT.

Parameters:

args -

Returns:

fluent self

pfdebug

public RedisAPI pfdebug(String arg0,
                        String arg1,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PFDEBUG.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

pfdebug

public RedisAPI pfdebug(String arg0,
                        String arg1)

Redis command PFDEBUG.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxPfdebug

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

Redis command PFDEBUG.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

pfmerge

public RedisAPI pfmerge(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PFMERGE.

Parameters:

args -

handler -

Returns:

fluent self

pfmerge

public RedisAPI pfmerge(List<String> args)

Redis command PFMERGE.

Parameters:

args -

Returns:

fluent self

rxPfmerge

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

Redis command PFMERGE.

Parameters:

args -

Returns:

fluent self

pfselftest

public RedisAPI pfselftest(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PFSELFTEST.

Parameters:

handler -

Returns:

fluent self

pfselftest

public RedisAPI pfselftest()

Redis command PFSELFTEST.

Returns:

fluent self

rxPfselftest

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

Redis command PFSELFTEST.

Returns:

fluent self

ping

public RedisAPI ping(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PING.

Parameters:

args -

handler -

Returns:

fluent self

ping

public RedisAPI ping(List<String> args)

Redis command PING.

Parameters:

args -

Returns:

fluent self

rxPing

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

Redis command PING.

Parameters:

args -

Returns:

fluent self

psetex

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

Redis command PSETEX.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

psetex

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

Redis command PSETEX.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxPsetex

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

Redis command PSETEX.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

psubscribe

public RedisAPI psubscribe(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PSUBSCRIBE.

Parameters:

args -

handler -

Returns:

fluent self

psubscribe

public RedisAPI psubscribe(List<String> args)

Redis command PSUBSCRIBE.

Parameters:

args -

Returns:

fluent self

rxPsubscribe

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

Redis command PSUBSCRIBE.

Parameters:

args -

Returns:

fluent self

psync

public RedisAPI psync(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PSYNC.

Parameters:

args -

handler -

Returns:

fluent self

psync

public RedisAPI psync(List<String> args)

Redis command PSYNC.

Parameters:

args -

Returns:

fluent self

rxPsync

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

Redis command PSYNC.

Parameters:

args -

Returns:

fluent self

pttl

public RedisAPI pttl(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PTTL.

Parameters:

arg0 -

handler -

Returns:

fluent self

pttl

public RedisAPI pttl(String arg0)

Redis command PTTL.

Parameters:

arg0 -

Returns:

fluent self

rxPttl

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

Redis command PTTL.

Parameters:

arg0 -

Returns:

fluent self

publish

public RedisAPI publish(String arg0,
                        String arg1,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PUBLISH.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

publish

public RedisAPI publish(String arg0,
                        String arg1)

Redis command PUBLISH.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxPublish

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

Redis command PUBLISH.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

pubsub

public RedisAPI pubsub(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PUBSUB.

Parameters:

args -

handler -

Returns:

fluent self

pubsub

public RedisAPI pubsub(List<String> args)

Redis command PUBSUB.

Parameters:

args -

Returns:

fluent self

rxPubsub

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

Redis command PUBSUB.

Parameters:

args -

Returns:

fluent self

punsubscribe

public RedisAPI punsubscribe(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command PUNSUBSCRIBE.

Parameters:

args -

handler -

Returns:

fluent self

punsubscribe

public RedisAPI punsubscribe(List<String> args)

Redis command PUNSUBSCRIBE.

Parameters:

args -

Returns:

fluent self

rxPunsubscribe

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

Redis command PUNSUBSCRIBE.

Parameters:

args -

Returns:

fluent self

quit

public RedisAPI quit(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command QUIT.

Parameters:

args -

handler -

Returns:

fluent self

quit

public RedisAPI quit(List<String> args)

Redis command QUIT.

Parameters:

args -

Returns:

fluent self

rxQuit

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

Redis command QUIT.

Parameters:

args -

Returns:

fluent self

randomkey

public RedisAPI randomkey(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command RANDOMKEY.

Parameters:

handler -

Returns:

fluent self

randomkey

public RedisAPI randomkey()

Redis command RANDOMKEY.

Returns:

fluent self

rxRandomkey

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

Redis command RANDOMKEY.

Returns:

fluent self

readonly

public RedisAPI readonly(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command READONLY.

Parameters:

handler -

Returns:

fluent self

readonly

public RedisAPI readonly()

Redis command READONLY.

Returns:

fluent self

rxReadonly

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

Redis command READONLY.

Returns:

fluent self

readwrite

public RedisAPI readwrite(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command READWRITE.

Parameters:

handler -

Returns:

fluent self

readwrite

public RedisAPI readwrite()

Redis command READWRITE.

Returns:

fluent self

rxReadwrite

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

Redis command READWRITE.

Returns:

fluent self

rename

public RedisAPI rename(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command RENAME.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

rename

public RedisAPI rename(String arg0,
                       String arg1)

Redis command RENAME.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxRename

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

Redis command RENAME.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

renamenx

public RedisAPI renamenx(String arg0,
                         String arg1,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command RENAMENX.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

renamenx

public RedisAPI renamenx(String arg0,
                         String arg1)

Redis command RENAMENX.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxRenamenx

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

Redis command RENAMENX.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

replconf

public RedisAPI replconf(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command REPLCONF.

Parameters:

args -

handler -

Returns:

fluent self

replconf

public RedisAPI replconf(List<String> args)

Redis command REPLCONF.

Parameters:

args -

Returns:

fluent self

rxReplconf

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

Redis command REPLCONF.

Parameters:

args -

Returns:

fluent self

replicaof

public RedisAPI replicaof(String arg0,
                          String arg1,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command REPLICAOF.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

replicaof

public RedisAPI replicaof(String arg0,
                          String arg1)

Redis command REPLICAOF.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxReplicaof

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

Redis command REPLICAOF.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

reset

public RedisAPI reset(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command RESET.

Parameters:

handler -

Returns:

fluent self

reset

public RedisAPI reset()

Redis command RESET.

Returns:

fluent self

rxReset

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

Redis command RESET.

Returns:

fluent self

restore

public RedisAPI restore(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command RESTORE.

Parameters:

args -

handler -

Returns:

fluent self

restore

public RedisAPI restore(List<String> args)

Redis command RESTORE.

Parameters:

args -

Returns:

fluent self

rxRestore

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

Redis command RESTORE.

Parameters:

args -

Returns:

fluent self

restoreAsking

public RedisAPI restoreAsking(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command RESTORE-ASKING.

Parameters:

args -

handler -

Returns:

fluent self

restoreAsking

public RedisAPI restoreAsking(List<String> args)

Redis command RESTORE-ASKING.

Parameters:

args -

Returns:

fluent self

rxRestoreAsking

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

Redis command RESTORE-ASKING.

Parameters:

args -

Returns:

fluent self

role

public RedisAPI role(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ROLE.

Parameters:

handler -

Returns:

fluent self

role

public RedisAPI role()

Redis command ROLE.

Returns:

fluent self

rxRole

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

Redis command ROLE.

Returns:

fluent self

rpop

public RedisAPI rpop(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command RPOP.

Parameters:

args -

handler -

Returns:

fluent self

rpop

public RedisAPI rpop(List<String> args)

Redis command RPOP.

Parameters:

args -

Returns:

fluent self

rxRpop

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

Redis command RPOP.

Parameters:

args -

Returns:

fluent self

rpoplpush

public RedisAPI rpoplpush(String arg0,
                          String arg1,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command RPOPLPUSH.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

rpoplpush

public RedisAPI rpoplpush(String arg0,
                          String arg1)

Redis command RPOPLPUSH.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxRpoplpush

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

Redis command RPOPLPUSH.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rpush

public RedisAPI rpush(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command RPUSH.

Parameters:

args -

handler -

Returns:

fluent self

rpush

public RedisAPI rpush(List<String> args)

Redis command RPUSH.

Parameters:

args -

Returns:

fluent self

rxRpush

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

Redis command RPUSH.

Parameters:

args -

Returns:

fluent self

rpushx

public RedisAPI rpushx(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command RPUSHX.

Parameters:

args -

handler -

Returns:

fluent self

rpushx

public RedisAPI rpushx(List<String> args)

Redis command RPUSHX.

Parameters:

args -

Returns:

fluent self

rxRpushx

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

Redis command RPUSHX.

Parameters:

args -

Returns:

fluent self

sadd

public RedisAPI sadd(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SADD.

Parameters:

args -

handler -

Returns:

fluent self

sadd

public RedisAPI sadd(List<String> args)

Redis command SADD.

Parameters:

args -

Returns:

fluent self

rxSadd

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

Redis command SADD.

Parameters:

args -

Returns:

fluent self

save

public RedisAPI save(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SAVE.

Parameters:

handler -

Returns:

fluent self

save

public RedisAPI save()

Redis command SAVE.

Returns:

fluent self

rxSave

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

Redis command SAVE.

Returns:

fluent self

scan

public RedisAPI scan(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SCAN.

Parameters:

args -

handler -

Returns:

fluent self

scan

public RedisAPI scan(List<String> args)

Redis command SCAN.

Parameters:

args -

Returns:

fluent self

rxScan

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

Redis command SCAN.

Parameters:

args -

Returns:

fluent self

scard

public RedisAPI scard(String arg0,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SCARD.

Parameters:

arg0 -

handler -

Returns:

fluent self

scard

public RedisAPI scard(String arg0)

Redis command SCARD.

Parameters:

arg0 -

Returns:

fluent self

rxScard

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

Redis command SCARD.

Parameters:

arg0 -

Returns:

fluent self

script

public RedisAPI script(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SCRIPT.

Parameters:

args -

handler -

Returns:

fluent self

script

public RedisAPI script(List<String> args)

Redis command SCRIPT.

Parameters:

args -

Returns:

fluent self

rxScript

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

Redis command SCRIPT.

Parameters:

args -

Returns:

fluent self

sdiff

public RedisAPI sdiff(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SDIFF.

Parameters:

args -

handler -

Returns:

fluent self

sdiff

public RedisAPI sdiff(List<String> args)

Redis command SDIFF.

Parameters:

args -

Returns:

fluent self

rxSdiff

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

Redis command SDIFF.

Parameters:

args -

Returns:

fluent self

sdiffstore

public RedisAPI sdiffstore(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SDIFFSTORE.

Parameters:

args -

handler -

Returns:

fluent self

sdiffstore

public RedisAPI sdiffstore(List<String> args)

Redis command SDIFFSTORE.

Parameters:

args -

Returns:

fluent self

rxSdiffstore

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

Redis command SDIFFSTORE.

Parameters:

args -

Returns:

fluent self

select

public RedisAPI select(String arg0,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SELECT.

Parameters:

arg0 -

handler -

Returns:

fluent self

select

public RedisAPI select(String arg0)

Redis command SELECT.

Parameters:

arg0 -

Returns:

fluent self

rxSelect

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

Redis command SELECT.

Parameters:

arg0 -

Returns:

fluent self

set

public RedisAPI set(List<String> args,
                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SET.

Parameters:

args -

handler -

Returns:

fluent self

set

public RedisAPI set(List<String> args)

Redis command SET.

Parameters:

args -

Returns:

fluent self

rxSet

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

Redis command SET.

Parameters:

args -

Returns:

fluent self

setbit

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

Redis command SETBIT.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

setbit

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

Redis command SETBIT.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxSetbit

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

Redis command SETBIT.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

setex

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

Redis command SETEX.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

setex

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

Redis command SETEX.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxSetex

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

Redis command SETEX.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

setnx

public RedisAPI setnx(String arg0,
                      String arg1,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SETNX.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

setnx

public RedisAPI setnx(String arg0,
                      String arg1)

Redis command SETNX.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxSetnx

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

Redis command SETNX.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

setrange

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

Redis command SETRANGE.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

setrange

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

Redis command SETRANGE.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxSetrange

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

Redis command SETRANGE.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

shutdown

public RedisAPI shutdown(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SHUTDOWN.

Parameters:

args -

handler -

Returns:

fluent self

shutdown

public RedisAPI shutdown(List<String> args)

Redis command SHUTDOWN.

Parameters:

args -

Returns:

fluent self

rxShutdown

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

Redis command SHUTDOWN.

Parameters:

args -

Returns:

fluent self

sinter

public RedisAPI sinter(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SINTER.

Parameters:

args -

handler -

Returns:

fluent self

sinter

public RedisAPI sinter(List<String> args)

Redis command SINTER.

Parameters:

args -

Returns:

fluent self

rxSinter

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

Redis command SINTER.

Parameters:

args -

Returns:

fluent self

sintercard

public RedisAPI sintercard(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SINTERCARD.

Parameters:

args -

handler -

Returns:

fluent self

sintercard

public RedisAPI sintercard(List<String> args)

Redis command SINTERCARD.

Parameters:

args -

Returns:

fluent self

rxSintercard

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

Redis command SINTERCARD.

Parameters:

args -

Returns:

fluent self

sinterstore

public RedisAPI sinterstore(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SINTERSTORE.

Parameters:

args -

handler -

Returns:

fluent self

sinterstore

public RedisAPI sinterstore(List<String> args)

Redis command SINTERSTORE.

Parameters:

args -

Returns:

fluent self

rxSinterstore

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

Redis command SINTERSTORE.

Parameters:

args -

Returns:

fluent self

sismember

public RedisAPI sismember(String arg0,
                          String arg1,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SISMEMBER.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

sismember

public RedisAPI sismember(String arg0,
                          String arg1)

Redis command SISMEMBER.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxSismember

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

Redis command SISMEMBER.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

slaveof

public RedisAPI slaveof(String arg0,
                        String arg1,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SLAVEOF.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

slaveof

public RedisAPI slaveof(String arg0,
                        String arg1)

Redis command SLAVEOF.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxSlaveof

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

Redis command SLAVEOF.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

slowlog

public RedisAPI slowlog(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SLOWLOG.

Parameters:

args -

handler -

Returns:

fluent self

slowlog

public RedisAPI slowlog(List<String> args)

Redis command SLOWLOG.

Parameters:

args -

Returns:

fluent self

rxSlowlog

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

Redis command SLOWLOG.

Parameters:

args -

Returns:

fluent self

smembers

public RedisAPI smembers(String arg0,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SMEMBERS.

Parameters:

arg0 -

handler -

Returns:

fluent self

smembers

public RedisAPI smembers(String arg0)

Redis command SMEMBERS.

Parameters:

arg0 -

Returns:

fluent self

rxSmembers

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

Redis command SMEMBERS.

Parameters:

arg0 -

Returns:

fluent self

smismember

public RedisAPI smismember(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SMISMEMBER.

Parameters:

args -

handler -

Returns:

fluent self

smismember

public RedisAPI smismember(List<String> args)

Redis command SMISMEMBER.

Parameters:

args -

Returns:

fluent self

rxSmismember

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

Redis command SMISMEMBER.

Parameters:

args -

Returns:

fluent self

smove

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

Redis command SMOVE.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

smove

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

Redis command SMOVE.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxSmove

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

Redis command SMOVE.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

sort

public RedisAPI sort(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SORT.

Parameters:

args -

handler -

Returns:

fluent self

sort

public RedisAPI sort(List<String> args)

Redis command SORT.

Parameters:

args -

Returns:

fluent self

rxSort

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

Redis command SORT.

Parameters:

args -

Returns:

fluent self

sortRo

public RedisAPI sortRo(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SORT_RO.

Parameters:

args -

handler -

Returns:

fluent self

sortRo

public RedisAPI sortRo(List<String> args)

Redis command SORT_RO.

Parameters:

args -

Returns:

fluent self

rxSortRo

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

Redis command SORT_RO.

Parameters:

args -

Returns:

fluent self

spop

public RedisAPI spop(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SPOP.

Parameters:

args -

handler -

Returns:

fluent self

spop

public RedisAPI spop(List<String> args)

Redis command SPOP.

Parameters:

args -

Returns:

fluent self

rxSpop

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

Redis command SPOP.

Parameters:

args -

Returns:

fluent self

spublish

public RedisAPI spublish(String arg0,
                         String arg1,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SPUBLISH.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

spublish

public RedisAPI spublish(String arg0,
                         String arg1)

Redis command SPUBLISH.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxSpublish

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

Redis command SPUBLISH.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

srandmember

public RedisAPI srandmember(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SRANDMEMBER.

Parameters:

args -

handler -

Returns:

fluent self

srandmember

public RedisAPI srandmember(List<String> args)

Redis command SRANDMEMBER.

Parameters:

args -

Returns:

fluent self

rxSrandmember

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

Redis command SRANDMEMBER.

Parameters:

args -

Returns:

fluent self

srem

public RedisAPI srem(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SREM.

Parameters:

args -

handler -

Returns:

fluent self

srem

public RedisAPI srem(List<String> args)

Redis command SREM.

Parameters:

args -

Returns:

fluent self

rxSrem

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

Redis command SREM.

Parameters:

args -

Returns:

fluent self

sscan

public RedisAPI sscan(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SSCAN.

Parameters:

args -

handler -

Returns:

fluent self

sscan

public RedisAPI sscan(List<String> args)

Redis command SSCAN.

Parameters:

args -

Returns:

fluent self

rxSscan

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

Redis command SSCAN.

Parameters:

args -

Returns:

fluent self

ssubscribe

public RedisAPI ssubscribe(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SSUBSCRIBE.

Parameters:

args -

handler -

Returns:

fluent self

ssubscribe

public RedisAPI ssubscribe(List<String> args)

Redis command SSUBSCRIBE.

Parameters:

args -

Returns:

fluent self

rxSsubscribe

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

Redis command SSUBSCRIBE.

Parameters:

args -

Returns:

fluent self

strlen

public RedisAPI strlen(String arg0,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command STRLEN.

Parameters:

arg0 -

handler -

Returns:

fluent self

strlen

public RedisAPI strlen(String arg0)

Redis command STRLEN.

Parameters:

arg0 -

Returns:

fluent self

rxStrlen

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

Redis command STRLEN.

Parameters:

arg0 -

Returns:

fluent self

subscribe

public RedisAPI subscribe(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SUBSCRIBE.

Parameters:

args -

handler -

Returns:

fluent self

subscribe

public RedisAPI subscribe(List<String> args)

Redis command SUBSCRIBE.

Parameters:

args -

Returns:

fluent self

rxSubscribe

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

Redis command SUBSCRIBE.

Parameters:

args -

Returns:

fluent self

substr

public RedisAPI substr(String arg0,
                       String arg1,
                       String arg2,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SUBSTR.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

substr

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

Redis command SUBSTR.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxSubstr

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

Redis command SUBSTR.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

sunion

public RedisAPI sunion(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SUNION.

Parameters:

args -

handler -

Returns:

fluent self

sunion

public RedisAPI sunion(List<String> args)

Redis command SUNION.

Parameters:

args -

Returns:

fluent self

rxSunion

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

Redis command SUNION.

Parameters:

args -

Returns:

fluent self

sunionstore

public RedisAPI sunionstore(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SUNIONSTORE.

Parameters:

args -

handler -

Returns:

fluent self

sunionstore

public RedisAPI sunionstore(List<String> args)

Redis command SUNIONSTORE.

Parameters:

args -

Returns:

fluent self

rxSunionstore

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

Redis command SUNIONSTORE.

Parameters:

args -

Returns:

fluent self

sunsubscribe

public RedisAPI sunsubscribe(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SUNSUBSCRIBE.

Parameters:

args -

handler -

Returns:

fluent self

sunsubscribe

public RedisAPI sunsubscribe(List<String> args)

Redis command SUNSUBSCRIBE.

Parameters:

args -

Returns:

fluent self

rxSunsubscribe

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

Redis command SUNSUBSCRIBE.

Parameters:

args -

Returns:

fluent self

swapdb

public RedisAPI swapdb(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SWAPDB.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

swapdb

public RedisAPI swapdb(String arg0,
                       String arg1)

Redis command SWAPDB.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxSwapdb

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

Redis command SWAPDB.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

sync

public RedisAPI sync(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command SYNC.

Parameters:

handler -

Returns:

fluent self

sync

public RedisAPI sync()

Redis command SYNC.

Returns:

fluent self

rxSync

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

Redis command SYNC.

Returns:

fluent self

tdigestAdd

public RedisAPI tdigestAdd(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.ADD.

Parameters:

args -

handler -

Returns:

fluent self

tdigestAdd

public RedisAPI tdigestAdd(List<String> args)

Redis command TDIGEST.ADD.

Parameters:

args -

Returns:

fluent self

rxTdigestAdd

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

Redis command TDIGEST.ADD.

Parameters:

args -

Returns:

fluent self

tdigestByrank

public RedisAPI tdigestByrank(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.BYRANK.

Parameters:

args -

handler -

Returns:

fluent self

tdigestByrank

public RedisAPI tdigestByrank(List<String> args)

Redis command TDIGEST.BYRANK.

Parameters:

args -

Returns:

fluent self

rxTdigestByrank

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

Redis command TDIGEST.BYRANK.

Parameters:

args -

Returns:

fluent self

tdigestByrevrank

public RedisAPI tdigestByrevrank(List<String> args,
                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.BYREVRANK.

Parameters:

args -

handler -

Returns:

fluent self

tdigestByrevrank

public RedisAPI tdigestByrevrank(List<String> args)

Redis command TDIGEST.BYREVRANK.

Parameters:

args -

Returns:

fluent self

rxTdigestByrevrank

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

Redis command TDIGEST.BYREVRANK.

Parameters:

args -

Returns:

fluent self

tdigestCdf

public RedisAPI tdigestCdf(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.CDF.

Parameters:

args -

handler -

Returns:

fluent self

tdigestCdf

public RedisAPI tdigestCdf(List<String> args)

Redis command TDIGEST.CDF.

Parameters:

args -

Returns:

fluent self

rxTdigestCdf

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

Redis command TDIGEST.CDF.

Parameters:

args -

Returns:

fluent self

tdigestCreate

public RedisAPI tdigestCreate(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.CREATE.

Parameters:

args -

handler -

Returns:

fluent self

tdigestCreate

public RedisAPI tdigestCreate(List<String> args)

Redis command TDIGEST.CREATE.

Parameters:

args -

Returns:

fluent self

rxTdigestCreate

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

Redis command TDIGEST.CREATE.

Parameters:

args -

Returns:

fluent self

tdigestInfo

public RedisAPI tdigestInfo(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.INFO.

Parameters:

args -

handler -

Returns:

fluent self

tdigestInfo

public RedisAPI tdigestInfo(List<String> args)

Redis command TDIGEST.INFO.

Parameters:

args -

Returns:

fluent self

rxTdigestInfo

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

Redis command TDIGEST.INFO.

Parameters:

args -

Returns:

fluent self

tdigestMax

public RedisAPI tdigestMax(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.MAX.

Parameters:

args -

handler -

Returns:

fluent self

tdigestMax

public RedisAPI tdigestMax(List<String> args)

Redis command TDIGEST.MAX.

Parameters:

args -

Returns:

fluent self

rxTdigestMax

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

Redis command TDIGEST.MAX.

Parameters:

args -

Returns:

fluent self

tdigestMerge

public RedisAPI tdigestMerge(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.MERGE.

Parameters:

args -

handler -

Returns:

fluent self

tdigestMerge

public RedisAPI tdigestMerge(List<String> args)

Redis command TDIGEST.MERGE.

Parameters:

args -

Returns:

fluent self

rxTdigestMerge

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

Redis command TDIGEST.MERGE.

Parameters:

args -

Returns:

fluent self

tdigestMin

public RedisAPI tdigestMin(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.MIN.

Parameters:

args -

handler -

Returns:

fluent self

tdigestMin

public RedisAPI tdigestMin(List<String> args)

Redis command TDIGEST.MIN.

Parameters:

args -

Returns:

fluent self

rxTdigestMin

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

Redis command TDIGEST.MIN.

Parameters:

args -

Returns:

fluent self

tdigestQuantile

public RedisAPI tdigestQuantile(List<String> args,
                                io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.QUANTILE.

Parameters:

args -

handler -

Returns:

fluent self

tdigestQuantile

public RedisAPI tdigestQuantile(List<String> args)

Redis command TDIGEST.QUANTILE.

Parameters:

args -

Returns:

fluent self

rxTdigestQuantile

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

Redis command TDIGEST.QUANTILE.

Parameters:

args -

Returns:

fluent self

tdigestRank

public RedisAPI tdigestRank(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.RANK.

Parameters:

args -

handler -

Returns:

fluent self

tdigestRank

public RedisAPI tdigestRank(List<String> args)

Redis command TDIGEST.RANK.

Parameters:

args -

Returns:

fluent self

rxTdigestRank

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

Redis command TDIGEST.RANK.

Parameters:

args -

Returns:

fluent self

tdigestReset

public RedisAPI tdigestReset(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.RESET.

Parameters:

args -

handler -

Returns:

fluent self

tdigestReset

public RedisAPI tdigestReset(List<String> args)

Redis command TDIGEST.RESET.

Parameters:

args -

Returns:

fluent self

rxTdigestReset

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

Redis command TDIGEST.RESET.

Parameters:

args -

Returns:

fluent self

tdigestRevrank

public RedisAPI tdigestRevrank(List<String> args,
                               io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.REVRANK.

Parameters:

args -

handler -

Returns:

fluent self

tdigestRevrank

public RedisAPI tdigestRevrank(List<String> args)

Redis command TDIGEST.REVRANK.

Parameters:

args -

Returns:

fluent self

rxTdigestRevrank

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

Redis command TDIGEST.REVRANK.

Parameters:

args -

Returns:

fluent self

tdigestTrimmedMean

public RedisAPI tdigestTrimmedMean(List<String> args,
                                   io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TDIGEST.TRIMMED_MEAN.

Parameters:

args -

handler -

Returns:

fluent self

tdigestTrimmedMean

public RedisAPI tdigestTrimmedMean(List<String> args)

Redis command TDIGEST.TRIMMED_MEAN.

Parameters:

args -

Returns:

fluent self

rxTdigestTrimmedMean

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

Redis command TDIGEST.TRIMMED_MEAN.

Parameters:

args -

Returns:

fluent self

time

public RedisAPI time(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TIME.

Parameters:

handler -

Returns:

fluent self

time

public RedisAPI time()

Redis command TIME.

Returns:

fluent self

rxTime

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

Redis command TIME.

Returns:

fluent self

timeseriesClusterset

public RedisAPI timeseriesClusterset(List<String> args,
                                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TIMESERIES.CLUSTERSET.

Parameters:

args -

handler -

Returns:

fluent self

timeseriesClusterset

public RedisAPI timeseriesClusterset(List<String> args)

Redis command TIMESERIES.CLUSTERSET.

Parameters:

args -

Returns:

fluent self

rxTimeseriesClusterset

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

Redis command TIMESERIES.CLUSTERSET.

Parameters:

args -

Returns:

fluent self

timeseriesClustersetfromshard

public RedisAPI timeseriesClustersetfromshard(List<String> args,
                                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TIMESERIES.CLUSTERSETFROMSHARD.

Parameters:

args -

handler -

Returns:

fluent self

timeseriesClustersetfromshard

public RedisAPI timeseriesClustersetfromshard(List<String> args)

Redis command TIMESERIES.CLUSTERSETFROMSHARD.

Parameters:

args -

Returns:

fluent self

rxTimeseriesClustersetfromshard

public io.reactivex.Maybe<Response> rxTimeseriesClustersetfromshard(List<String> args)

Redis command TIMESERIES.CLUSTERSETFROMSHARD.

Parameters:

args -

Returns:

fluent self

timeseriesHello

public RedisAPI timeseriesHello(List<String> args,
                                io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TIMESERIES.HELLO.

Parameters:

args -

handler -

Returns:

fluent self

timeseriesHello

public RedisAPI timeseriesHello(List<String> args)

Redis command TIMESERIES.HELLO.

Parameters:

args -

Returns:

fluent self

rxTimeseriesHello

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

Redis command TIMESERIES.HELLO.

Parameters:

args -

Returns:

fluent self

timeseriesInfocluster

public RedisAPI timeseriesInfocluster(List<String> args,
                                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TIMESERIES.INFOCLUSTER.

Parameters:

args -

handler -

Returns:

fluent self

timeseriesInfocluster

public RedisAPI timeseriesInfocluster(List<String> args)

Redis command TIMESERIES.INFOCLUSTER.

Parameters:

args -

Returns:

fluent self

rxTimeseriesInfocluster

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

Redis command TIMESERIES.INFOCLUSTER.

Parameters:

args -

Returns:

fluent self

timeseriesInnercommunication

public RedisAPI timeseriesInnercommunication(List<String> args,
                                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TIMESERIES.INNERCOMMUNICATION.

Parameters:

args -

handler -

Returns:

fluent self

timeseriesInnercommunication

public RedisAPI timeseriesInnercommunication(List<String> args)

Redis command TIMESERIES.INNERCOMMUNICATION.

Parameters:

args -

Returns:

fluent self

rxTimeseriesInnercommunication

public io.reactivex.Maybe<Response> rxTimeseriesInnercommunication(List<String> args)

Redis command TIMESERIES.INNERCOMMUNICATION.

Parameters:

args -

Returns:

fluent self

timeseriesNetworktest

public RedisAPI timeseriesNetworktest(List<String> args,
                                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TIMESERIES.NETWORKTEST.

Parameters:

args -

handler -

Returns:

fluent self

timeseriesNetworktest

public RedisAPI timeseriesNetworktest(List<String> args)

Redis command TIMESERIES.NETWORKTEST.

Parameters:

args -

Returns:

fluent self

rxTimeseriesNetworktest

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

Redis command TIMESERIES.NETWORKTEST.

Parameters:

args -

Returns:

fluent self

timeseriesRefreshcluster

public RedisAPI timeseriesRefreshcluster(List<String> args,
                                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TIMESERIES.REFRESHCLUSTER.

Parameters:

args -

handler -

Returns:

fluent self

timeseriesRefreshcluster

public RedisAPI timeseriesRefreshcluster(List<String> args)

Redis command TIMESERIES.REFRESHCLUSTER.

Parameters:

args -

Returns:

fluent self

rxTimeseriesRefreshcluster

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

Redis command TIMESERIES.REFRESHCLUSTER.

Parameters:

args -

Returns:

fluent self

topkAdd

public RedisAPI topkAdd(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TOPK.ADD.

Parameters:

args -

handler -

Returns:

fluent self

topkAdd

public RedisAPI topkAdd(List<String> args)

Redis command TOPK.ADD.

Parameters:

args -

Returns:

fluent self

rxTopkAdd

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

Redis command TOPK.ADD.

Parameters:

args -

Returns:

fluent self

topkCount

public RedisAPI topkCount(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TOPK.COUNT.

Parameters:

args -

handler -

Returns:

fluent self

topkCount

public RedisAPI topkCount(List<String> args)

Redis command TOPK.COUNT.

Parameters:

args -

Returns:

fluent self

rxTopkCount

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

Redis command TOPK.COUNT.

Parameters:

args -

Returns:

fluent self

topkIncrby

public RedisAPI topkIncrby(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TOPK.INCRBY.

Parameters:

args -

handler -

Returns:

fluent self

topkIncrby

public RedisAPI topkIncrby(List<String> args)

Redis command TOPK.INCRBY.

Parameters:

args -

Returns:

fluent self

rxTopkIncrby

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

Redis command TOPK.INCRBY.

Parameters:

args -

Returns:

fluent self

topkInfo

public RedisAPI topkInfo(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TOPK.INFO.

Parameters:

args -

handler -

Returns:

fluent self

topkInfo

public RedisAPI topkInfo(List<String> args)

Redis command TOPK.INFO.

Parameters:

args -

Returns:

fluent self

rxTopkInfo

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

Redis command TOPK.INFO.

Parameters:

args -

Returns:

fluent self

topkList

public RedisAPI topkList(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TOPK.LIST.

Parameters:

args -

handler -

Returns:

fluent self

topkList

public RedisAPI topkList(List<String> args)

Redis command TOPK.LIST.

Parameters:

args -

Returns:

fluent self

rxTopkList

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

Redis command TOPK.LIST.

Parameters:

args -

Returns:

fluent self

topkQuery

public RedisAPI topkQuery(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TOPK.QUERY.

Parameters:

args -

handler -

Returns:

fluent self

topkQuery

public RedisAPI topkQuery(List<String> args)

Redis command TOPK.QUERY.

Parameters:

args -

Returns:

fluent self

rxTopkQuery

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

Redis command TOPK.QUERY.

Parameters:

args -

Returns:

fluent self

topkReserve

public RedisAPI topkReserve(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TOPK.RESERVE.

Parameters:

args -

handler -

Returns:

fluent self

topkReserve

public RedisAPI topkReserve(List<String> args)

Redis command TOPK.RESERVE.

Parameters:

args -

Returns:

fluent self

rxTopkReserve

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

Redis command TOPK.RESERVE.

Parameters:

args -

Returns:

fluent self

touch

public RedisAPI touch(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TOUCH.

Parameters:

args -

handler -

Returns:

fluent self

touch

public RedisAPI touch(List<String> args)

Redis command TOUCH.

Parameters:

args -

Returns:

fluent self

rxTouch

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

Redis command TOUCH.

Parameters:

args -

Returns:

fluent self

tsAdd

public RedisAPI tsAdd(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.ADD.

Parameters:

args -

handler -

Returns:

fluent self

tsAdd

public RedisAPI tsAdd(List<String> args)

Redis command TS.ADD.

Parameters:

args -

Returns:

fluent self

rxTsAdd

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

Redis command TS.ADD.

Parameters:

args -

Returns:

fluent self

tsAlter

public RedisAPI tsAlter(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.ALTER.

Parameters:

args -

handler -

Returns:

fluent self

tsAlter

public RedisAPI tsAlter(List<String> args)

Redis command TS.ALTER.

Parameters:

args -

Returns:

fluent self

rxTsAlter

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

Redis command TS.ALTER.

Parameters:

args -

Returns:

fluent self

tsCreate

public RedisAPI tsCreate(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.CREATE.

Parameters:

args -

handler -

Returns:

fluent self

tsCreate

public RedisAPI tsCreate(List<String> args)

Redis command TS.CREATE.

Parameters:

args -

Returns:

fluent self

rxTsCreate

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

Redis command TS.CREATE.

Parameters:

args -

Returns:

fluent self

tsCreaterule

public RedisAPI tsCreaterule(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.CREATERULE.

Parameters:

args -

handler -

Returns:

fluent self

tsCreaterule

public RedisAPI tsCreaterule(List<String> args)

Redis command TS.CREATERULE.

Parameters:

args -

Returns:

fluent self

rxTsCreaterule

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

Redis command TS.CREATERULE.

Parameters:

args -

Returns:

fluent self

tsDecrby

public RedisAPI tsDecrby(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.DECRBY.

Parameters:

args -

handler -

Returns:

fluent self

tsDecrby

public RedisAPI tsDecrby(List<String> args)

Redis command TS.DECRBY.

Parameters:

args -

Returns:

fluent self

rxTsDecrby

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

Redis command TS.DECRBY.

Parameters:

args -

Returns:

fluent self

tsDel

public RedisAPI tsDel(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.DEL.

Parameters:

args -

handler -

Returns:

fluent self

tsDel

public RedisAPI tsDel(List<String> args)

Redis command TS.DEL.

Parameters:

args -

Returns:

fluent self

rxTsDel

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

Redis command TS.DEL.

Parameters:

args -

Returns:

fluent self

tsDeleterule

public RedisAPI tsDeleterule(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.DELETERULE.

Parameters:

args -

handler -

Returns:

fluent self

tsDeleterule

public RedisAPI tsDeleterule(List<String> args)

Redis command TS.DELETERULE.

Parameters:

args -

Returns:

fluent self

rxTsDeleterule

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

Redis command TS.DELETERULE.

Parameters:

args -

Returns:

fluent self

tsGet

public RedisAPI tsGet(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.GET.

Parameters:

args -

handler -

Returns:

fluent self

tsGet

public RedisAPI tsGet(List<String> args)

Redis command TS.GET.

Parameters:

args -

Returns:

fluent self

rxTsGet

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

Redis command TS.GET.

Parameters:

args -

Returns:

fluent self

tsIncrby

public RedisAPI tsIncrby(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.INCRBY.

Parameters:

args -

handler -

Returns:

fluent self

tsIncrby

public RedisAPI tsIncrby(List<String> args)

Redis command TS.INCRBY.

Parameters:

args -

Returns:

fluent self

rxTsIncrby

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

Redis command TS.INCRBY.

Parameters:

args -

Returns:

fluent self

tsInfo

public RedisAPI tsInfo(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.INFO.

Parameters:

args -

handler -

Returns:

fluent self

tsInfo

public RedisAPI tsInfo(List<String> args)

Redis command TS.INFO.

Parameters:

args -

Returns:

fluent self

rxTsInfo

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

Redis command TS.INFO.

Parameters:

args -

Returns:

fluent self

tsMadd

public RedisAPI tsMadd(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.MADD.

Parameters:

args -

handler -

Returns:

fluent self

tsMadd

public RedisAPI tsMadd(List<String> args)

Redis command TS.MADD.

Parameters:

args -

Returns:

fluent self

rxTsMadd

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

Redis command TS.MADD.

Parameters:

args -

Returns:

fluent self

tsMget

public RedisAPI tsMget(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.MGET.

Parameters:

args -

handler -

Returns:

fluent self

tsMget

public RedisAPI tsMget(List<String> args)

Redis command TS.MGET.

Parameters:

args -

Returns:

fluent self

rxTsMget

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

Redis command TS.MGET.

Parameters:

args -

Returns:

fluent self

tsMrange

public RedisAPI tsMrange(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.MRANGE.

Parameters:

args -

handler -

Returns:

fluent self

tsMrange

public RedisAPI tsMrange(List<String> args)

Redis command TS.MRANGE.

Parameters:

args -

Returns:

fluent self

rxTsMrange

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

Redis command TS.MRANGE.

Parameters:

args -

Returns:

fluent self

tsMrevrange

public RedisAPI tsMrevrange(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.MREVRANGE.

Parameters:

args -

handler -

Returns:

fluent self

tsMrevrange

public RedisAPI tsMrevrange(List<String> args)

Redis command TS.MREVRANGE.

Parameters:

args -

Returns:

fluent self

rxTsMrevrange

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

Redis command TS.MREVRANGE.

Parameters:

args -

Returns:

fluent self

tsQueryindex

public RedisAPI tsQueryindex(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.QUERYINDEX.

Parameters:

args -

handler -

Returns:

fluent self

tsQueryindex

public RedisAPI tsQueryindex(List<String> args)

Redis command TS.QUERYINDEX.

Parameters:

args -

Returns:

fluent self

rxTsQueryindex

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

Redis command TS.QUERYINDEX.

Parameters:

args -

Returns:

fluent self

tsRange

public RedisAPI tsRange(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.RANGE.

Parameters:

args -

handler -

Returns:

fluent self

tsRange

public RedisAPI tsRange(List<String> args)

Redis command TS.RANGE.

Parameters:

args -

Returns:

fluent self

rxTsRange

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

Redis command TS.RANGE.

Parameters:

args -

Returns:

fluent self

tsRevrange

public RedisAPI tsRevrange(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TS.REVRANGE.

Parameters:

args -

handler -

Returns:

fluent self

tsRevrange

public RedisAPI tsRevrange(List<String> args)

Redis command TS.REVRANGE.

Parameters:

args -

Returns:

fluent self

rxTsRevrange

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

Redis command TS.REVRANGE.

Parameters:

args -

Returns:

fluent self

ttl

public RedisAPI ttl(String arg0,
                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TTL.

Parameters:

arg0 -

handler -

Returns:

fluent self

ttl

public RedisAPI ttl(String arg0)

Redis command TTL.

Parameters:

arg0 -

Returns:

fluent self

rxTtl

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

Redis command TTL.

Parameters:

arg0 -

Returns:

fluent self

type

public RedisAPI type(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command TYPE.

Parameters:

arg0 -

handler -

Returns:

fluent self

type

public RedisAPI type(String arg0)

Redis command TYPE.

Parameters:

arg0 -

Returns:

fluent self

rxType

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

Redis command TYPE.

Parameters:

arg0 -

Returns:

fluent self

unlink

public RedisAPI unlink(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command UNLINK.

Parameters:

args -

handler -

Returns:

fluent self

unlink

public RedisAPI unlink(List<String> args)

Redis command UNLINK.

Parameters:

args -

Returns:

fluent self

rxUnlink

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

Redis command UNLINK.

Parameters:

args -

Returns:

fluent self

unsubscribe

public RedisAPI unsubscribe(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command UNSUBSCRIBE.

Parameters:

args -

handler -

Returns:

fluent self

unsubscribe

public RedisAPI unsubscribe(List<String> args)

Redis command UNSUBSCRIBE.

Parameters:

args -

Returns:

fluent self

rxUnsubscribe

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

Redis command UNSUBSCRIBE.

Parameters:

args -

Returns:

fluent self

unwatch

public RedisAPI unwatch(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command UNWATCH.

Parameters:

handler -

Returns:

fluent self

unwatch

public RedisAPI unwatch()

Redis command UNWATCH.

Returns:

fluent self

rxUnwatch

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

Redis command UNWATCH.

Returns:

fluent self

wait

public RedisAPI wait(String arg0,
                     String arg1,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command WAIT.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

wait

public RedisAPI wait(String arg0,
                     String arg1)

Redis command WAIT.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxWait

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

Redis command WAIT.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

watch

public RedisAPI watch(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command WATCH.

Parameters:

args -

handler -

Returns:

fluent self

watch

public RedisAPI watch(List<String> args)

Redis command WATCH.

Parameters:

args -

Returns:

fluent self

rxWatch

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

Redis command WATCH.

Parameters:

args -

Returns:

fluent self

xack

public RedisAPI xack(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XACK.

Parameters:

args -

handler -

Returns:

fluent self

xack

public RedisAPI xack(List<String> args)

Redis command XACK.

Parameters:

args -

Returns:

fluent self

rxXack

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

Redis command XACK.

Parameters:

args -

Returns:

fluent self

xadd

public RedisAPI xadd(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XADD.

Parameters:

args -

handler -

Returns:

fluent self

xadd

public RedisAPI xadd(List<String> args)

Redis command XADD.

Parameters:

args -

Returns:

fluent self

rxXadd

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

Redis command XADD.

Parameters:

args -

Returns:

fluent self

xautoclaim

public RedisAPI xautoclaim(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XAUTOCLAIM.

Parameters:

args -

handler -

Returns:

fluent self

xautoclaim

public RedisAPI xautoclaim(List<String> args)

Redis command XAUTOCLAIM.

Parameters:

args -

Returns:

fluent self

rxXautoclaim

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

Redis command XAUTOCLAIM.

Parameters:

args -

Returns:

fluent self

xclaim

public RedisAPI xclaim(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XCLAIM.

Parameters:

args -

handler -

Returns:

fluent self

xclaim

public RedisAPI xclaim(List<String> args)

Redis command XCLAIM.

Parameters:

args -

Returns:

fluent self

rxXclaim

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

Redis command XCLAIM.

Parameters:

args -

Returns:

fluent self

xdel

public RedisAPI xdel(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XDEL.

Parameters:

args -

handler -

Returns:

fluent self

xdel

public RedisAPI xdel(List<String> args)

Redis command XDEL.

Parameters:

args -

Returns:

fluent self

rxXdel

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

Redis command XDEL.

Parameters:

args -

Returns:

fluent self

xgroup

public RedisAPI xgroup(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XGROUP.

Parameters:

args -

handler -

Returns:

fluent self

xgroup

public RedisAPI xgroup(List<String> args)

Redis command XGROUP.

Parameters:

args -

Returns:

fluent self

rxXgroup

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

Redis command XGROUP.

Parameters:

args -

Returns:

fluent self

xinfo

public RedisAPI xinfo(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XINFO.

Parameters:

args -

handler -

Returns:

fluent self

xinfo

public RedisAPI xinfo(List<String> args)

Redis command XINFO.

Parameters:

args -

Returns:

fluent self

rxXinfo

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

Redis command XINFO.

Parameters:

args -

Returns:

fluent self

xlen

public RedisAPI xlen(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XLEN.

Parameters:

arg0 -

handler -

Returns:

fluent self

xlen

public RedisAPI xlen(String arg0)

Redis command XLEN.

Parameters:

arg0 -

Returns:

fluent self

rxXlen

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

Redis command XLEN.

Parameters:

arg0 -

Returns:

fluent self

xpending

public RedisAPI xpending(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XPENDING.

Parameters:

args -

handler -

Returns:

fluent self

xpending

public RedisAPI xpending(List<String> args)

Redis command XPENDING.

Parameters:

args -

Returns:

fluent self

rxXpending

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

Redis command XPENDING.

Parameters:

args -

Returns:

fluent self

xrange

public RedisAPI xrange(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XRANGE.

Parameters:

args -

handler -

Returns:

fluent self

xrange

public RedisAPI xrange(List<String> args)

Redis command XRANGE.

Parameters:

args -

Returns:

fluent self

rxXrange

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

Redis command XRANGE.

Parameters:

args -

Returns:

fluent self

xread

public RedisAPI xread(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XREAD.

Parameters:

args -

handler -

Returns:

fluent self

xread

public RedisAPI xread(List<String> args)

Redis command XREAD.

Parameters:

args -

Returns:

fluent self

rxXread

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

Redis command XREAD.

Parameters:

args -

Returns:

fluent self

xreadgroup

public RedisAPI xreadgroup(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XREADGROUP.

Parameters:

args -

handler -

Returns:

fluent self

xreadgroup

public RedisAPI xreadgroup(List<String> args)

Redis command XREADGROUP.

Parameters:

args -

Returns:

fluent self

rxXreadgroup

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

Redis command XREADGROUP.

Parameters:

args -

Returns:

fluent self

xrevrange

public RedisAPI xrevrange(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XREVRANGE.

Parameters:

args -

handler -

Returns:

fluent self

xrevrange

public RedisAPI xrevrange(List<String> args)

Redis command XREVRANGE.

Parameters:

args -

Returns:

fluent self

rxXrevrange

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

Redis command XREVRANGE.

Parameters:

args -

Returns:

fluent self

xsetid

public RedisAPI xsetid(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XSETID.

Parameters:

args -

handler -

Returns:

fluent self

xsetid

public RedisAPI xsetid(List<String> args)

Redis command XSETID.

Parameters:

args -

Returns:

fluent self

rxXsetid

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

Redis command XSETID.

Parameters:

args -

Returns:

fluent self

xtrim

public RedisAPI xtrim(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command XTRIM.

Parameters:

args -

handler -

Returns:

fluent self

xtrim

public RedisAPI xtrim(List<String> args)

Redis command XTRIM.

Parameters:

args -

Returns:

fluent self

rxXtrim

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

Redis command XTRIM.

Parameters:

args -

Returns:

fluent self

zadd

public RedisAPI zadd(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZADD.

Parameters:

args -

handler -

Returns:

fluent self

zadd

public RedisAPI zadd(List<String> args)

Redis command ZADD.

Parameters:

args -

Returns:

fluent self

rxZadd

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

Redis command ZADD.

Parameters:

args -

Returns:

fluent self

zcard

public RedisAPI zcard(String arg0,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZCARD.

Parameters:

arg0 -

handler -

Returns:

fluent self

zcard

public RedisAPI zcard(String arg0)

Redis command ZCARD.

Parameters:

arg0 -

Returns:

fluent self

rxZcard

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

Redis command ZCARD.

Parameters:

arg0 -

Returns:

fluent self

zcount

public RedisAPI zcount(String arg0,
                       String arg1,
                       String arg2,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZCOUNT.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

zcount

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

Redis command ZCOUNT.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxZcount

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

Redis command ZCOUNT.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

zdiff

public RedisAPI zdiff(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZDIFF.

Parameters:

args -

handler -

Returns:

fluent self

zdiff

public RedisAPI zdiff(List<String> args)

Redis command ZDIFF.

Parameters:

args -

Returns:

fluent self

rxZdiff

public io.reactivex.Maybe<Response> rxZdiff(List<String> args)

Redis command ZDIFF.

Parameters:

args -

Returns:

fluent self

zdiffstore

public RedisAPI zdiffstore(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZDIFFSTORE.

Parameters:

args -

handler -

Returns:

fluent self

zdiffstore

public RedisAPI zdiffstore(List<String> args)

Redis command ZDIFFSTORE.

Parameters:

args -

Returns:

fluent self

rxZdiffstore

public io.reactivex.Maybe<Response> rxZdiffstore(List<String> args)

Redis command ZDIFFSTORE.

Parameters:

args -

Returns:

fluent self

zincrby

public RedisAPI zincrby(String arg0,
                        String arg1,
                        String arg2,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZINCRBY.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

zincrby

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

Redis command ZINCRBY.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxZincrby

public io.reactivex.Maybe<Response> rxZincrby(String arg0,
                                              String arg1,
                                              String arg2)

Redis command ZINCRBY.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

zinter

public RedisAPI zinter(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZINTER.

Parameters:

args -

handler -

Returns:

fluent self

zinter

public RedisAPI zinter(List<String> args)

Redis command ZINTER.

Parameters:

args -

Returns:

fluent self

rxZinter

public io.reactivex.Maybe<Response> rxZinter(List<String> args)

Redis command ZINTER.

Parameters:

args -

Returns:

fluent self

zintercard

public RedisAPI zintercard(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZINTERCARD.

Parameters:

args -

handler -

Returns:

fluent self

zintercard

public RedisAPI zintercard(List<String> args)

Redis command ZINTERCARD.

Parameters:

args -

Returns:

fluent self

rxZintercard

public io.reactivex.Maybe<Response> rxZintercard(List<String> args)

Redis command ZINTERCARD.

Parameters:

args -

Returns:

fluent self

zinterstore

public RedisAPI zinterstore(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZINTERSTORE.

Parameters:

args -

handler -

Returns:

fluent self

zinterstore

public RedisAPI zinterstore(List<String> args)

Redis command ZINTERSTORE.

Parameters:

args -

Returns:

fluent self

rxZinterstore

public io.reactivex.Maybe<Response> rxZinterstore(List<String> args)

Redis command ZINTERSTORE.

Parameters:

args -

Returns:

fluent self

zlexcount

public RedisAPI zlexcount(String arg0,
                          String arg1,
                          String arg2,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZLEXCOUNT.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

zlexcount

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

Redis command ZLEXCOUNT.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxZlexcount

public io.reactivex.Maybe<Response> rxZlexcount(String arg0,
                                                String arg1,
                                                String arg2)

Redis command ZLEXCOUNT.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

zmpop

public RedisAPI zmpop(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZMPOP.

Parameters:

args -

handler -

Returns:

fluent self

zmpop

public RedisAPI zmpop(List<String> args)

Redis command ZMPOP.

Parameters:

args -

Returns:

fluent self

rxZmpop

public io.reactivex.Maybe<Response> rxZmpop(List<String> args)

Redis command ZMPOP.

Parameters:

args -

Returns:

fluent self

zmscore

public RedisAPI zmscore(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZMSCORE.

Parameters:

args -

handler -

Returns:

fluent self

zmscore

public RedisAPI zmscore(List<String> args)

Redis command ZMSCORE.

Parameters:

args -

Returns:

fluent self

rxZmscore

public io.reactivex.Maybe<Response> rxZmscore(List<String> args)

Redis command ZMSCORE.

Parameters:

args -

Returns:

fluent self

zpopmax

public RedisAPI zpopmax(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZPOPMAX.

Parameters:

args -

handler -

Returns:

fluent self

zpopmax

public RedisAPI zpopmax(List<String> args)

Redis command ZPOPMAX.

Parameters:

args -

Returns:

fluent self

rxZpopmax

public io.reactivex.Maybe<Response> rxZpopmax(List<String> args)

Redis command ZPOPMAX.

Parameters:

args -

Returns:

fluent self

zpopmin

public RedisAPI zpopmin(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZPOPMIN.

Parameters:

args -

handler -

Returns:

fluent self

zpopmin

public RedisAPI zpopmin(List<String> args)

Redis command ZPOPMIN.

Parameters:

args -

Returns:

fluent self

rxZpopmin

public io.reactivex.Maybe<Response> rxZpopmin(List<String> args)

Redis command ZPOPMIN.

Parameters:

args -

Returns:

fluent self

zrandmember

public RedisAPI zrandmember(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZRANDMEMBER.

Parameters:

args -

handler -

Returns:

fluent self

zrandmember

public RedisAPI zrandmember(List<String> args)

Redis command ZRANDMEMBER.

Parameters:

args -

Returns:

fluent self

rxZrandmember

public io.reactivex.Maybe<Response> rxZrandmember(List<String> args)

Redis command ZRANDMEMBER.

Parameters:

args -

Returns:

fluent self

zrange

public RedisAPI zrange(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZRANGE.

Parameters:

args -

handler -

Returns:

fluent self

zrange

public RedisAPI zrange(List<String> args)

Redis command ZRANGE.

Parameters:

args -

Returns:

fluent self

rxZrange

public io.reactivex.Maybe<Response> rxZrange(List<String> args)

Redis command ZRANGE.

Parameters:

args -

Returns:

fluent self

zrangebylex

public RedisAPI zrangebylex(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZRANGEBYLEX.

Parameters:

args -

handler -

Returns:

fluent self

zrangebylex

public RedisAPI zrangebylex(List<String> args)

Redis command ZRANGEBYLEX.

Parameters:

args -

Returns:

fluent self

rxZrangebylex

public io.reactivex.Maybe<Response> rxZrangebylex(List<String> args)

Redis command ZRANGEBYLEX.

Parameters:

args -

Returns:

fluent self

zrangebyscore

public RedisAPI zrangebyscore(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZRANGEBYSCORE.

Parameters:

args -

handler -

Returns:

fluent self

zrangebyscore

public RedisAPI zrangebyscore(List<String> args)

Redis command ZRANGEBYSCORE.

Parameters:

args -

Returns:

fluent self

rxZrangebyscore

public io.reactivex.Maybe<Response> rxZrangebyscore(List<String> args)

Redis command ZRANGEBYSCORE.

Parameters:

args -

Returns:

fluent self

zrangestore

public RedisAPI zrangestore(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZRANGESTORE.

Parameters:

args -

handler -

Returns:

fluent self

zrangestore

public RedisAPI zrangestore(List<String> args)

Redis command ZRANGESTORE.

Parameters:

args -

Returns:

fluent self

rxZrangestore

public io.reactivex.Maybe<Response> rxZrangestore(List<String> args)

Redis command ZRANGESTORE.

Parameters:

args -

Returns:

fluent self

zrank

public RedisAPI zrank(String arg0,
                      String arg1,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZRANK.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

zrank

public RedisAPI zrank(String arg0,
                      String arg1)

Redis command ZRANK.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxZrank

public io.reactivex.Maybe<Response> rxZrank(String arg0,
                                            String arg1)

Redis command ZRANK.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

zrem

public RedisAPI zrem(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZREM.

Parameters:

args -

handler -

Returns:

fluent self

zrem

public RedisAPI zrem(List<String> args)

Redis command ZREM.

Parameters:

args -

Returns:

fluent self

rxZrem

public io.reactivex.Maybe<Response> rxZrem(List<String> args)

Redis command ZREM.

Parameters:

args -

Returns:

fluent self

zremrangebylex

public RedisAPI zremrangebylex(String arg0,
                               String arg1,
                               String arg2,
                               io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZREMRANGEBYLEX.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

zremrangebylex

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

Redis command ZREMRANGEBYLEX.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxZremrangebylex

public io.reactivex.Maybe<Response> rxZremrangebylex(String arg0,
                                                     String arg1,
                                                     String arg2)

Redis command ZREMRANGEBYLEX.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

zremrangebyrank

public RedisAPI zremrangebyrank(String arg0,
                                String arg1,
                                String arg2,
                                io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZREMRANGEBYRANK.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

zremrangebyrank

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

Redis command ZREMRANGEBYRANK.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxZremrangebyrank

public io.reactivex.Maybe<Response> rxZremrangebyrank(String arg0,
                                                      String arg1,
                                                      String arg2)

Redis command ZREMRANGEBYRANK.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

zremrangebyscore

public RedisAPI zremrangebyscore(String arg0,
                                 String arg1,
                                 String arg2,
                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZREMRANGEBYSCORE.

Parameters:

arg0 -

arg1 -

arg2 -

handler -

Returns:

fluent self

zremrangebyscore

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

Redis command ZREMRANGEBYSCORE.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

rxZremrangebyscore

public io.reactivex.Maybe<Response> rxZremrangebyscore(String arg0,
                                                       String arg1,
                                                       String arg2)

Redis command ZREMRANGEBYSCORE.

Parameters:

arg0 -

arg1 -

arg2 -

Returns:

fluent self

zrevrange

public RedisAPI zrevrange(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZREVRANGE.

Parameters:

args -

handler -

Returns:

fluent self

zrevrange

public RedisAPI zrevrange(List<String> args)

Redis command ZREVRANGE.

Parameters:

args -

Returns:

fluent self

rxZrevrange

public io.reactivex.Maybe<Response> rxZrevrange(List<String> args)

Redis command ZREVRANGE.

Parameters:

args -

Returns:

fluent self

zrevrangebylex

public RedisAPI zrevrangebylex(List<String> args,
                               io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZREVRANGEBYLEX.

Parameters:

args -

handler -

Returns:

fluent self

zrevrangebylex

public RedisAPI zrevrangebylex(List<String> args)

Redis command ZREVRANGEBYLEX.

Parameters:

args -

Returns:

fluent self

rxZrevrangebylex

public io.reactivex.Maybe<Response> rxZrevrangebylex(List<String> args)

Redis command ZREVRANGEBYLEX.

Parameters:

args -

Returns:

fluent self

zrevrangebyscore

public RedisAPI zrevrangebyscore(List<String> args,
                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZREVRANGEBYSCORE.

Parameters:

args -

handler -

Returns:

fluent self

zrevrangebyscore

public RedisAPI zrevrangebyscore(List<String> args)

Redis command ZREVRANGEBYSCORE.

Parameters:

args -

Returns:

fluent self

rxZrevrangebyscore

public io.reactivex.Maybe<Response> rxZrevrangebyscore(List<String> args)

Redis command ZREVRANGEBYSCORE.

Parameters:

args -

Returns:

fluent self

zrevrank

public RedisAPI zrevrank(String arg0,
                         String arg1,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZREVRANK.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

zrevrank

public RedisAPI zrevrank(String arg0,
                         String arg1)

Redis command ZREVRANK.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxZrevrank

public io.reactivex.Maybe<Response> rxZrevrank(String arg0,
                                               String arg1)

Redis command ZREVRANK.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

zscan

public RedisAPI zscan(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZSCAN.

Parameters:

args -

handler -

Returns:

fluent self

zscan

public RedisAPI zscan(List<String> args)

Redis command ZSCAN.

Parameters:

args -

Returns:

fluent self

rxZscan

public io.reactivex.Maybe<Response> rxZscan(List<String> args)

Redis command ZSCAN.

Parameters:

args -

Returns:

fluent self

zscore

public RedisAPI zscore(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZSCORE.

Parameters:

arg0 -

arg1 -

handler -

Returns:

fluent self

zscore

public RedisAPI zscore(String arg0,
                       String arg1)

Redis command ZSCORE.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

rxZscore

public io.reactivex.Maybe<Response> rxZscore(String arg0,
                                             String arg1)

Redis command ZSCORE.

Parameters:

arg0 -

arg1 -

Returns:

fluent self

zunion

public RedisAPI zunion(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZUNION.

Parameters:

args -

handler -

Returns:

fluent self

zunion

public RedisAPI zunion(List<String> args)

Redis command ZUNION.

Parameters:

args -

Returns:

fluent self

rxZunion

public io.reactivex.Maybe<Response> rxZunion(List<String> args)

Redis command ZUNION.

Parameters:

args -

Returns:

fluent self

zunionstore

public RedisAPI zunionstore(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ZUNIONSTORE.

Parameters:

args -

handler -

Returns:

fluent self

zunionstore

public RedisAPI zunionstore(List<String> args)

Redis command ZUNIONSTORE.

Parameters:

args -

Returns:

fluent self

rxZunionstore

public io.reactivex.Maybe<Response> rxZunionstore(List<String> args)

Redis command ZUNIONSTORE.

Parameters:

args -

Returns:

fluent self

api

public static RedisAPI api(Redis client)

api

public static RedisAPI api(RedisConnection connection)

newInstance

public static RedisAPI newInstance(io.vertx.redis.client.RedisAPI arg)