java.lang.Object
- io.quarkus.redis.runtime.client.ReactiveRedisClientImpl

All Implemented Interfaces:: ReactiveRedisClient

class ReactiveRedisClientImpl
extends Object
implements ReactiveRedisClient

Constructor Summary

Constructors
Constructor Description

ReactiveRedisClientImpl(io.vertx.mutiny.redis.client.Redis redis, io.vertx.mutiny.redis.client.RedisAPI redisAPI)

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	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(List<String> args)`
`io.vertx.mutiny.redis.client.Response`	`authAndAwait(List<String> args)`
`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(List<String> args)`
`io.vertx.mutiny.redis.client.Response`	`commandAndAwait(List<String> args)`
`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.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>`	`lpop(List<String> arg0)`
`io.vertx.mutiny.redis.client.Response`	`lpopAndAwait(String arg0)`
`io.vertx.mutiny.redis.client.Response`	`lpopAndAwait(List<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.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>`	`psync(List<String> args)`
`io.vertx.mutiny.redis.client.Response`	`psyncAndAwait(String arg0, String arg1)`
`io.vertx.mutiny.redis.client.Response`	`psyncAndAwait(List<String> args)`
`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.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>`	`rpop(List<String> args)`
`io.vertx.mutiny.redis.client.Response`	`rpopAndAwait(String arg0)`
`io.vertx.mutiny.redis.client.Response`	`rpopAndAwait(List<String> args)`
`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>`	`zunion(List<String> args)`
`io.vertx.mutiny.redis.client.Response`	`zunionAndAwait(List<String> args)`
`io.smallrye.mutiny.Uni<io.vertx.mutiny.redis.client.Response>`	`zunionstore(List<String> args)`
`io.vertx.mutiny.redis.client.Response`	`zunionstoreAndAwait(List<String> args)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ReactiveRedisClientImpl

public ReactiveRedisClientImpl(io.vertx.mutiny.redis.client.Redis redis,
                               io.vertx.mutiny.redis.client.RedisAPI redisAPI)

Method Detail

close
```
public void close()
```
Specified by:

close in interface ReactiveRedisClient

append

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

Specified by:: append in interface ReactiveRedisClient

appendAndAwait

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

Specified by:: appendAndAwait in interface ReactiveRedisClient

asking

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

Specified by:: asking in interface ReactiveRedisClient

askingAndAwait
```
public io.vertx.mutiny.redis.client.Response askingAndAwait()
```
Specified by:

askingAndAwait in interface ReactiveRedisClient

auth

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

Specified by:: auth in interface ReactiveRedisClient

authAndAwait

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

Specified by:: authAndAwait in interface ReactiveRedisClient

bgrewriteaof

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

Specified by:: bgrewriteaof in interface ReactiveRedisClient

bgrewriteaofAndAwait
```
public io.vertx.mutiny.redis.client.Response bgrewriteaofAndAwait()
```
Specified by:

bgrewriteaofAndAwait in interface ReactiveRedisClient

bgsave

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

Specified by:: bgsave in interface ReactiveRedisClient

bgsaveAndAwait

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

Specified by:: bgsaveAndAwait in interface ReactiveRedisClient

bitcount

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

Specified by:: bitcount in interface ReactiveRedisClient

bitcountAndAwait

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

Specified by:: bitcountAndAwait in interface ReactiveRedisClient

bitfield

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

Specified by:: bitfield in interface ReactiveRedisClient

bitfieldAndAwait

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

Specified by:: bitfieldAndAwait in interface ReactiveRedisClient

bitop

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

Specified by:: bitop in interface ReactiveRedisClient

bitopAndAwait

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

Specified by:: bitopAndAwait in interface ReactiveRedisClient

bitpos

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

Specified by:: bitpos in interface ReactiveRedisClient

bitposAndAwait

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

Specified by:: bitposAndAwait in interface ReactiveRedisClient

blpop

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

Specified by:: blpop in interface ReactiveRedisClient

blpopAndAwait

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

Specified by:: blpopAndAwait in interface ReactiveRedisClient

brpop

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

Specified by:: brpop in interface ReactiveRedisClient

brpopAndAwait

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

Specified by:: brpopAndAwait in interface ReactiveRedisClient

brpoplpush

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

Specified by:: brpoplpush in interface ReactiveRedisClient

brpoplpushAndAwait

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

Specified by:: brpoplpushAndAwait in interface ReactiveRedisClient

bzpopmax

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

Specified by:: bzpopmax in interface ReactiveRedisClient

bzpopmaxAndAwait

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

Specified by:: bzpopmaxAndAwait in interface ReactiveRedisClient

bzpopmin

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

Specified by:: bzpopmin in interface ReactiveRedisClient

bzpopminAndAwait

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

Specified by:: bzpopminAndAwait in interface ReactiveRedisClient

client

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

Specified by:: client in interface ReactiveRedisClient

clientAndAwait

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

Specified by:: clientAndAwait in interface ReactiveRedisClient

cluster

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

Specified by:: cluster in interface ReactiveRedisClient

clusterAndAwait

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

Specified by:: clusterAndAwait in interface ReactiveRedisClient

command

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

Specified by:: command in interface ReactiveRedisClient

commandAndAwait

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

Specified by:: commandAndAwait in interface ReactiveRedisClient

config

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

Specified by:: config in interface ReactiveRedisClient

configAndAwait

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

Specified by:: configAndAwait in interface ReactiveRedisClient

dbsize

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

Specified by:: dbsize in interface ReactiveRedisClient

dbsizeAndAwait
```
public io.vertx.mutiny.redis.client.Response dbsizeAndAwait()
```
Specified by:

dbsizeAndAwait in interface ReactiveRedisClient

debug

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

Specified by:: debug in interface ReactiveRedisClient

debugAndAwait

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

Specified by:: debugAndAwait in interface ReactiveRedisClient

decr

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

Specified by:: decr in interface ReactiveRedisClient

decrAndAwait

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

Specified by:: decrAndAwait in interface ReactiveRedisClient

decrby

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

Specified by:: decrby in interface ReactiveRedisClient

decrbyAndAwait

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

Specified by:: decrbyAndAwait in interface ReactiveRedisClient

del

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

Specified by:: del in interface ReactiveRedisClient

delAndAwait

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

Specified by:: delAndAwait in interface ReactiveRedisClient

discard

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

Specified by:: discard in interface ReactiveRedisClient

discardAndAwait
```
public io.vertx.mutiny.redis.client.Response discardAndAwait()
```
Specified by:

discardAndAwait in interface ReactiveRedisClient

dump

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

Specified by:: dump in interface ReactiveRedisClient

dumpAndAwait

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

Specified by:: dumpAndAwait in interface ReactiveRedisClient

echo

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

Specified by:: echo in interface ReactiveRedisClient

echoAndAwait

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

Specified by:: echoAndAwait in interface ReactiveRedisClient

eval

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

Specified by:: eval in interface ReactiveRedisClient

evalAndAwait

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

Specified by:: evalAndAwait in interface ReactiveRedisClient

evalsha

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

Specified by:: evalsha in interface ReactiveRedisClient

evalshaAndAwait

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

Specified by:: evalshaAndAwait in interface ReactiveRedisClient

exec

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

Specified by:: exec in interface ReactiveRedisClient

execAndAwait
```
public io.vertx.mutiny.redis.client.Response execAndAwait()
```
Specified by:

execAndAwait in interface ReactiveRedisClient

exists

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

Specified by:: exists in interface ReactiveRedisClient

existsAndAwait

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

Specified by:: existsAndAwait in interface ReactiveRedisClient

expire

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

Specified by:: expire in interface ReactiveRedisClient

expireAndAwait

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

Specified by:: expireAndAwait in interface ReactiveRedisClient

expireat

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

Specified by:: expireat in interface ReactiveRedisClient

expireatAndAwait

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

Specified by:: expireatAndAwait in interface ReactiveRedisClient

flushall

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

Specified by:: flushall in interface ReactiveRedisClient

flushallAndAwait

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

Specified by:: flushallAndAwait in interface ReactiveRedisClient

flushdb

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

Specified by:: flushdb in interface ReactiveRedisClient

flushdbAndAwait

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

Specified by:: flushdbAndAwait in interface ReactiveRedisClient

geoadd

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

Specified by:: geoadd in interface ReactiveRedisClient

geoaddAndAwait

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

Specified by:: geoaddAndAwait in interface ReactiveRedisClient

geodist

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

Specified by:: geodist in interface ReactiveRedisClient

geodistAndAwait

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

Specified by:: geodistAndAwait in interface ReactiveRedisClient

geohash

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

Specified by:: geohash in interface ReactiveRedisClient

geohashAndAwait

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

Specified by:: geohashAndAwait in interface ReactiveRedisClient

geopos

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

Specified by:: geopos in interface ReactiveRedisClient

geoposAndAwait

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

Specified by:: geoposAndAwait in interface ReactiveRedisClient

georadius

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

Specified by:: georadius in interface ReactiveRedisClient

georadiusAndAwait

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

Specified by:: georadiusAndAwait in interface ReactiveRedisClient

georadiusRo

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

Specified by:: georadiusRo in interface ReactiveRedisClient

georadiusRoAndAwait

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

Specified by:: georadiusRoAndAwait in interface ReactiveRedisClient

georadiusbymember

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

Specified by:: georadiusbymember in interface ReactiveRedisClient

georadiusbymemberAndAwait

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

Specified by:: georadiusbymemberAndAwait in interface ReactiveRedisClient

georadiusbymemberRo

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

Specified by:: georadiusbymemberRo in interface ReactiveRedisClient

georadiusbymemberRoAndAwait
```
public io.vertx.mutiny.redis.client.Response georadiusbymemberRoAndAwait(List<String> args)
```
Specified by:

georadiusbymemberRoAndAwait in interface ReactiveRedisClient

get

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

Specified by:: get in interface ReactiveRedisClient

getAndAwait

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

Specified by:: getAndAwait in interface ReactiveRedisClient

getbit

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

Specified by:: getbit in interface ReactiveRedisClient

getbitAndAwait

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

Specified by:: getbitAndAwait in interface ReactiveRedisClient

getrange

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

Specified by:: getrange in interface ReactiveRedisClient

getrangeAndAwait

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

Specified by:: getrangeAndAwait in interface ReactiveRedisClient

getset

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

Specified by:: getset in interface ReactiveRedisClient

getsetAndAwait

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

Specified by:: getsetAndAwait in interface ReactiveRedisClient

hdel

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

Specified by:: hdel in interface ReactiveRedisClient

hdelAndAwait

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

Specified by:: hdelAndAwait in interface ReactiveRedisClient

hexists

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

Specified by:: hexists in interface ReactiveRedisClient

hexistsAndAwait

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

Specified by:: hexistsAndAwait in interface ReactiveRedisClient

hget

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

Specified by:: hget in interface ReactiveRedisClient

hgetAndAwait

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

Specified by:: hgetAndAwait in interface ReactiveRedisClient

hgetall

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

Specified by:: hgetall in interface ReactiveRedisClient

hgetallAndAwait

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

Specified by:: hgetallAndAwait in interface ReactiveRedisClient

hincrby

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

Specified by:: hincrby in interface ReactiveRedisClient

hincrbyAndAwait

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

Specified by:: hincrbyAndAwait in interface ReactiveRedisClient

hincrbyfloat

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

Specified by:: hincrbyfloat in interface ReactiveRedisClient

hincrbyfloatAndAwait

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

Specified by:: hincrbyfloatAndAwait in interface ReactiveRedisClient

hkeys

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

Specified by:: hkeys in interface ReactiveRedisClient

hkeysAndAwait

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

Specified by:: hkeysAndAwait in interface ReactiveRedisClient

hlen

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

Specified by:: hlen in interface ReactiveRedisClient

hlenAndAwait

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

Specified by:: hlenAndAwait in interface ReactiveRedisClient

hmget

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

Specified by:: hmget in interface ReactiveRedisClient

hmgetAndAwait

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

Specified by:: hmgetAndAwait in interface ReactiveRedisClient

hmset

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

Specified by:: hmset in interface ReactiveRedisClient

hmsetAndAwait

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

Specified by:: hmsetAndAwait in interface ReactiveRedisClient

host

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

Specified by:: host in interface ReactiveRedisClient

hostAndAwait

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

Specified by:: hostAndAwait in interface ReactiveRedisClient

hscan

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

Specified by:: hscan in interface ReactiveRedisClient

hscanAndAwait

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

Specified by:: hscanAndAwait in interface ReactiveRedisClient

hset

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

Specified by:: hset in interface ReactiveRedisClient

hsetAndAwait

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

Specified by:: hsetAndAwait in interface ReactiveRedisClient

hsetnx

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

Specified by:: hsetnx in interface ReactiveRedisClient

hsetnxAndAwait

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

Specified by:: hsetnxAndAwait in interface ReactiveRedisClient

hstrlen

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

Specified by:: hstrlen in interface ReactiveRedisClient

hstrlenAndAwait

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

Specified by:: hstrlenAndAwait in interface ReactiveRedisClient

hvals

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

Specified by:: hvals in interface ReactiveRedisClient

hvalsAndAwait

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

Specified by:: hvalsAndAwait in interface ReactiveRedisClient

incr

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

Specified by:: incr in interface ReactiveRedisClient

incrAndAwait

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

Specified by:: incrAndAwait in interface ReactiveRedisClient

incrby

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

Specified by:: incrby in interface ReactiveRedisClient

incrbyAndAwait

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

Specified by:: incrbyAndAwait in interface ReactiveRedisClient

incrbyfloat

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

Specified by:: incrbyfloat in interface ReactiveRedisClient

incrbyfloatAndAwait

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

Specified by:: incrbyfloatAndAwait in interface ReactiveRedisClient

info

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

Specified by:: info in interface ReactiveRedisClient

infoAndAwait

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

Specified by:: infoAndAwait in interface ReactiveRedisClient

keys

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

Specified by:: keys in interface ReactiveRedisClient

keysAndAwait

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

Specified by:: keysAndAwait in interface ReactiveRedisClient

lastsave

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

Specified by:: lastsave in interface ReactiveRedisClient

lastsaveAndAwait
```
public io.vertx.mutiny.redis.client.Response lastsaveAndAwait()
```
Specified by:

lastsaveAndAwait in interface ReactiveRedisClient

latency

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

Specified by:: latency in interface ReactiveRedisClient

latencyAndAwait

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

Specified by:: latencyAndAwait in interface ReactiveRedisClient

lindex

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

Specified by:: lindex in interface ReactiveRedisClient

lindexAndAwait

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

Specified by:: lindexAndAwait in interface ReactiveRedisClient

linsert

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

Specified by:: linsert in interface ReactiveRedisClient

linsertAndAwait

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

Specified by:: linsertAndAwait in interface ReactiveRedisClient

llen

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

Specified by:: llen in interface ReactiveRedisClient

llenAndAwait

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

Specified by:: llenAndAwait in interface ReactiveRedisClient

lolwut

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

Specified by:: lolwut in interface ReactiveRedisClient

lolwutAndAwait

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

Specified by:: lolwutAndAwait in interface ReactiveRedisClient

lpop

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

Specified by:: lpop in interface ReactiveRedisClient

lpop

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

Specified by:: lpop in interface ReactiveRedisClient

lpopAndAwait

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

Specified by:: lpopAndAwait in interface ReactiveRedisClient

lpopAndAwait

public io.vertx.mutiny.redis.client.Response lpopAndAwait(List<String> arg0)

Specified by:: lpopAndAwait in interface ReactiveRedisClient

lpush

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

Specified by:: lpush in interface ReactiveRedisClient

lpushAndAwait

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

Specified by:: lpushAndAwait in interface ReactiveRedisClient

lpushx

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

Specified by:: lpushx in interface ReactiveRedisClient

lpushxAndAwait

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

Specified by:: lpushxAndAwait in interface ReactiveRedisClient

lrange

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

Specified by:: lrange in interface ReactiveRedisClient

lrangeAndAwait

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

Specified by:: lrangeAndAwait in interface ReactiveRedisClient

lrem

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

Specified by:: lrem in interface ReactiveRedisClient

lremAndAwait

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

Specified by:: lremAndAwait in interface ReactiveRedisClient

lset

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

Specified by:: lset in interface ReactiveRedisClient

lsetAndAwait

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

Specified by:: lsetAndAwait in interface ReactiveRedisClient

ltrim

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

Specified by:: ltrim in interface ReactiveRedisClient

ltrimAndAwait

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

Specified by:: ltrimAndAwait in interface ReactiveRedisClient

memory

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

Specified by:: memory in interface ReactiveRedisClient

memoryAndAwait

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

Specified by:: memoryAndAwait in interface ReactiveRedisClient

mget

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

Specified by:: mget in interface ReactiveRedisClient

mgetAndAwait

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

Specified by:: mgetAndAwait in interface ReactiveRedisClient

migrate

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

Specified by:: migrate in interface ReactiveRedisClient

migrateAndAwait

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

Specified by:: migrateAndAwait in interface ReactiveRedisClient

module

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

Specified by:: module in interface ReactiveRedisClient

moduleAndAwait

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

Specified by:: moduleAndAwait in interface ReactiveRedisClient

monitor

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

Specified by:: monitor in interface ReactiveRedisClient

monitorAndAwait
```
public io.vertx.mutiny.redis.client.Response monitorAndAwait()
```
Specified by:

monitorAndAwait in interface ReactiveRedisClient

move

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

Specified by:: move in interface ReactiveRedisClient

moveAndAwait

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

Specified by:: moveAndAwait in interface ReactiveRedisClient

mset

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

Specified by:: mset in interface ReactiveRedisClient

msetAndAwait

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

Specified by:: msetAndAwait in interface ReactiveRedisClient

msetnx

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

Specified by:: msetnx in interface ReactiveRedisClient

msetnxAndAwait

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

Specified by:: msetnxAndAwait in interface ReactiveRedisClient

multi

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

Specified by:: multi in interface ReactiveRedisClient

multiAndAwait
```
public io.vertx.mutiny.redis.client.Response multiAndAwait()
```
Specified by:

multiAndAwait in interface ReactiveRedisClient

object

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

Specified by:: object in interface ReactiveRedisClient

objectAndAwait

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

Specified by:: objectAndAwait in interface ReactiveRedisClient

persist

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

Specified by:: persist in interface ReactiveRedisClient

persistAndAwait

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

Specified by:: persistAndAwait in interface ReactiveRedisClient

pexpire

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

Specified by:: pexpire in interface ReactiveRedisClient

pexpireAndAwait

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

Specified by:: pexpireAndAwait in interface ReactiveRedisClient

pexpireat

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

Specified by:: pexpireat in interface ReactiveRedisClient

pexpireatAndAwait

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

Specified by:: pexpireatAndAwait in interface ReactiveRedisClient

pfadd

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

Specified by:: pfadd in interface ReactiveRedisClient

pfaddAndAwait

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

Specified by:: pfaddAndAwait in interface ReactiveRedisClient

pfcount

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

Specified by:: pfcount in interface ReactiveRedisClient

pfcountAndAwait

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

Specified by:: pfcountAndAwait in interface ReactiveRedisClient

pfdebug

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

Specified by:: pfdebug in interface ReactiveRedisClient

pfdebugAndAwait

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

Specified by:: pfdebugAndAwait in interface ReactiveRedisClient

pfmerge

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

Specified by:: pfmerge in interface ReactiveRedisClient

pfmergeAndAwait

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

Specified by:: pfmergeAndAwait in interface ReactiveRedisClient

pfselftest

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

Specified by:: pfselftest in interface ReactiveRedisClient

pfselftestAndAwait
```
public io.vertx.mutiny.redis.client.Response pfselftestAndAwait()
```
Specified by:

pfselftestAndAwait in interface ReactiveRedisClient

ping

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

Specified by:: ping in interface ReactiveRedisClient

pingAndAwait

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

Specified by:: pingAndAwait in interface ReactiveRedisClient

post

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

Specified by:: post in interface ReactiveRedisClient

postAndAwait

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

Specified by:: postAndAwait in interface ReactiveRedisClient

psetex

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

Specified by:: psetex in interface ReactiveRedisClient

psetexAndAwait

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

Specified by:: psetexAndAwait in interface ReactiveRedisClient

psubscribe

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

Specified by:: psubscribe in interface ReactiveRedisClient

psubscribeAndAwait

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

Specified by:: psubscribeAndAwait in interface ReactiveRedisClient

psync

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

Specified by:: psync in interface ReactiveRedisClient

psync

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

Specified by:: psync in interface ReactiveRedisClient

psyncAndAwait

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

Specified by:: psyncAndAwait in interface ReactiveRedisClient

psyncAndAwait

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

Specified by:: psyncAndAwait in interface ReactiveRedisClient

pttl

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

Specified by:: pttl in interface ReactiveRedisClient

pttlAndAwait

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

Specified by:: pttlAndAwait in interface ReactiveRedisClient

publish

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

Specified by:: publish in interface ReactiveRedisClient

publishAndAwait

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

Specified by:: publishAndAwait in interface ReactiveRedisClient

pubsub

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

Specified by:: pubsub in interface ReactiveRedisClient

pubsubAndAwait

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

Specified by:: pubsubAndAwait in interface ReactiveRedisClient

punsubscribe

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

Specified by:: punsubscribe in interface ReactiveRedisClient

punsubscribeAndAwait

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

Specified by:: punsubscribeAndAwait in interface ReactiveRedisClient

randomkey

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

Specified by:: randomkey in interface ReactiveRedisClient

randomkeyAndAwait
```
public io.vertx.mutiny.redis.client.Response randomkeyAndAwait()
```
Specified by:

randomkeyAndAwait in interface ReactiveRedisClient

readonly

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

Specified by:: readonly in interface ReactiveRedisClient

readonlyAndAwait
```
public io.vertx.mutiny.redis.client.Response readonlyAndAwait()
```
Specified by:

readonlyAndAwait in interface ReactiveRedisClient

readwrite

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

Specified by:: readwrite in interface ReactiveRedisClient

readwriteAndAwait
```
public io.vertx.mutiny.redis.client.Response readwriteAndAwait()
```
Specified by:

readwriteAndAwait in interface ReactiveRedisClient

rename

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

Specified by:: rename in interface ReactiveRedisClient

renameAndAwait

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

Specified by:: renameAndAwait in interface ReactiveRedisClient

renamenx

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

Specified by:: renamenx in interface ReactiveRedisClient

renamenxAndAwait

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

Specified by:: renamenxAndAwait in interface ReactiveRedisClient

replconf

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

Specified by:: replconf in interface ReactiveRedisClient

replconfAndAwait

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

Specified by:: replconfAndAwait in interface ReactiveRedisClient

replicaof

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

Specified by:: replicaof in interface ReactiveRedisClient

replicaofAndAwait

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

Specified by:: replicaofAndAwait in interface ReactiveRedisClient

restore

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

Specified by:: restore in interface ReactiveRedisClient

restoreAndAwait

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

Specified by:: restoreAndAwait in interface ReactiveRedisClient

restoreAsking

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

Specified by:: restoreAsking in interface ReactiveRedisClient

restoreAskingAndAwait

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

Specified by:: restoreAskingAndAwait in interface ReactiveRedisClient

role

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

Specified by:: role in interface ReactiveRedisClient

roleAndAwait
```
public io.vertx.mutiny.redis.client.Response roleAndAwait()
```
Specified by:

roleAndAwait in interface ReactiveRedisClient

rpop

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

Specified by:: rpop in interface ReactiveRedisClient

rpop

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

Specified by:: rpop in interface ReactiveRedisClient

rpopAndAwait

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

Specified by:: rpopAndAwait in interface ReactiveRedisClient

rpopAndAwait

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

Specified by:: rpopAndAwait in interface ReactiveRedisClient

rpoplpush

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

Specified by:: rpoplpush in interface ReactiveRedisClient

rpoplpushAndAwait

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

Specified by:: rpoplpushAndAwait in interface ReactiveRedisClient

rpush

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

Specified by:: rpush in interface ReactiveRedisClient

rpushAndAwait

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

Specified by:: rpushAndAwait in interface ReactiveRedisClient

rpushx

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

Specified by:: rpushx in interface ReactiveRedisClient

rpushxAndAwait

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

Specified by:: rpushxAndAwait in interface ReactiveRedisClient

sadd

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

Specified by:: sadd in interface ReactiveRedisClient

saddAndAwait

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

Specified by:: saddAndAwait in interface ReactiveRedisClient

save

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

Specified by:: save in interface ReactiveRedisClient

saveAndAwait
```
public io.vertx.mutiny.redis.client.Response saveAndAwait()
```
Specified by:

saveAndAwait in interface ReactiveRedisClient

scan

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

Specified by:: scan in interface ReactiveRedisClient

scanAndAwait

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

Specified by:: scanAndAwait in interface ReactiveRedisClient

scard

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

Specified by:: scard in interface ReactiveRedisClient

scardAndAwait

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

Specified by:: scardAndAwait in interface ReactiveRedisClient

script

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

Specified by:: script in interface ReactiveRedisClient

scriptAndAwait

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

Specified by:: scriptAndAwait in interface ReactiveRedisClient

sdiff

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

Specified by:: sdiff in interface ReactiveRedisClient

sdiffAndAwait

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

Specified by:: sdiffAndAwait in interface ReactiveRedisClient

sdiffstore

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

Specified by:: sdiffstore in interface ReactiveRedisClient

sdiffstoreAndAwait

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

Specified by:: sdiffstoreAndAwait in interface ReactiveRedisClient

select

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

Specified by:: select in interface ReactiveRedisClient

selectAndAwait

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

Specified by:: selectAndAwait in interface ReactiveRedisClient

set

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

Specified by:: set in interface ReactiveRedisClient

setAndAwait

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

Specified by:: setAndAwait in interface ReactiveRedisClient

setbit

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

Specified by:: setbit in interface ReactiveRedisClient

setbitAndAwait

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

Specified by:: setbitAndAwait in interface ReactiveRedisClient

setex

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

Specified by:: setex in interface ReactiveRedisClient

setexAndAwait

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

Specified by:: setexAndAwait in interface ReactiveRedisClient

setnx

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

Specified by:: setnx in interface ReactiveRedisClient

setnxAndAwait

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

Specified by:: setnxAndAwait in interface ReactiveRedisClient

setrange

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

Specified by:: setrange in interface ReactiveRedisClient

setrangeAndAwait

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

Specified by:: setrangeAndAwait in interface ReactiveRedisClient

shutdown

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

Specified by:: shutdown in interface ReactiveRedisClient

shutdownAndAwait

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

Specified by:: shutdownAndAwait in interface ReactiveRedisClient

sinter

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

Specified by:: sinter in interface ReactiveRedisClient

sinterAndAwait

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

Specified by:: sinterAndAwait in interface ReactiveRedisClient

sinterstore

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

Specified by:: sinterstore in interface ReactiveRedisClient

sinterstoreAndAwait

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

Specified by:: sinterstoreAndAwait in interface ReactiveRedisClient

sismember

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

Specified by:: sismember in interface ReactiveRedisClient

sismemberAndAwait

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

Specified by:: sismemberAndAwait in interface ReactiveRedisClient

slaveof

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

Specified by:: slaveof in interface ReactiveRedisClient

slaveofAndAwait

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

Specified by:: slaveofAndAwait in interface ReactiveRedisClient

slowlog

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

Specified by:: slowlog in interface ReactiveRedisClient

slowlogAndAwait

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

Specified by:: slowlogAndAwait in interface ReactiveRedisClient

smembers

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

Specified by:: smembers in interface ReactiveRedisClient

smembersAndAwait

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

Specified by:: smembersAndAwait in interface ReactiveRedisClient

smove

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

Specified by:: smove in interface ReactiveRedisClient

smoveAndAwait

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

Specified by:: smoveAndAwait in interface ReactiveRedisClient

sort

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

Specified by:: sort in interface ReactiveRedisClient

sortAndAwait

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

Specified by:: sortAndAwait in interface ReactiveRedisClient

spop

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

Specified by:: spop in interface ReactiveRedisClient

spopAndAwait

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

Specified by:: spopAndAwait in interface ReactiveRedisClient

srandmember

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

Specified by:: srandmember in interface ReactiveRedisClient

srandmemberAndAwait

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

Specified by:: srandmemberAndAwait in interface ReactiveRedisClient

srem

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

Specified by:: srem in interface ReactiveRedisClient

sremAndAwait

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

Specified by:: sremAndAwait in interface ReactiveRedisClient

sscan

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

Specified by:: sscan in interface ReactiveRedisClient

sscanAndAwait

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

Specified by:: sscanAndAwait in interface ReactiveRedisClient

strlen

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

Specified by:: strlen in interface ReactiveRedisClient

strlenAndAwait

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

Specified by:: strlenAndAwait in interface ReactiveRedisClient

subscribe

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

Specified by:: subscribe in interface ReactiveRedisClient

subscribeAndAwait

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

Specified by:: subscribeAndAwait in interface ReactiveRedisClient

substr

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

Specified by:: substr in interface ReactiveRedisClient

substrAndAwait

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

Specified by:: substrAndAwait in interface ReactiveRedisClient

sunion

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

Specified by:: sunion in interface ReactiveRedisClient

sunionAndAwait

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

Specified by:: sunionAndAwait in interface ReactiveRedisClient

sunionstore

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

Specified by:: sunionstore in interface ReactiveRedisClient

sunionstoreAndAwait

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

Specified by:: sunionstoreAndAwait in interface ReactiveRedisClient

swapdb

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

Specified by:: swapdb in interface ReactiveRedisClient

swapdbAndAwait

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

Specified by:: swapdbAndAwait in interface ReactiveRedisClient

sync

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

Specified by:: sync in interface ReactiveRedisClient

syncAndAwait
```
public io.vertx.mutiny.redis.client.Response syncAndAwait()
```
Specified by:

syncAndAwait in interface ReactiveRedisClient

time

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

Specified by:: time in interface ReactiveRedisClient

timeAndAwait
```
public io.vertx.mutiny.redis.client.Response timeAndAwait()
```
Specified by:

timeAndAwait in interface ReactiveRedisClient

touch

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

Specified by:: touch in interface ReactiveRedisClient

touchAndAwait

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

Specified by:: touchAndAwait in interface ReactiveRedisClient

ttl

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

Specified by:: ttl in interface ReactiveRedisClient

ttlAndAwait

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

Specified by:: ttlAndAwait in interface ReactiveRedisClient

type

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

Specified by:: type in interface ReactiveRedisClient

typeAndAwait

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

Specified by:: typeAndAwait in interface ReactiveRedisClient

unlink

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

Specified by:: unlink in interface ReactiveRedisClient

unlinkAndAwait

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

Specified by:: unlinkAndAwait in interface ReactiveRedisClient

unsubscribe

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

Specified by:: unsubscribe in interface ReactiveRedisClient

unsubscribeAndAwait

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

Specified by:: unsubscribeAndAwait in interface ReactiveRedisClient

unwatch

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

Specified by:: unwatch in interface ReactiveRedisClient

unwatchAndAwait
```
public io.vertx.mutiny.redis.client.Response unwatchAndAwait()
```
Specified by:

unwatchAndAwait in interface ReactiveRedisClient

wait

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

Specified by:: wait in interface ReactiveRedisClient

waitAndAwait

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

Specified by:: waitAndAwait in interface ReactiveRedisClient

watch

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

Specified by:: watch in interface ReactiveRedisClient

watchAndAwait

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

Specified by:: watchAndAwait in interface ReactiveRedisClient

xack

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

Specified by:: xack in interface ReactiveRedisClient

xackAndAwait

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

Specified by:: xackAndAwait in interface ReactiveRedisClient

xadd

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

Specified by:: xadd in interface ReactiveRedisClient

xaddAndAwait

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

Specified by:: xaddAndAwait in interface ReactiveRedisClient

xclaim

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

Specified by:: xclaim in interface ReactiveRedisClient

xclaimAndAwait

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

Specified by:: xclaimAndAwait in interface ReactiveRedisClient

xdel

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

Specified by:: xdel in interface ReactiveRedisClient

xdelAndAwait

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

Specified by:: xdelAndAwait in interface ReactiveRedisClient

xgroup

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

Specified by:: xgroup in interface ReactiveRedisClient

xgroupAndAwait

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

Specified by:: xgroupAndAwait in interface ReactiveRedisClient

xinfo

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

Specified by:: xinfo in interface ReactiveRedisClient

xinfoAndAwait

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

Specified by:: xinfoAndAwait in interface ReactiveRedisClient

xlen

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

Specified by:: xlen in interface ReactiveRedisClient

xlenAndAwait

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

Specified by:: xlenAndAwait in interface ReactiveRedisClient

xpending

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

Specified by:: xpending in interface ReactiveRedisClient

xpendingAndAwait

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

Specified by:: xpendingAndAwait in interface ReactiveRedisClient

xrange

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

Specified by:: xrange in interface ReactiveRedisClient

xrangeAndAwait

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

Specified by:: xrangeAndAwait in interface ReactiveRedisClient

xread

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

Specified by:: xread in interface ReactiveRedisClient

xreadAndAwait

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

Specified by:: xreadAndAwait in interface ReactiveRedisClient

xreadgroup

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

Specified by:: xreadgroup in interface ReactiveRedisClient

xreadgroupAndAwait

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

Specified by:: xreadgroupAndAwait in interface ReactiveRedisClient

xrevrange

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

Specified by:: xrevrange in interface ReactiveRedisClient

xrevrangeAndAwait

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

Specified by:: xrevrangeAndAwait in interface ReactiveRedisClient

xsetid

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

Specified by:: xsetid in interface ReactiveRedisClient

xsetidAndAwait

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

Specified by:: xsetidAndAwait in interface ReactiveRedisClient

xtrim

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

Specified by:: xtrim in interface ReactiveRedisClient

xtrimAndAwait

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

Specified by:: xtrimAndAwait in interface ReactiveRedisClient

zadd

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

Specified by:: zadd in interface ReactiveRedisClient

zaddAndAwait

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

Specified by:: zaddAndAwait in interface ReactiveRedisClient

zcard

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

Specified by:: zcard in interface ReactiveRedisClient

zcardAndAwait

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

Specified by:: zcardAndAwait in interface ReactiveRedisClient

zcount

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

Specified by:: zcount in interface ReactiveRedisClient

zcountAndAwait

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

Specified by:: zcountAndAwait in interface ReactiveRedisClient

zincrby

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

Specified by:: zincrby in interface ReactiveRedisClient

zincrbyAndAwait

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

Specified by:: zincrbyAndAwait in interface ReactiveRedisClient

zinterstore

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

Specified by:: zinterstore in interface ReactiveRedisClient

zinterstoreAndAwait

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

Specified by:: zinterstoreAndAwait in interface ReactiveRedisClient

zlexcount

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

Specified by:: zlexcount in interface ReactiveRedisClient

zlexcountAndAwait

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

Specified by:: zlexcountAndAwait in interface ReactiveRedisClient

zpopmax

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

Specified by:: zpopmax in interface ReactiveRedisClient

zpopmaxAndAwait

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

Specified by:: zpopmaxAndAwait in interface ReactiveRedisClient

zpopmin

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

Specified by:: zpopmin in interface ReactiveRedisClient

zpopminAndAwait

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

Specified by:: zpopminAndAwait in interface ReactiveRedisClient

zrange

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

Specified by:: zrange in interface ReactiveRedisClient

zrangeAndAwait

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

Specified by:: zrangeAndAwait in interface ReactiveRedisClient

zrangebylex

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

Specified by:: zrangebylex in interface ReactiveRedisClient

zrangebylexAndAwait

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

Specified by:: zrangebylexAndAwait in interface ReactiveRedisClient

zrangebyscore

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

Specified by:: zrangebyscore in interface ReactiveRedisClient

zrangebyscoreAndAwait

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

Specified by:: zrangebyscoreAndAwait in interface ReactiveRedisClient

zrank

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

Specified by:: zrank in interface ReactiveRedisClient

zrankAndAwait

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

Specified by:: zrankAndAwait in interface ReactiveRedisClient

zrem

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

Specified by:: zrem in interface ReactiveRedisClient

zremAndAwait

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

Specified by:: zremAndAwait in interface ReactiveRedisClient

zremrangebylex

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

Specified by:: zremrangebylex in interface ReactiveRedisClient

zremrangebylexAndAwait

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

Specified by:: zremrangebylexAndAwait in interface ReactiveRedisClient

zremrangebyrank

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

Specified by:: zremrangebyrank in interface ReactiveRedisClient

zremrangebyrankAndAwait

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

Specified by:: zremrangebyrankAndAwait in interface ReactiveRedisClient

zremrangebyscore

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

Specified by:: zremrangebyscore in interface ReactiveRedisClient

zremrangebyscoreAndAwait

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

Specified by:: zremrangebyscoreAndAwait in interface ReactiveRedisClient

zrevrange

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

Specified by:: zrevrange in interface ReactiveRedisClient

zrevrangeAndAwait

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

Specified by:: zrevrangeAndAwait in interface ReactiveRedisClient

zrevrangebylex

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

Specified by:: zrevrangebylex in interface ReactiveRedisClient

zrevrangebylexAndAwait

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

Specified by:: zrevrangebylexAndAwait in interface ReactiveRedisClient

zrevrangebyscore

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

Specified by:: zrevrangebyscore in interface ReactiveRedisClient

zrevrangebyscoreAndAwait

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

Specified by:: zrevrangebyscoreAndAwait in interface ReactiveRedisClient

zrevrank

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

Specified by:: zrevrank in interface ReactiveRedisClient

zrevrankAndAwait

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

Specified by:: zrevrankAndAwait in interface ReactiveRedisClient

zscan

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

Specified by:: zscan in interface ReactiveRedisClient

zscanAndAwait

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

Specified by:: zscanAndAwait in interface ReactiveRedisClient

zscore

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

Specified by:: zscore in interface ReactiveRedisClient

zscoreAndAwait

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

Specified by:: zscoreAndAwait in interface ReactiveRedisClient

zunion

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

Specified by:: zunion in interface ReactiveRedisClient

zunionAndAwait

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

Specified by:: zunionAndAwait in interface ReactiveRedisClient

zunionstore

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

Specified by:: zunionstore in interface ReactiveRedisClient

zunionstoreAndAwait

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

Specified by:: zunionstoreAndAwait in interface ReactiveRedisClient

Class ReactiveRedisClientImpl

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ReactiveRedisClientImpl

Method Detail

close

append

appendAndAwait

asking

askingAndAwait

auth

authAndAwait

bgrewriteaof

bgrewriteaofAndAwait

bgsave

bgsaveAndAwait

bitcount

bitcountAndAwait

bitfield

bitfieldAndAwait

bitop

bitopAndAwait

bitpos

bitposAndAwait

blpop

blpopAndAwait

brpop

brpopAndAwait

brpoplpush

brpoplpushAndAwait

bzpopmax

bzpopmaxAndAwait

bzpopmin

bzpopminAndAwait

client

clientAndAwait

cluster

clusterAndAwait

command

commandAndAwait

config

configAndAwait

dbsize

dbsizeAndAwait

debug

debugAndAwait

decr

decrAndAwait

decrby

decrbyAndAwait

del

delAndAwait

discard

discardAndAwait

dump

dumpAndAwait

echo

echoAndAwait

eval

evalAndAwait

evalsha

evalshaAndAwait

exec

execAndAwait

exists

existsAndAwait

expire

expireAndAwait

expireat

expireatAndAwait

flushall

flushallAndAwait

flushdb

flushdbAndAwait

geoadd

geoaddAndAwait

geodist

geodistAndAwait