io.quarkus.redis.client.reactive

Interface ReactiveRedisClient

All Known Implementing Classes:

ReactiveRedisClientImpl

public interface ReactiveRedisClient

A Redis client offering reactive Redis commands. For more information about how each individual command visit the Redis Commands Page

Method Summary

Modifier and Type	Method and Description
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	append(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	appendAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	asking()
io.vertx.mutiny.redis.client.Response	askingAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	auth(String arg0)
io.vertx.mutiny.redis.client.Response	authAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	bgrewriteaof()
io.vertx.mutiny.redis.client.Response	bgrewriteaofAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	bgsave(List<String> args)
io.vertx.mutiny.redis.client.Response	bgsaveAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	bitcount(List<String> args)
io.vertx.mutiny.redis.client.Response	bitcountAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	bitfield(List<String> args)
io.vertx.mutiny.redis.client.Response	bitfieldAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	bitop(List<String> args)
io.vertx.mutiny.redis.client.Response	bitopAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	bitpos(List<String> args)
io.vertx.mutiny.redis.client.Response	bitposAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	blpop(List<String> args)
io.vertx.mutiny.redis.client.Response	blpopAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	brpop(List<String> args)
io.vertx.mutiny.redis.client.Response	brpopAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	brpoplpush(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	brpoplpushAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	bzpopmax(List<String> args)
io.vertx.mutiny.redis.client.Response	bzpopmaxAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	bzpopmin(List<String> args)
io.vertx.mutiny.redis.client.Response	bzpopminAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	client(List<String> args)
io.vertx.mutiny.redis.client.Response	clientAndAwait(List<String> args)
void	close()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	cluster(List<String> args)
io.vertx.mutiny.redis.client.Response	clusterAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	command()
io.vertx.mutiny.redis.client.Response	commandAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	config(List<String> args)
io.vertx.mutiny.redis.client.Response	configAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	dbsize()
io.vertx.mutiny.redis.client.Response	dbsizeAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	debug(List<String> args)
io.vertx.mutiny.redis.client.Response	debugAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	decr(String arg0)
io.vertx.mutiny.redis.client.Response	decrAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	decrby(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	decrbyAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	del(List<String> args)
io.vertx.mutiny.redis.client.Response	delAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	discard()
io.vertx.mutiny.redis.client.Response	discardAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	dump(String arg0)
io.vertx.mutiny.redis.client.Response	dumpAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	echo(String arg0)
io.vertx.mutiny.redis.client.Response	echoAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	eval(List<String> args)
io.vertx.mutiny.redis.client.Response	evalAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	evalsha(List<String> args)
io.vertx.mutiny.redis.client.Response	evalshaAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	exec()
io.vertx.mutiny.redis.client.Response	execAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	exists(List<String> args)
io.vertx.mutiny.redis.client.Response	existsAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	expire(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	expireAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	expireat(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	expireatAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	flushall(List<String> args)
io.vertx.mutiny.redis.client.Response	flushallAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	flushdb(List<String> args)
io.vertx.mutiny.redis.client.Response	flushdbAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	geoadd(List<String> args)
io.vertx.mutiny.redis.client.Response	geoaddAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	geodist(List<String> args)
io.vertx.mutiny.redis.client.Response	geodistAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	geohash(List<String> args)
io.vertx.mutiny.redis.client.Response	geohashAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	geopos(List<String> args)
io.vertx.mutiny.redis.client.Response	geoposAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	georadius(List<String> args)
io.vertx.mutiny.redis.client.Response	georadiusAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	georadiusbymember(List<String> args)
io.vertx.mutiny.redis.client.Response	georadiusbymemberAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	georadiusbymemberRo(List<String> args)
io.vertx.mutiny.redis.client.Response	georadiusbymemberRoAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	georadiusRo(List<String> args)
io.vertx.mutiny.redis.client.Response	georadiusRoAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	get(String arg0)
io.vertx.mutiny.redis.client.Response	getAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	getbit(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	getbitAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	getrange(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	getrangeAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	getset(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	getsetAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hdel(List<String> args)
io.vertx.mutiny.redis.client.Response	hdelAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hexists(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	hexistsAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hget(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hgetall(String arg0)
io.vertx.mutiny.redis.client.Response	hgetallAndAwait(String arg0)
io.vertx.mutiny.redis.client.Response	hgetAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hincrby(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	hincrbyAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hincrbyfloat(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	hincrbyfloatAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hkeys(String arg0)
io.vertx.mutiny.redis.client.Response	hkeysAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hlen(String arg0)
io.vertx.mutiny.redis.client.Response	hlenAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hmget(List<String> args)
io.vertx.mutiny.redis.client.Response	hmgetAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hmset(List<String> args)
io.vertx.mutiny.redis.client.Response	hmsetAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	host(List<String> args)
io.vertx.mutiny.redis.client.Response	hostAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hscan(List<String> args)
io.vertx.mutiny.redis.client.Response	hscanAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hset(List<String> args)
io.vertx.mutiny.redis.client.Response	hsetAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hsetnx(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	hsetnxAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hstrlen(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	hstrlenAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	hvals(String arg0)
io.vertx.mutiny.redis.client.Response	hvalsAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	incr(String arg0)
io.vertx.mutiny.redis.client.Response	incrAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	incrby(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	incrbyAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	incrbyfloat(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	incrbyfloatAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	info(List<String> args)
io.vertx.mutiny.redis.client.Response	infoAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	keys(String arg0)
io.vertx.mutiny.redis.client.Response	keysAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	lastsave()
io.vertx.mutiny.redis.client.Response	lastsaveAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	latency(List<String> args)
io.vertx.mutiny.redis.client.Response	latencyAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	lindex(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	lindexAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	linsert(String arg0, String arg1, String arg2, String arg3)
io.vertx.mutiny.redis.client.Response	linsertAndAwait(String arg0, String arg1, String arg2, String arg3)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	llen(String arg0)
io.vertx.mutiny.redis.client.Response	llenAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	lolwut(List<String> args)
io.vertx.mutiny.redis.client.Response	lolwutAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	lpop(String arg0)
io.vertx.mutiny.redis.client.Response	lpopAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	lpush(List<String> args)
io.vertx.mutiny.redis.client.Response	lpushAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	lpushx(List<String> args)
io.vertx.mutiny.redis.client.Response	lpushxAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	lrange(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	lrangeAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	lrem(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	lremAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	lset(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	lsetAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	ltrim(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	ltrimAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	memory(List<String> args)
io.vertx.mutiny.redis.client.Response	memoryAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	mget(List<String> args)
io.vertx.mutiny.redis.client.Response	mgetAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	migrate(List<String> args)
io.vertx.mutiny.redis.client.Response	migrateAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	module(List<String> args)
io.vertx.mutiny.redis.client.Response	moduleAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	monitor()
io.vertx.mutiny.redis.client.Response	monitorAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	move(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	moveAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	mset(List<String> args)
io.vertx.mutiny.redis.client.Response	msetAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	msetnx(List<String> args)
io.vertx.mutiny.redis.client.Response	msetnxAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	multi()
io.vertx.mutiny.redis.client.Response	multiAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	object(List<String> args)
io.vertx.mutiny.redis.client.Response	objectAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	persist(String arg0)
io.vertx.mutiny.redis.client.Response	persistAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	pexpire(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	pexpireAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	pexpireat(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	pexpireatAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	pfadd(List<String> args)
io.vertx.mutiny.redis.client.Response	pfaddAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	pfcount(List<String> args)
io.vertx.mutiny.redis.client.Response	pfcountAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	pfdebug(List<String> args)
io.vertx.mutiny.redis.client.Response	pfdebugAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	pfmerge(List<String> args)
io.vertx.mutiny.redis.client.Response	pfmergeAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	pfselftest()
io.vertx.mutiny.redis.client.Response	pfselftestAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	ping(List<String> args)
io.vertx.mutiny.redis.client.Response	pingAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	post(List<String> args)
io.vertx.mutiny.redis.client.Response	postAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	psetex(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	psetexAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	psubscribe(List<String> args)
io.vertx.mutiny.redis.client.Response	psubscribeAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	psync(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	psyncAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	pttl(String arg0)
io.vertx.mutiny.redis.client.Response	pttlAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	publish(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	publishAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	pubsub(List<String> args)
io.vertx.mutiny.redis.client.Response	pubsubAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	punsubscribe(List<String> args)
io.vertx.mutiny.redis.client.Response	punsubscribeAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	randomkey()
io.vertx.mutiny.redis.client.Response	randomkeyAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	readonly()
io.vertx.mutiny.redis.client.Response	readonlyAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	readwrite()
io.vertx.mutiny.redis.client.Response	readwriteAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	rename(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	renameAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	renamenx(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	renamenxAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	replconf(List<String> args)
io.vertx.mutiny.redis.client.Response	replconfAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	replicaof(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	replicaofAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	restore(List<String> args)
io.vertx.mutiny.redis.client.Response	restoreAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	restoreAsking(List<String> args)
io.vertx.mutiny.redis.client.Response	restoreAskingAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	role()
io.vertx.mutiny.redis.client.Response	roleAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	rpop(String arg0)
io.vertx.mutiny.redis.client.Response	rpopAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	rpoplpush(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	rpoplpushAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	rpush(List<String> args)
io.vertx.mutiny.redis.client.Response	rpushAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	rpushx(List<String> args)
io.vertx.mutiny.redis.client.Response	rpushxAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	sadd(List<String> args)
io.vertx.mutiny.redis.client.Response	saddAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	save()
io.vertx.mutiny.redis.client.Response	saveAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	scan(List<String> args)
io.vertx.mutiny.redis.client.Response	scanAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	scard(String arg0)
io.vertx.mutiny.redis.client.Response	scardAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	script(List<String> args)
io.vertx.mutiny.redis.client.Response	scriptAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	sdiff(List<String> args)
io.vertx.mutiny.redis.client.Response	sdiffAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	sdiffstore(List<String> args)
io.vertx.mutiny.redis.client.Response	sdiffstoreAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	select(String arg0)
io.vertx.mutiny.redis.client.Response	selectAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	set(List<String> args)
io.vertx.mutiny.redis.client.Response	setAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	setbit(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	setbitAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	setex(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	setexAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	setnx(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	setnxAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	setrange(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	setrangeAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	shutdown(List<String> args)
io.vertx.mutiny.redis.client.Response	shutdownAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	sinter(List<String> args)
io.vertx.mutiny.redis.client.Response	sinterAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	sinterstore(List<String> args)
io.vertx.mutiny.redis.client.Response	sinterstoreAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	sismember(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	sismemberAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	slaveof(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	slaveofAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	slowlog(List<String> args)
io.vertx.mutiny.redis.client.Response	slowlogAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	smembers(String arg0)
io.vertx.mutiny.redis.client.Response	smembersAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	smove(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	smoveAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	sort(List<String> args)
io.vertx.mutiny.redis.client.Response	sortAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	spop(List<String> args)
io.vertx.mutiny.redis.client.Response	spopAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	srandmember(List<String> args)
io.vertx.mutiny.redis.client.Response	srandmemberAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	srem(List<String> args)
io.vertx.mutiny.redis.client.Response	sremAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	sscan(List<String> args)
io.vertx.mutiny.redis.client.Response	sscanAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	strlen(String arg0)
io.vertx.mutiny.redis.client.Response	strlenAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	subscribe(List<String> args)
io.vertx.mutiny.redis.client.Response	subscribeAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	substr(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	substrAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	sunion(List<String> args)
io.vertx.mutiny.redis.client.Response	sunionAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	sunionstore(List<String> args)
io.vertx.mutiny.redis.client.Response	sunionstoreAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	swapdb(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	swapdbAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	sync()
io.vertx.mutiny.redis.client.Response	syncAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	time()
io.vertx.mutiny.redis.client.Response	timeAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	touch(List<String> args)
io.vertx.mutiny.redis.client.Response	touchAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	ttl(String arg0)
io.vertx.mutiny.redis.client.Response	ttlAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	type(String arg0)
io.vertx.mutiny.redis.client.Response	typeAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	unlink(List<String> args)
io.vertx.mutiny.redis.client.Response	unlinkAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	unsubscribe(List<String> args)
io.vertx.mutiny.redis.client.Response	unsubscribeAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	unwatch()
io.vertx.mutiny.redis.client.Response	unwatchAndAwait()
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	wait(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	waitAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	watch(List<String> args)
io.vertx.mutiny.redis.client.Response	watchAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xack(List<String> args)
io.vertx.mutiny.redis.client.Response	xackAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xadd(List<String> args)
io.vertx.mutiny.redis.client.Response	xaddAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xclaim(List<String> args)
io.vertx.mutiny.redis.client.Response	xclaimAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xdel(List<String> args)
io.vertx.mutiny.redis.client.Response	xdelAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xgroup(List<String> args)
io.vertx.mutiny.redis.client.Response	xgroupAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xinfo(List<String> args)
io.vertx.mutiny.redis.client.Response	xinfoAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xlen(String arg0)
io.vertx.mutiny.redis.client.Response	xlenAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xpending(List<String> args)
io.vertx.mutiny.redis.client.Response	xpendingAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xrange(List<String> args)
io.vertx.mutiny.redis.client.Response	xrangeAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xread(List<String> args)
io.vertx.mutiny.redis.client.Response	xreadAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xreadgroup(List<String> args)
io.vertx.mutiny.redis.client.Response	xreadgroupAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xrevrange(List<String> args)
io.vertx.mutiny.redis.client.Response	xrevrangeAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xsetid(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	xsetidAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	xtrim(List<String> args)
io.vertx.mutiny.redis.client.Response	xtrimAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zadd(List<String> args)
io.vertx.mutiny.redis.client.Response	zaddAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zcard(String arg0)
io.vertx.mutiny.redis.client.Response	zcardAndAwait(String arg0)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zcount(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	zcountAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zincrby(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	zincrbyAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zinterstore(List<String> args)
io.vertx.mutiny.redis.client.Response	zinterstoreAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zlexcount(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	zlexcountAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zpopmax(List<String> args)
io.vertx.mutiny.redis.client.Response	zpopmaxAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zpopmin(List<String> args)
io.vertx.mutiny.redis.client.Response	zpopminAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zrange(List<String> args)
io.vertx.mutiny.redis.client.Response	zrangeAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zrangebylex(List<String> args)
io.vertx.mutiny.redis.client.Response	zrangebylexAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zrangebyscore(List<String> args)
io.vertx.mutiny.redis.client.Response	zrangebyscoreAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zrank(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	zrankAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zrem(List<String> args)
io.vertx.mutiny.redis.client.Response	zremAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zremrangebylex(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	zremrangebylexAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zremrangebyrank(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	zremrangebyrankAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zremrangebyscore(String arg0, String arg1, String arg2)
io.vertx.mutiny.redis.client.Response	zremrangebyscoreAndAwait(String arg0, String arg1, String arg2)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zrevrange(List<String> args)
io.vertx.mutiny.redis.client.Response	zrevrangeAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zrevrangebylex(List<String> args)
io.vertx.mutiny.redis.client.Response	zrevrangebylexAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zrevrangebyscore(List<String> args)
io.vertx.mutiny.redis.client.Response	zrevrangebyscoreAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zrevrank(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	zrevrankAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zscan(List<String> args)
io.vertx.mutiny.redis.client.Response	zscanAndAwait(List<String> args)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zscore(String arg0, String arg1)
io.vertx.mutiny.redis.client.Response	zscoreAndAwait(String arg0, String arg1)
io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>	zunionstore(List<String> args)
io.vertx.mutiny.redis.client.Response	zunionstoreAndAwait(List<String> args)

Method Detail

close

void close()

append

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> append(String arg0,
                                                                     String arg1)

appendAndAwait

io.vertx.mutiny.redis.client.Response appendAndAwait(String arg0,
                                                     String arg1)

asking

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> asking()

askingAndAwait

io.vertx.mutiny.redis.client.Response askingAndAwait()

auth

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> auth(String arg0)

authAndAwait

io.vertx.mutiny.redis.client.Response authAndAwait(String arg0)

bgrewriteaof

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> bgrewriteaof()

bgrewriteaofAndAwait

io.vertx.mutiny.redis.client.Response bgrewriteaofAndAwait()

bgsave

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> bgsave(List<String> args)

bgsaveAndAwait

io.vertx.mutiny.redis.client.Response bgsaveAndAwait(List<String> args)

bitcount

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> bitcount(List<String> args)

bitcountAndAwait

io.vertx.mutiny.redis.client.Response bitcountAndAwait(List<String> args)

bitfield

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> bitfield(List<String> args)

bitfieldAndAwait

io.vertx.mutiny.redis.client.Response bitfieldAndAwait(List<String> args)

bitop

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> bitop(List<String> args)

bitopAndAwait

io.vertx.mutiny.redis.client.Response bitopAndAwait(List<String> args)

bitpos

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> bitpos(List<String> args)

bitposAndAwait

io.vertx.mutiny.redis.client.Response bitposAndAwait(List<String> args)

blpop

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> blpop(List<String> args)

blpopAndAwait

io.vertx.mutiny.redis.client.Response blpopAndAwait(List<String> args)

brpop

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> brpop(List<String> args)

brpopAndAwait

io.vertx.mutiny.redis.client.Response brpopAndAwait(List<String> args)

brpoplpush

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> brpoplpush(String arg0,
                                                                         String arg1,
                                                                         String arg2)

brpoplpushAndAwait

io.vertx.mutiny.redis.client.Response brpoplpushAndAwait(String arg0,
                                                         String arg1,
                                                         String arg2)

bzpopmax

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> bzpopmax(List<String> args)

bzpopmaxAndAwait

io.vertx.mutiny.redis.client.Response bzpopmaxAndAwait(List<String> args)

bzpopmin

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> bzpopmin(List<String> args)

bzpopminAndAwait

io.vertx.mutiny.redis.client.Response bzpopminAndAwait(List<String> args)

client

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> client(List<String> args)

clientAndAwait

io.vertx.mutiny.redis.client.Response clientAndAwait(List<String> args)

cluster

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> cluster(List<String> args)

clusterAndAwait

io.vertx.mutiny.redis.client.Response clusterAndAwait(List<String> args)

command

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> command()

commandAndAwait

io.vertx.mutiny.redis.client.Response commandAndAwait()

config

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> config(List<String> args)

configAndAwait

io.vertx.mutiny.redis.client.Response configAndAwait(List<String> args)

dbsize

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> dbsize()

dbsizeAndAwait

io.vertx.mutiny.redis.client.Response dbsizeAndAwait()

debug

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> debug(List<String> args)

debugAndAwait

io.vertx.mutiny.redis.client.Response debugAndAwait(List<String> args)

decr

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> decr(String arg0)

decrAndAwait

io.vertx.mutiny.redis.client.Response decrAndAwait(String arg0)

decrby

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> decrby(String arg0,
                                                                     String arg1)

decrbyAndAwait

io.vertx.mutiny.redis.client.Response decrbyAndAwait(String arg0,
                                                     String arg1)

del

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> del(List<String> args)

delAndAwait

io.vertx.mutiny.redis.client.Response delAndAwait(List<String> args)

discard

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> discard()

discardAndAwait

io.vertx.mutiny.redis.client.Response discardAndAwait()

dump

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> dump(String arg0)

dumpAndAwait

io.vertx.mutiny.redis.client.Response dumpAndAwait(String arg0)

echo

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> echo(String arg0)

echoAndAwait

io.vertx.mutiny.redis.client.Response echoAndAwait(String arg0)

eval

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> eval(List<String> args)

evalAndAwait

io.vertx.mutiny.redis.client.Response evalAndAwait(List<String> args)

evalsha

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> evalsha(List<String> args)

evalshaAndAwait

io.vertx.mutiny.redis.client.Response evalshaAndAwait(List<String> args)

exec

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> exec()

execAndAwait

io.vertx.mutiny.redis.client.Response execAndAwait()

exists

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> exists(List<String> args)

existsAndAwait

io.vertx.mutiny.redis.client.Response existsAndAwait(List<String> args)

expire

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> expire(String arg0,
                                                                     String arg1)

expireAndAwait

io.vertx.mutiny.redis.client.Response expireAndAwait(String arg0,
                                                     String arg1)

expireat

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> expireat(String arg0,
                                                                       String arg1)

expireatAndAwait

io.vertx.mutiny.redis.client.Response expireatAndAwait(String arg0,
                                                       String arg1)

flushall

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> flushall(List<String> args)

flushallAndAwait

io.vertx.mutiny.redis.client.Response flushallAndAwait(List<String> args)

flushdb

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> flushdb(List<String> args)

flushdbAndAwait

io.vertx.mutiny.redis.client.Response flushdbAndAwait(List<String> args)

geoadd

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> geoadd(List<String> args)

geoaddAndAwait

io.vertx.mutiny.redis.client.Response geoaddAndAwait(List<String> args)

geodist

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> geodist(List<String> args)

geodistAndAwait

io.vertx.mutiny.redis.client.Response geodistAndAwait(List<String> args)

geohash

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> geohash(List<String> args)

geohashAndAwait

io.vertx.mutiny.redis.client.Response geohashAndAwait(List<String> args)

geopos

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> geopos(List<String> args)

geoposAndAwait

io.vertx.mutiny.redis.client.Response geoposAndAwait(List<String> args)

georadius

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> georadius(List<String> args)

georadiusAndAwait

io.vertx.mutiny.redis.client.Response georadiusAndAwait(List<String> args)

georadiusRo

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> georadiusRo(List<String> args)

georadiusRoAndAwait

io.vertx.mutiny.redis.client.Response georadiusRoAndAwait(List<String> args)

georadiusbymember

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> georadiusbymember(List<String> args)

georadiusbymemberAndAwait

io.vertx.mutiny.redis.client.Response georadiusbymemberAndAwait(List<String> args)

georadiusbymemberRo

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> georadiusbymemberRo(List<String> args)

georadiusbymemberRoAndAwait

io.vertx.mutiny.redis.client.Response georadiusbymemberRoAndAwait(List<String> args)

get

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> get(String arg0)

getAndAwait

io.vertx.mutiny.redis.client.Response getAndAwait(String arg0)

getbit

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> getbit(String arg0,
                                                                     String arg1)

getbitAndAwait

io.vertx.mutiny.redis.client.Response getbitAndAwait(String arg0,
                                                     String arg1)

getrange

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> getrange(String arg0,
                                                                       String arg1,
                                                                       String arg2)

getrangeAndAwait

io.vertx.mutiny.redis.client.Response getrangeAndAwait(String arg0,
                                                       String arg1,
                                                       String arg2)

getset

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> getset(String arg0,
                                                                     String arg1)

getsetAndAwait

io.vertx.mutiny.redis.client.Response getsetAndAwait(String arg0,
                                                     String arg1)

hdel

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hdel(List<String> args)

hdelAndAwait

io.vertx.mutiny.redis.client.Response hdelAndAwait(List<String> args)

hexists

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hexists(String arg0,
                                                                      String arg1)

hexistsAndAwait

io.vertx.mutiny.redis.client.Response hexistsAndAwait(String arg0,
                                                      String arg1)

hget

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hget(String arg0,
                                                                   String arg1)

hgetAndAwait

io.vertx.mutiny.redis.client.Response hgetAndAwait(String arg0,
                                                   String arg1)

hgetall

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hgetall(String arg0)

hgetallAndAwait

io.vertx.mutiny.redis.client.Response hgetallAndAwait(String arg0)

hincrby

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hincrby(String arg0,
                                                                      String arg1,
                                                                      String arg2)

hincrbyAndAwait

io.vertx.mutiny.redis.client.Response hincrbyAndAwait(String arg0,
                                                      String arg1,
                                                      String arg2)

hincrbyfloat

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hincrbyfloat(String arg0,
                                                                           String arg1,
                                                                           String arg2)

hincrbyfloatAndAwait

io.vertx.mutiny.redis.client.Response hincrbyfloatAndAwait(String arg0,
                                                           String arg1,
                                                           String arg2)

hkeys

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hkeys(String arg0)

hkeysAndAwait

io.vertx.mutiny.redis.client.Response hkeysAndAwait(String arg0)

hlen

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hlen(String arg0)

hlenAndAwait

io.vertx.mutiny.redis.client.Response hlenAndAwait(String arg0)

hmget

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hmget(List<String> args)

hmgetAndAwait

io.vertx.mutiny.redis.client.Response hmgetAndAwait(List<String> args)

hmset

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hmset(List<String> args)

hmsetAndAwait

io.vertx.mutiny.redis.client.Response hmsetAndAwait(List<String> args)

host

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> host(List<String> args)

hostAndAwait

io.vertx.mutiny.redis.client.Response hostAndAwait(List<String> args)

hscan

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hscan(List<String> args)

hscanAndAwait

io.vertx.mutiny.redis.client.Response hscanAndAwait(List<String> args)

hset

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hset(List<String> args)

hsetAndAwait

io.vertx.mutiny.redis.client.Response hsetAndAwait(List<String> args)

hsetnx

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hsetnx(String arg0,
                                                                     String arg1,
                                                                     String arg2)

hsetnxAndAwait

io.vertx.mutiny.redis.client.Response hsetnxAndAwait(String arg0,
                                                     String arg1,
                                                     String arg2)

hstrlen

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hstrlen(String arg0,
                                                                      String arg1)

hstrlenAndAwait

io.vertx.mutiny.redis.client.Response hstrlenAndAwait(String arg0,
                                                      String arg1)

hvals

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> hvals(String arg0)

hvalsAndAwait

io.vertx.mutiny.redis.client.Response hvalsAndAwait(String arg0)

incr

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> incr(String arg0)

incrAndAwait

io.vertx.mutiny.redis.client.Response incrAndAwait(String arg0)

incrby

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> incrby(String arg0,
                                                                     String arg1)

incrbyAndAwait

io.vertx.mutiny.redis.client.Response incrbyAndAwait(String arg0,
                                                     String arg1)

incrbyfloat

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> incrbyfloat(String arg0,
                                                                          String arg1)

incrbyfloatAndAwait

io.vertx.mutiny.redis.client.Response incrbyfloatAndAwait(String arg0,
                                                          String arg1)

info

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> info(List<String> args)

infoAndAwait

io.vertx.mutiny.redis.client.Response infoAndAwait(List<String> args)

keys

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> keys(String arg0)

keysAndAwait

io.vertx.mutiny.redis.client.Response keysAndAwait(String arg0)

lastsave

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> lastsave()

lastsaveAndAwait

io.vertx.mutiny.redis.client.Response lastsaveAndAwait()

latency

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> latency(List<String> args)

latencyAndAwait

io.vertx.mutiny.redis.client.Response latencyAndAwait(List<String> args)

lindex

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> lindex(String arg0,
                                                                     String arg1)

lindexAndAwait

io.vertx.mutiny.redis.client.Response lindexAndAwait(String arg0,
                                                     String arg1)

linsert

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> linsert(String arg0,
                                                                      String arg1,
                                                                      String arg2,
                                                                      String arg3)

linsertAndAwait

io.vertx.mutiny.redis.client.Response linsertAndAwait(String arg0,
                                                      String arg1,
                                                      String arg2,
                                                      String arg3)

llen

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> llen(String arg0)

llenAndAwait

io.vertx.mutiny.redis.client.Response llenAndAwait(String arg0)

lolwut

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> lolwut(List<String> args)

lolwutAndAwait

io.vertx.mutiny.redis.client.Response lolwutAndAwait(List<String> args)

lpop

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> lpop(String arg0)

lpopAndAwait

io.vertx.mutiny.redis.client.Response lpopAndAwait(String arg0)

lpush

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> lpush(List<String> args)

lpushAndAwait

io.vertx.mutiny.redis.client.Response lpushAndAwait(List<String> args)

lpushx

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> lpushx(List<String> args)

lpushxAndAwait

io.vertx.mutiny.redis.client.Response lpushxAndAwait(List<String> args)

lrange

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> lrange(String arg0,
                                                                     String arg1,
                                                                     String arg2)

lrangeAndAwait

io.vertx.mutiny.redis.client.Response lrangeAndAwait(String arg0,
                                                     String arg1,
                                                     String arg2)

lrem

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> lrem(String arg0,
                                                                   String arg1,
                                                                   String arg2)

lremAndAwait

io.vertx.mutiny.redis.client.Response lremAndAwait(String arg0,
                                                   String arg1,
                                                   String arg2)

lset

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> lset(String arg0,
                                                                   String arg1,
                                                                   String arg2)

lsetAndAwait

io.vertx.mutiny.redis.client.Response lsetAndAwait(String arg0,
                                                   String arg1,
                                                   String arg2)

ltrim

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> ltrim(String arg0,
                                                                    String arg1,
                                                                    String arg2)

ltrimAndAwait

io.vertx.mutiny.redis.client.Response ltrimAndAwait(String arg0,
                                                    String arg1,
                                                    String arg2)

memory

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> memory(List<String> args)

memoryAndAwait

io.vertx.mutiny.redis.client.Response memoryAndAwait(List<String> args)

mget

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> mget(List<String> args)

mgetAndAwait

io.vertx.mutiny.redis.client.Response mgetAndAwait(List<String> args)

migrate

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> migrate(List<String> args)

migrateAndAwait

io.vertx.mutiny.redis.client.Response migrateAndAwait(List<String> args)

module

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> module(List<String> args)

moduleAndAwait

io.vertx.mutiny.redis.client.Response moduleAndAwait(List<String> args)

monitor

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> monitor()

monitorAndAwait

io.vertx.mutiny.redis.client.Response monitorAndAwait()

move

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> move(String arg0,
                                                                   String arg1)

moveAndAwait

io.vertx.mutiny.redis.client.Response moveAndAwait(String arg0,
                                                   String arg1)

mset

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> mset(List<String> args)

msetAndAwait

io.vertx.mutiny.redis.client.Response msetAndAwait(List<String> args)

msetnx

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> msetnx(List<String> args)

msetnxAndAwait

io.vertx.mutiny.redis.client.Response msetnxAndAwait(List<String> args)

multi

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> multi()

multiAndAwait

io.vertx.mutiny.redis.client.Response multiAndAwait()

object

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> object(List<String> args)

objectAndAwait

io.vertx.mutiny.redis.client.Response objectAndAwait(List<String> args)

persist

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> persist(String arg0)

persistAndAwait

io.vertx.mutiny.redis.client.Response persistAndAwait(String arg0)

pexpire

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> pexpire(String arg0,
                                                                      String arg1)

pexpireAndAwait

io.vertx.mutiny.redis.client.Response pexpireAndAwait(String arg0,
                                                      String arg1)

pexpireat

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> pexpireat(String arg0,
                                                                        String arg1)

pexpireatAndAwait

io.vertx.mutiny.redis.client.Response pexpireatAndAwait(String arg0,
                                                        String arg1)

pfadd

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> pfadd(List<String> args)

pfaddAndAwait

io.vertx.mutiny.redis.client.Response pfaddAndAwait(List<String> args)

pfcount

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> pfcount(List<String> args)

pfcountAndAwait

io.vertx.mutiny.redis.client.Response pfcountAndAwait(List<String> args)

pfdebug

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> pfdebug(List<String> args)

pfdebugAndAwait

io.vertx.mutiny.redis.client.Response pfdebugAndAwait(List<String> args)

pfmerge

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> pfmerge(List<String> args)

pfmergeAndAwait

io.vertx.mutiny.redis.client.Response pfmergeAndAwait(List<String> args)

pfselftest

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> pfselftest()

pfselftestAndAwait

io.vertx.mutiny.redis.client.Response pfselftestAndAwait()

ping

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> ping(List<String> args)

pingAndAwait

io.vertx.mutiny.redis.client.Response pingAndAwait(List<String> args)

post

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> post(List<String> args)

postAndAwait

io.vertx.mutiny.redis.client.Response postAndAwait(List<String> args)

psetex

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> psetex(String arg0,
                                                                     String arg1,
                                                                     String arg2)

psetexAndAwait

io.vertx.mutiny.redis.client.Response psetexAndAwait(String arg0,
                                                     String arg1,
                                                     String arg2)

psubscribe

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> psubscribe(List<String> args)

psubscribeAndAwait

io.vertx.mutiny.redis.client.Response psubscribeAndAwait(List<String> args)

psync

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> psync(String arg0,
                                                                    String arg1)

psyncAndAwait

io.vertx.mutiny.redis.client.Response psyncAndAwait(String arg0,
                                                    String arg1)

pttl

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> pttl(String arg0)

pttlAndAwait

io.vertx.mutiny.redis.client.Response pttlAndAwait(String arg0)

publish

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> publish(String arg0,
                                                                      String arg1)

publishAndAwait

io.vertx.mutiny.redis.client.Response publishAndAwait(String arg0,
                                                      String arg1)

pubsub

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> pubsub(List<String> args)

pubsubAndAwait

io.vertx.mutiny.redis.client.Response pubsubAndAwait(List<String> args)

punsubscribe

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> punsubscribe(List<String> args)

punsubscribeAndAwait

io.vertx.mutiny.redis.client.Response punsubscribeAndAwait(List<String> args)

randomkey

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> randomkey()

randomkeyAndAwait

io.vertx.mutiny.redis.client.Response randomkeyAndAwait()

readonly

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> readonly()

readonlyAndAwait

io.vertx.mutiny.redis.client.Response readonlyAndAwait()

readwrite

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> readwrite()

readwriteAndAwait

io.vertx.mutiny.redis.client.Response readwriteAndAwait()

rename

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> rename(String arg0,
                                                                     String arg1)

renameAndAwait

io.vertx.mutiny.redis.client.Response renameAndAwait(String arg0,
                                                     String arg1)

renamenx

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> renamenx(String arg0,
                                                                       String arg1)

renamenxAndAwait

io.vertx.mutiny.redis.client.Response renamenxAndAwait(String arg0,
                                                       String arg1)

replconf

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> replconf(List<String> args)

replconfAndAwait

io.vertx.mutiny.redis.client.Response replconfAndAwait(List<String> args)

replicaof

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> replicaof(String arg0,
                                                                        String arg1)

replicaofAndAwait

io.vertx.mutiny.redis.client.Response replicaofAndAwait(String arg0,
                                                        String arg1)

restore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> restore(List<String> args)

restoreAndAwait

io.vertx.mutiny.redis.client.Response restoreAndAwait(List<String> args)

restoreAsking

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> restoreAsking(List<String> args)

restoreAskingAndAwait

io.vertx.mutiny.redis.client.Response restoreAskingAndAwait(List<String> args)

role

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> role()

roleAndAwait

io.vertx.mutiny.redis.client.Response roleAndAwait()

rpop

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> rpop(String arg0)

rpopAndAwait

io.vertx.mutiny.redis.client.Response rpopAndAwait(String arg0)

rpoplpush

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> rpoplpush(String arg0,
                                                                        String arg1)

rpoplpushAndAwait

io.vertx.mutiny.redis.client.Response rpoplpushAndAwait(String arg0,
                                                        String arg1)

rpush

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> rpush(List<String> args)

rpushAndAwait

io.vertx.mutiny.redis.client.Response rpushAndAwait(List<String> args)

rpushx

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> rpushx(List<String> args)

rpushxAndAwait

io.vertx.mutiny.redis.client.Response rpushxAndAwait(List<String> args)

sadd

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> sadd(List<String> args)

saddAndAwait

io.vertx.mutiny.redis.client.Response saddAndAwait(List<String> args)

save

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> save()

saveAndAwait

io.vertx.mutiny.redis.client.Response saveAndAwait()

scan

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> scan(List<String> args)

scanAndAwait

io.vertx.mutiny.redis.client.Response scanAndAwait(List<String> args)

scard

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> scard(String arg0)

scardAndAwait

io.vertx.mutiny.redis.client.Response scardAndAwait(String arg0)

script

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> script(List<String> args)

scriptAndAwait

io.vertx.mutiny.redis.client.Response scriptAndAwait(List<String> args)

sdiff

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> sdiff(List<String> args)

sdiffAndAwait

io.vertx.mutiny.redis.client.Response sdiffAndAwait(List<String> args)

sdiffstore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> sdiffstore(List<String> args)

sdiffstoreAndAwait

io.vertx.mutiny.redis.client.Response sdiffstoreAndAwait(List<String> args)

select

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> select(String arg0)

selectAndAwait

io.vertx.mutiny.redis.client.Response selectAndAwait(String arg0)

set

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> set(List<String> args)

setAndAwait

io.vertx.mutiny.redis.client.Response setAndAwait(List<String> args)

setbit

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> setbit(String arg0,
                                                                     String arg1,
                                                                     String arg2)

setbitAndAwait

io.vertx.mutiny.redis.client.Response setbitAndAwait(String arg0,
                                                     String arg1,
                                                     String arg2)

setex

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> setex(String arg0,
                                                                    String arg1,
                                                                    String arg2)

setexAndAwait

io.vertx.mutiny.redis.client.Response setexAndAwait(String arg0,
                                                    String arg1,
                                                    String arg2)

setnx

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> setnx(String arg0,
                                                                    String arg1)

setnxAndAwait

io.vertx.mutiny.redis.client.Response setnxAndAwait(String arg0,
                                                    String arg1)

setrange

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> setrange(String arg0,
                                                                       String arg1,
                                                                       String arg2)

setrangeAndAwait

io.vertx.mutiny.redis.client.Response setrangeAndAwait(String arg0,
                                                       String arg1,
                                                       String arg2)

shutdown

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> shutdown(List<String> args)

shutdownAndAwait

io.vertx.mutiny.redis.client.Response shutdownAndAwait(List<String> args)

sinter

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> sinter(List<String> args)

sinterAndAwait

io.vertx.mutiny.redis.client.Response sinterAndAwait(List<String> args)

sinterstore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> sinterstore(List<String> args)

sinterstoreAndAwait

io.vertx.mutiny.redis.client.Response sinterstoreAndAwait(List<String> args)

sismember

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> sismember(String arg0,
                                                                        String arg1)

sismemberAndAwait

io.vertx.mutiny.redis.client.Response sismemberAndAwait(String arg0,
                                                        String arg1)

slaveof

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> slaveof(String arg0,
                                                                      String arg1)

slaveofAndAwait

io.vertx.mutiny.redis.client.Response slaveofAndAwait(String arg0,
                                                      String arg1)

slowlog

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> slowlog(List<String> args)

slowlogAndAwait

io.vertx.mutiny.redis.client.Response slowlogAndAwait(List<String> args)

smembers

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> smembers(String arg0)

smembersAndAwait

io.vertx.mutiny.redis.client.Response smembersAndAwait(String arg0)

smove

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> smove(String arg0,
                                                                    String arg1,
                                                                    String arg2)

smoveAndAwait

io.vertx.mutiny.redis.client.Response smoveAndAwait(String arg0,
                                                    String arg1,
                                                    String arg2)

sort

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> sort(List<String> args)

sortAndAwait

io.vertx.mutiny.redis.client.Response sortAndAwait(List<String> args)

spop

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> spop(List<String> args)

spopAndAwait

io.vertx.mutiny.redis.client.Response spopAndAwait(List<String> args)

srandmember

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> srandmember(List<String> args)

srandmemberAndAwait

io.vertx.mutiny.redis.client.Response srandmemberAndAwait(List<String> args)

srem

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> srem(List<String> args)

sremAndAwait

io.vertx.mutiny.redis.client.Response sremAndAwait(List<String> args)

sscan

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> sscan(List<String> args)

sscanAndAwait

io.vertx.mutiny.redis.client.Response sscanAndAwait(List<String> args)

strlen

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> strlen(String arg0)

strlenAndAwait

io.vertx.mutiny.redis.client.Response strlenAndAwait(String arg0)

subscribe

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> subscribe(List<String> args)

subscribeAndAwait

io.vertx.mutiny.redis.client.Response subscribeAndAwait(List<String> args)

substr

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> substr(String arg0,
                                                                     String arg1,
                                                                     String arg2)

substrAndAwait

io.vertx.mutiny.redis.client.Response substrAndAwait(String arg0,
                                                     String arg1,
                                                     String arg2)

sunion

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> sunion(List<String> args)

sunionAndAwait

io.vertx.mutiny.redis.client.Response sunionAndAwait(List<String> args)

sunionstore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> sunionstore(List<String> args)

sunionstoreAndAwait

io.vertx.mutiny.redis.client.Response sunionstoreAndAwait(List<String> args)

swapdb

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> swapdb(String arg0,
                                                                     String arg1)

swapdbAndAwait

io.vertx.mutiny.redis.client.Response swapdbAndAwait(String arg0,
                                                     String arg1)

sync

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> sync()

syncAndAwait

io.vertx.mutiny.redis.client.Response syncAndAwait()

time

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> time()

timeAndAwait

io.vertx.mutiny.redis.client.Response timeAndAwait()

touch

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> touch(List<String> args)

touchAndAwait

io.vertx.mutiny.redis.client.Response touchAndAwait(List<String> args)

ttl

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> ttl(String arg0)

ttlAndAwait

io.vertx.mutiny.redis.client.Response ttlAndAwait(String arg0)

type

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> type(String arg0)

typeAndAwait

io.vertx.mutiny.redis.client.Response typeAndAwait(String arg0)

unlink

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> unlink(List<String> args)

unlinkAndAwait

io.vertx.mutiny.redis.client.Response unlinkAndAwait(List<String> args)

unsubscribe

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> unsubscribe(List<String> args)

unsubscribeAndAwait

io.vertx.mutiny.redis.client.Response unsubscribeAndAwait(List<String> args)

unwatch

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> unwatch()

unwatchAndAwait

io.vertx.mutiny.redis.client.Response unwatchAndAwait()

wait

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> wait(String arg0,
                                                                   String arg1)

waitAndAwait

io.vertx.mutiny.redis.client.Response waitAndAwait(String arg0,
                                                   String arg1)

watch

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> watch(List<String> args)

watchAndAwait

io.vertx.mutiny.redis.client.Response watchAndAwait(List<String> args)

xack

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xack(List<String> args)

xackAndAwait

io.vertx.mutiny.redis.client.Response xackAndAwait(List<String> args)

xadd

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xadd(List<String> args)

xaddAndAwait

io.vertx.mutiny.redis.client.Response xaddAndAwait(List<String> args)

xclaim

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xclaim(List<String> args)

xclaimAndAwait

io.vertx.mutiny.redis.client.Response xclaimAndAwait(List<String> args)

xdel

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xdel(List<String> args)

xdelAndAwait

io.vertx.mutiny.redis.client.Response xdelAndAwait(List<String> args)

xgroup

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xgroup(List<String> args)

xgroupAndAwait

io.vertx.mutiny.redis.client.Response xgroupAndAwait(List<String> args)

xinfo

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xinfo(List<String> args)

xinfoAndAwait

io.vertx.mutiny.redis.client.Response xinfoAndAwait(List<String> args)

xlen

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xlen(String arg0)

xlenAndAwait

io.vertx.mutiny.redis.client.Response xlenAndAwait(String arg0)

xpending

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xpending(List<String> args)

xpendingAndAwait

io.vertx.mutiny.redis.client.Response xpendingAndAwait(List<String> args)

xrange

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xrange(List<String> args)

xrangeAndAwait

io.vertx.mutiny.redis.client.Response xrangeAndAwait(List<String> args)

xread

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xread(List<String> args)

xreadAndAwait

io.vertx.mutiny.redis.client.Response xreadAndAwait(List<String> args)

xreadgroup

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xreadgroup(List<String> args)

xreadgroupAndAwait

io.vertx.mutiny.redis.client.Response xreadgroupAndAwait(List<String> args)

xrevrange

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xrevrange(List<String> args)

xrevrangeAndAwait

io.vertx.mutiny.redis.client.Response xrevrangeAndAwait(List<String> args)

xsetid

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xsetid(String arg0,
                                                                     String arg1)

xsetidAndAwait

io.vertx.mutiny.redis.client.Response xsetidAndAwait(String arg0,
                                                     String arg1)

xtrim

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> xtrim(List<String> args)

xtrimAndAwait

io.vertx.mutiny.redis.client.Response xtrimAndAwait(List<String> args)

zadd

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zadd(List<String> args)

zaddAndAwait

io.vertx.mutiny.redis.client.Response zaddAndAwait(List<String> args)

zcard

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zcard(String arg0)

zcardAndAwait

io.vertx.mutiny.redis.client.Response zcardAndAwait(String arg0)

zcount

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zcount(String arg0,
                                                                     String arg1,
                                                                     String arg2)

zcountAndAwait

io.vertx.mutiny.redis.client.Response zcountAndAwait(String arg0,
                                                     String arg1,
                                                     String arg2)

zincrby

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zincrby(String arg0,
                                                                      String arg1,
                                                                      String arg2)

zincrbyAndAwait

io.vertx.mutiny.redis.client.Response zincrbyAndAwait(String arg0,
                                                      String arg1,
                                                      String arg2)

zinterstore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zinterstore(List<String> args)

zinterstoreAndAwait

io.vertx.mutiny.redis.client.Response zinterstoreAndAwait(List<String> args)

zlexcount

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zlexcount(String arg0,
                                                                        String arg1,
                                                                        String arg2)

zlexcountAndAwait

io.vertx.mutiny.redis.client.Response zlexcountAndAwait(String arg0,
                                                        String arg1,
                                                        String arg2)

zpopmax

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zpopmax(List<String> args)

zpopmaxAndAwait

io.vertx.mutiny.redis.client.Response zpopmaxAndAwait(List<String> args)

zpopmin

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zpopmin(List<String> args)

zpopminAndAwait

io.vertx.mutiny.redis.client.Response zpopminAndAwait(List<String> args)

zrange

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zrange(List<String> args)

zrangeAndAwait

io.vertx.mutiny.redis.client.Response zrangeAndAwait(List<String> args)

zrangebylex

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zrangebylex(List<String> args)

zrangebylexAndAwait

io.vertx.mutiny.redis.client.Response zrangebylexAndAwait(List<String> args)

zrangebyscore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zrangebyscore(List<String> args)

zrangebyscoreAndAwait

io.vertx.mutiny.redis.client.Response zrangebyscoreAndAwait(List<String> args)

zrank

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zrank(String arg0,
                                                                    String arg1)

zrankAndAwait

io.vertx.mutiny.redis.client.Response zrankAndAwait(String arg0,
                                                    String arg1)

zrem

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zrem(List<String> args)

zremAndAwait

io.vertx.mutiny.redis.client.Response zremAndAwait(List<String> args)

zremrangebylex

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zremrangebylex(String arg0,
                                                                             String arg1,
                                                                             String arg2)

zremrangebylexAndAwait

io.vertx.mutiny.redis.client.Response zremrangebylexAndAwait(String arg0,
                                                             String arg1,
                                                             String arg2)

zremrangebyrank

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zremrangebyrank(String arg0,
                                                                              String arg1,
                                                                              String arg2)

zremrangebyrankAndAwait

io.vertx.mutiny.redis.client.Response zremrangebyrankAndAwait(String arg0,
                                                              String arg1,
                                                              String arg2)

zremrangebyscore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zremrangebyscore(String arg0,
                                                                               String arg1,
                                                                               String arg2)

zremrangebyscoreAndAwait

io.vertx.mutiny.redis.client.Response zremrangebyscoreAndAwait(String arg0,
                                                               String arg1,
                                                               String arg2)

zrevrange

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zrevrange(List<String> args)

zrevrangeAndAwait

io.vertx.mutiny.redis.client.Response zrevrangeAndAwait(List<String> args)

zrevrangebylex

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zrevrangebylex(List<String> args)

zrevrangebylexAndAwait

io.vertx.mutiny.redis.client.Response zrevrangebylexAndAwait(List<String> args)

zrevrangebyscore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zrevrangebyscore(List<String> args)

zrevrangebyscoreAndAwait

io.vertx.mutiny.redis.client.Response zrevrangebyscoreAndAwait(List<String> args)

zrevrank

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zrevrank(String arg0,
                                                                       String arg1)

zrevrankAndAwait

io.vertx.mutiny.redis.client.Response zrevrankAndAwait(String arg0,
                                                       String arg1)

zscan

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zscan(List<String> args)

zscanAndAwait

io.vertx.mutiny.redis.client.Response zscanAndAwait(List<String> args)

zscore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zscore(String arg0,
                                                                     String arg1)

zscoreAndAwait

io.vertx.mutiny.redis.client.Response zscoreAndAwait(String arg0,
                                                     String arg1)

zunionstore

io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response> zunionstore(List<String> args)

zunionstoreAndAwait

io.vertx.mutiny.redis.client.Response zunionstoreAndAwait(List<String> args)