java.lang.Object
- io.vertx.mutiny.redis.client.RedisAPI

```
public class RedisAPI
extends Object
```
Auto generated Redis API client wrapper.
NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

Field Summary

Fields
Modifier and Type Field Description

static TypeArg<RedisAPI> __TYPE_ARG

Constructor Summary

Constructors
Constructor Description

RedisAPI(io.vertx.redis.client.RedisAPI delegate)

RedisAPI(Object delegate)

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`io.smallrye.mutiny.Uni<Response>`	`acl(List<String> args)`	Redis command acl.
`Response`	`aclAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#acl(List)`.
`RedisAPI`	`aclAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#acl(List)` that ignores the result of the operation.
`static RedisAPI`	`api(Redis client)`
`static RedisAPI`	`api(RedisConnection connection)`
`io.smallrye.mutiny.Uni<Response>`	`append(String arg0, String arg1)`	Redis command append.
`Response`	`appendAndAwait(String arg0, String arg1)`	Blocking variant of `append(String,String)`.
`RedisAPI`	`appendAndForget(String arg0, String arg1)`	Variant of `append(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`asking()`	Redis command asking.
`Response`	`askingAndAwait()`	Blocking variant of `asking()`.
`RedisAPI`	`askingAndForget()`	Variant of `asking()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`auth(List<String> args)`	Redis command auth.
`Response`	`authAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#auth(List)`.
`RedisAPI`	`authAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#auth(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bgrewriteaof()`	Redis command bgrewriteaof.
`Response`	`bgrewriteaofAndAwait()`	Blocking variant of `bgrewriteaof()`.
`RedisAPI`	`bgrewriteaofAndForget()`	Variant of `bgrewriteaof()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bgsave(List<String> args)`	Redis command bgsave.
`Response`	`bgsaveAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#bgsave(List)`.
`RedisAPI`	`bgsaveAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#bgsave(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bitcount(List<String> args)`	Redis command bitcount.
`Response`	`bitcountAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#bitcount(List)`.
`RedisAPI`	`bitcountAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#bitcount(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bitfield(List<String> args)`	Redis command bitfield.
`Response`	`bitfieldAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#bitfield(List)`.
`RedisAPI`	`bitfieldAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#bitfield(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bitfieldRo(List<String> args)`	Redis command bitfieldRo.
`Response`	`bitfieldRoAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#bitfieldRo(List)`.
`RedisAPI`	`bitfieldRoAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#bitfieldRo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bitop(List<String> args)`	Redis command bitop.
`Response`	`bitopAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#bitop(List)`.
`RedisAPI`	`bitopAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#bitop(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bitpos(List<String> args)`	Redis command bitpos.
`Response`	`bitposAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#bitpos(List)`.
`RedisAPI`	`bitposAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#bitpos(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`blpop(List<String> args)`	Redis command blpop.
`Response`	`blpopAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#blpop(List)`.
`RedisAPI`	`blpopAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#blpop(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`brpop(List<String> args)`	Redis command brpop.
`Response`	`brpopAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#brpop(List)`.
`RedisAPI`	`brpopAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#brpop(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`brpoplpush(String arg0, String arg1, String arg2)`	Redis command brpoplpush.
`Response`	`brpoplpushAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `brpoplpush(String,String,String)`.
`RedisAPI`	`brpoplpushAndForget(String arg0, String arg1, String arg2)`	Variant of `brpoplpush(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bzpopmax(List<String> args)`	Redis command bzpopmax.
`Response`	`bzpopmaxAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#bzpopmax(List)`.
`RedisAPI`	`bzpopmaxAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#bzpopmax(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bzpopmin(List<String> args)`	Redis command bzpopmin.
`Response`	`bzpopminAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#bzpopmin(List)`.
`RedisAPI`	`bzpopminAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#bzpopmin(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`client(List<String> args)`	Redis command client.
`Response`	`clientAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#client(List)`.
`RedisAPI`	`clientAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#client(List)` that ignores the result of the operation.
`void`	`close()`
`io.smallrye.mutiny.Uni<Response>`	`cluster(List<String> args)`	Redis command cluster.
`Response`	`clusterAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#cluster(List)`.
`RedisAPI`	`clusterAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#cluster(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`command(List<String> args)`	Redis command command.
`Response`	`commandAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#command(List)`.
`RedisAPI`	`commandAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#command(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`config(List<String> args)`	Redis command config.
`Response`	`configAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#config(List)`.
`RedisAPI`	`configAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#config(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`dbsize()`	Redis command dbsize.
`Response`	`dbsizeAndAwait()`	Blocking variant of `dbsize()`.
`RedisAPI`	`dbsizeAndForget()`	Variant of `dbsize()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`debug(List<String> args)`	Redis command debug.
`Response`	`debugAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#debug(List)`.
`RedisAPI`	`debugAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#debug(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`decr(String arg0)`	Redis command decr.
`Response`	`decrAndAwait(String arg0)`	Blocking variant of `decr(String)`.
`RedisAPI`	`decrAndForget(String arg0)`	Variant of `decr(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`decrby(String arg0, String arg1)`	Redis command decrby.
`Response`	`decrbyAndAwait(String arg0, String arg1)`	Blocking variant of `decrby(String,String)`.
`RedisAPI`	`decrbyAndForget(String arg0, String arg1)`	Variant of `decrby(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`del(List<String> args)`	Redis command del.
`Response`	`delAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#del(List)`.
`RedisAPI`	`delAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#del(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`discard()`	Redis command discard.
`Response`	`discardAndAwait()`	Blocking variant of `discard()`.
`RedisAPI`	`discardAndForget()`	Variant of `discard()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`dump(String arg0)`	Redis command dump.
`Response`	`dumpAndAwait(String arg0)`	Blocking variant of `dump(String)`.
`RedisAPI`	`dumpAndForget(String arg0)`	Variant of `dump(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`echo(String arg0)`	Redis command echo.
`Response`	`echoAndAwait(String arg0)`	Blocking variant of `echo(String)`.
`RedisAPI`	`echoAndForget(String arg0)`	Variant of `echo(String)` that ignores the result of the operation.
`boolean`	`equals(Object o)`
`io.smallrye.mutiny.Uni<Response>`	`eval(List<String> args)`	Redis command eval.
`Response`	`evalAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#eval(List)`.
`RedisAPI`	`evalAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#eval(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`evalsha(List<String> args)`	Redis command evalsha.
`Response`	`evalshaAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#evalsha(List)`.
`RedisAPI`	`evalshaAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#evalsha(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`exec()`	Redis command exec.
`Response`	`execAndAwait()`	Blocking variant of `exec()`.
`RedisAPI`	`execAndForget()`	Variant of `exec()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`exists(List<String> args)`	Redis command exists.
`Response`	`existsAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#exists(List)`.
`RedisAPI`	`existsAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#exists(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`expire(String arg0, String arg1)`	Redis command expire.
`Response`	`expireAndAwait(String arg0, String arg1)`	Blocking variant of `expire(String,String)`.
`RedisAPI`	`expireAndForget(String arg0, String arg1)`	Variant of `expire(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`expireat(String arg0, String arg1)`	Redis command expireat.
`Response`	`expireatAndAwait(String arg0, String arg1)`	Blocking variant of `expireat(String,String)`.
`RedisAPI`	`expireatAndForget(String arg0, String arg1)`	Variant of `expireat(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`flushall(List<String> args)`	Redis command flushall.
`Response`	`flushallAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#flushall(List)`.
`RedisAPI`	`flushallAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#flushall(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`flushdb(List<String> args)`	Redis command flushdb.
`Response`	`flushdbAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#flushdb(List)`.
`RedisAPI`	`flushdbAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#flushdb(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`geoadd(List<String> args)`	Redis command geoadd.
`Response`	`geoaddAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#geoadd(List)`.
`RedisAPI`	`geoaddAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#geoadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`geodist(List<String> args)`	Redis command geodist.
`Response`	`geodistAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#geodist(List)`.
`RedisAPI`	`geodistAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#geodist(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`geohash(List<String> args)`	Redis command geohash.
`Response`	`geohashAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#geohash(List)`.
`RedisAPI`	`geohashAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#geohash(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`geopos(List<String> args)`	Redis command geopos.
`Response`	`geoposAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#geopos(List)`.
`RedisAPI`	`geoposAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#geopos(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`georadius(List<String> args)`	Redis command georadius.
`Response`	`georadiusAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#georadius(List)`.
`RedisAPI`	`georadiusAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#georadius(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`georadiusbymember(List<String> args)`	Redis command georadiusbymember.
`Response`	`georadiusbymemberAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#georadiusbymember(List)`.
`RedisAPI`	`georadiusbymemberAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#georadiusbymember(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`georadiusbymemberRo(List<String> args)`	Redis command georadiusbymemberRo.
`Response`	`georadiusbymemberRoAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#georadiusbymemberRo(List)`.
`RedisAPI`	`georadiusbymemberRoAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#georadiusbymemberRo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`georadiusRo(List<String> args)`	Redis command georadiusRo.
`Response`	`georadiusRoAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#georadiusRo(List)`.
`RedisAPI`	`georadiusRoAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#georadiusRo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`get(String arg0)`	Redis command get.
`Response`	`getAndAwait(String arg0)`	Blocking variant of `get(String)`.
`RedisAPI`	`getAndForget(String arg0)`	Variant of `get(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`getbit(String arg0, String arg1)`	Redis command getbit.
`Response`	`getbitAndAwait(String arg0, String arg1)`	Blocking variant of `getbit(String,String)`.
`RedisAPI`	`getbitAndForget(String arg0, String arg1)`	Variant of `getbit(String,String)` that ignores the result of the operation.
`io.vertx.redis.client.RedisAPI`	`getDelegate()`
`io.smallrye.mutiny.Uni<Response>`	`getrange(String arg0, String arg1, String arg2)`	Redis command getrange.
`Response`	`getrangeAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `getrange(String,String,String)`.
`RedisAPI`	`getrangeAndForget(String arg0, String arg1, String arg2)`	Variant of `getrange(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`getset(String arg0, String arg1)`	Redis command getset.
`Response`	`getsetAndAwait(String arg0, String arg1)`	Blocking variant of `getset(String,String)`.
`RedisAPI`	`getsetAndForget(String arg0, String arg1)`	Variant of `getset(String,String)` that ignores the result of the operation.
`int`	`hashCode()`
`io.smallrye.mutiny.Uni<Response>`	`hdel(List<String> args)`	Redis command hdel.
`Response`	`hdelAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#hdel(List)`.
`RedisAPI`	`hdelAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#hdel(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hello(List<String> args)`	Redis command hello.
`Response`	`helloAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#hello(List)`.
`RedisAPI`	`helloAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#hello(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hexists(String arg0, String arg1)`	Redis command hexists.
`Response`	`hexistsAndAwait(String arg0, String arg1)`	Blocking variant of `hexists(String,String)`.
`RedisAPI`	`hexistsAndForget(String arg0, String arg1)`	Variant of `hexists(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hget(String arg0, String arg1)`	Redis command hget.
`io.smallrye.mutiny.Uni<Response>`	`hgetall(String arg0)`	Redis command hgetall.
`Response`	`hgetallAndAwait(String arg0)`	Blocking variant of `hgetall(String)`.
`RedisAPI`	`hgetallAndForget(String arg0)`	Variant of `hgetall(String)` that ignores the result of the operation.
`Response`	`hgetAndAwait(String arg0, String arg1)`	Blocking variant of `hget(String,String)`.
`RedisAPI`	`hgetAndForget(String arg0, String arg1)`	Variant of `hget(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hincrby(String arg0, String arg1, String arg2)`	Redis command hincrby.
`Response`	`hincrbyAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `hincrby(String,String,String)`.
`RedisAPI`	`hincrbyAndForget(String arg0, String arg1, String arg2)`	Variant of `hincrby(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hincrbyfloat(String arg0, String arg1, String arg2)`	Redis command hincrbyfloat.
`Response`	`hincrbyfloatAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `hincrbyfloat(String,String,String)`.
`RedisAPI`	`hincrbyfloatAndForget(String arg0, String arg1, String arg2)`	Variant of `hincrbyfloat(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hkeys(String arg0)`	Redis command hkeys.
`Response`	`hkeysAndAwait(String arg0)`	Blocking variant of `hkeys(String)`.
`RedisAPI`	`hkeysAndForget(String arg0)`	Variant of `hkeys(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hlen(String arg0)`	Redis command hlen.
`Response`	`hlenAndAwait(String arg0)`	Blocking variant of `hlen(String)`.
`RedisAPI`	`hlenAndForget(String arg0)`	Variant of `hlen(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hmget(List<String> args)`	Redis command hmget.
`Response`	`hmgetAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#hmget(List)`.
`RedisAPI`	`hmgetAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#hmget(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hmset(List<String> args)`	Redis command hmset.
`Response`	`hmsetAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#hmset(List)`.
`RedisAPI`	`hmsetAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#hmset(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`host(List<String> args)`	Redis command host.
`Response`	`hostAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#host(List)`.
`RedisAPI`	`hostAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#host(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hscan(List<String> args)`	Redis command hscan.
`Response`	`hscanAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#hscan(List)`.
`RedisAPI`	`hscanAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#hscan(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hset(List<String> args)`	Redis command hset.
`Response`	`hsetAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#hset(List)`.
`RedisAPI`	`hsetAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#hset(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hsetnx(String arg0, String arg1, String arg2)`	Redis command hsetnx.
`Response`	`hsetnxAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `hsetnx(String,String,String)`.
`RedisAPI`	`hsetnxAndForget(String arg0, String arg1, String arg2)`	Variant of `hsetnx(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hstrlen(String arg0, String arg1)`	Redis command hstrlen.
`Response`	`hstrlenAndAwait(String arg0, String arg1)`	Blocking variant of `hstrlen(String,String)`.
`RedisAPI`	`hstrlenAndForget(String arg0, String arg1)`	Variant of `hstrlen(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hvals(String arg0)`	Redis command hvals.
`Response`	`hvalsAndAwait(String arg0)`	Blocking variant of `hvals(String)`.
`RedisAPI`	`hvalsAndForget(String arg0)`	Variant of `hvals(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`incr(String arg0)`	Redis command incr.
`Response`	`incrAndAwait(String arg0)`	Blocking variant of `incr(String)`.
`RedisAPI`	`incrAndForget(String arg0)`	Variant of `incr(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`incrby(String arg0, String arg1)`	Redis command incrby.
`Response`	`incrbyAndAwait(String arg0, String arg1)`	Blocking variant of `incrby(String,String)`.
`RedisAPI`	`incrbyAndForget(String arg0, String arg1)`	Variant of `incrby(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`incrbyfloat(String arg0, String arg1)`	Redis command incrbyfloat.
`Response`	`incrbyfloatAndAwait(String arg0, String arg1)`	Blocking variant of `incrbyfloat(String,String)`.
`RedisAPI`	`incrbyfloatAndForget(String arg0, String arg1)`	Variant of `incrbyfloat(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`info(List<String> args)`	Redis command info.
`Response`	`infoAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#info(List)`.
`RedisAPI`	`infoAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#info(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`keys(String arg0)`	Redis command keys.
`Response`	`keysAndAwait(String arg0)`	Blocking variant of `keys(String)`.
`RedisAPI`	`keysAndForget(String arg0)`	Variant of `keys(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`lastsave()`	Redis command lastsave.
`Response`	`lastsaveAndAwait()`	Blocking variant of `lastsave()`.
`RedisAPI`	`lastsaveAndForget()`	Variant of `lastsave()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`latency(List<String> args)`	Redis command latency.
`Response`	`latencyAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#latency(List)`.
`RedisAPI`	`latencyAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#latency(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`lindex(String arg0, String arg1)`	Redis command lindex.
`Response`	`lindexAndAwait(String arg0, String arg1)`	Blocking variant of `lindex(String,String)`.
`RedisAPI`	`lindexAndForget(String arg0, String arg1)`	Variant of `lindex(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`linsert(String arg0, String arg1, String arg2, String arg3)`	Redis command linsert.
`Response`	`linsertAndAwait(String arg0, String arg1, String arg2, String arg3)`	Blocking variant of `linsert(String,String,String,String)`.
`RedisAPI`	`linsertAndForget(String arg0, String arg1, String arg2, String arg3)`	Variant of `linsert(String,String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`llen(String arg0)`	Redis command llen.
`Response`	`llenAndAwait(String arg0)`	Blocking variant of `llen(String)`.
`RedisAPI`	`llenAndForget(String arg0)`	Variant of `llen(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`lolwut(List<String> args)`	Redis command lolwut.
`Response`	`lolwutAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#lolwut(List)`.
`RedisAPI`	`lolwutAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#lolwut(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`lpop(String arg0)`	Redis command lpop.
`Response`	`lpopAndAwait(String arg0)`	Blocking variant of `lpop(String)`.
`RedisAPI`	`lpopAndForget(String arg0)`	Variant of `lpop(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`lpush(List<String> args)`	Redis command lpush.
`Response`	`lpushAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#lpush(List)`.
`RedisAPI`	`lpushAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#lpush(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`lpushx(List<String> args)`	Redis command lpushx.
`Response`	`lpushxAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#lpushx(List)`.
`RedisAPI`	`lpushxAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#lpushx(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`lrange(String arg0, String arg1, String arg2)`	Redis command lrange.
`Response`	`lrangeAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `lrange(String,String,String)`.
`RedisAPI`	`lrangeAndForget(String arg0, String arg1, String arg2)`	Variant of `lrange(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`lrem(String arg0, String arg1, String arg2)`	Redis command lrem.
`Response`	`lremAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `lrem(String,String,String)`.
`RedisAPI`	`lremAndForget(String arg0, String arg1, String arg2)`	Variant of `lrem(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`lset(String arg0, String arg1, String arg2)`	Redis command lset.
`Response`	`lsetAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `lset(String,String,String)`.
`RedisAPI`	`lsetAndForget(String arg0, String arg1, String arg2)`	Variant of `lset(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ltrim(String arg0, String arg1, String arg2)`	Redis command ltrim.
`Response`	`ltrimAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `ltrim(String,String,String)`.
`RedisAPI`	`ltrimAndForget(String arg0, String arg1, String arg2)`	Variant of `ltrim(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`memory(List<String> args)`	Redis command memory.
`Response`	`memoryAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#memory(List)`.
`RedisAPI`	`memoryAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#memory(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`mget(List<String> args)`	Redis command mget.
`Response`	`mgetAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#mget(List)`.
`RedisAPI`	`mgetAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#mget(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`migrate(List<String> args)`	Redis command migrate.
`Response`	`migrateAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#migrate(List)`.
`RedisAPI`	`migrateAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#migrate(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`module(List<String> args)`	Redis command module.
`Response`	`moduleAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#module(List)`.
`RedisAPI`	`moduleAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#module(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`monitor()`	Redis command monitor.
`Response`	`monitorAndAwait()`	Blocking variant of `monitor()`.
`RedisAPI`	`monitorAndForget()`	Variant of `monitor()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`move(String arg0, String arg1)`	Redis command move.
`Response`	`moveAndAwait(String arg0, String arg1)`	Blocking variant of `move(String,String)`.
`RedisAPI`	`moveAndForget(String arg0, String arg1)`	Variant of `move(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`mset(List<String> args)`	Redis command mset.
`Response`	`msetAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#mset(List)`.
`RedisAPI`	`msetAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#mset(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`msetnx(List<String> args)`	Redis command msetnx.
`Response`	`msetnxAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#msetnx(List)`.
`RedisAPI`	`msetnxAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#msetnx(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`multi()`	Redis command multi.
`Response`	`multiAndAwait()`	Blocking variant of `multi()`.
`RedisAPI`	`multiAndForget()`	Variant of `multi()` that ignores the result of the operation.
`static RedisAPI`	`newInstance(io.vertx.redis.client.RedisAPI arg)`
`io.smallrye.mutiny.Uni<Response>`	`object(List<String> args)`	Redis command object.
`Response`	`objectAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#object(List)`.
`RedisAPI`	`objectAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#object(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`persist(String arg0)`	Redis command persist.
`Response`	`persistAndAwait(String arg0)`	Blocking variant of `persist(String)`.
`RedisAPI`	`persistAndForget(String arg0)`	Variant of `persist(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pexpire(String arg0, String arg1)`	Redis command pexpire.
`Response`	`pexpireAndAwait(String arg0, String arg1)`	Blocking variant of `pexpire(String,String)`.
`RedisAPI`	`pexpireAndForget(String arg0, String arg1)`	Variant of `pexpire(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pexpireat(String arg0, String arg1)`	Redis command pexpireat.
`Response`	`pexpireatAndAwait(String arg0, String arg1)`	Blocking variant of `pexpireat(String,String)`.
`RedisAPI`	`pexpireatAndForget(String arg0, String arg1)`	Variant of `pexpireat(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pfadd(List<String> args)`	Redis command pfadd.
`Response`	`pfaddAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#pfadd(List)`.
`RedisAPI`	`pfaddAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#pfadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pfcount(List<String> args)`	Redis command pfcount.
`Response`	`pfcountAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#pfcount(List)`.
`RedisAPI`	`pfcountAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#pfcount(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pfdebug(List<String> args)`	Redis command pfdebug.
`Response`	`pfdebugAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#pfdebug(List)`.
`RedisAPI`	`pfdebugAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#pfdebug(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pfmerge(List<String> args)`	Redis command pfmerge.
`Response`	`pfmergeAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#pfmerge(List)`.
`RedisAPI`	`pfmergeAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#pfmerge(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pfselftest()`	Redis command pfselftest.
`Response`	`pfselftestAndAwait()`	Blocking variant of `pfselftest()`.
`RedisAPI`	`pfselftestAndForget()`	Variant of `pfselftest()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ping(List<String> args)`	Redis command ping.
`Response`	`pingAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#ping(List)`.
`RedisAPI`	`pingAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#ping(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`post(List<String> args)`	Redis command post.
`Response`	`postAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#post(List)`.
`RedisAPI`	`postAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#post(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`psetex(String arg0, String arg1, String arg2)`	Redis command psetex.
`Response`	`psetexAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `psetex(String,String,String)`.
`RedisAPI`	`psetexAndForget(String arg0, String arg1, String arg2)`	Variant of `psetex(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`psubscribe(List<String> args)`	Redis command psubscribe.
`Response`	`psubscribeAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#psubscribe(List)`.
`RedisAPI`	`psubscribeAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#psubscribe(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`psync(String arg0, String arg1)`	Redis command psync.
`Response`	`psyncAndAwait(String arg0, String arg1)`	Blocking variant of `psync(String,String)`.
`RedisAPI`	`psyncAndForget(String arg0, String arg1)`	Variant of `psync(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pttl(String arg0)`	Redis command pttl.
`Response`	`pttlAndAwait(String arg0)`	Blocking variant of `pttl(String)`.
`RedisAPI`	`pttlAndForget(String arg0)`	Variant of `pttl(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`publish(String arg0, String arg1)`	Redis command publish.
`Response`	`publishAndAwait(String arg0, String arg1)`	Blocking variant of `publish(String,String)`.
`RedisAPI`	`publishAndForget(String arg0, String arg1)`	Variant of `publish(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pubsub(List<String> args)`	Redis command pubsub.
`Response`	`pubsubAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#pubsub(List)`.
`RedisAPI`	`pubsubAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#pubsub(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`punsubscribe(List<String> args)`	Redis command punsubscribe.
`Response`	`punsubscribeAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#punsubscribe(List)`.
`RedisAPI`	`punsubscribeAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#punsubscribe(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`randomkey()`	Redis command randomkey.
`Response`	`randomkeyAndAwait()`	Blocking variant of `randomkey()`.
`RedisAPI`	`randomkeyAndForget()`	Variant of `randomkey()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`readonly()`	Redis command readonly.
`Response`	`readonlyAndAwait()`	Blocking variant of `readonly()`.
`RedisAPI`	`readonlyAndForget()`	Variant of `readonly()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`readwrite()`	Redis command readwrite.
`Response`	`readwriteAndAwait()`	Blocking variant of `readwrite()`.
`RedisAPI`	`readwriteAndForget()`	Variant of `readwrite()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`rename(String arg0, String arg1)`	Redis command rename.
`Response`	`renameAndAwait(String arg0, String arg1)`	Blocking variant of `rename(String,String)`.
`RedisAPI`	`renameAndForget(String arg0, String arg1)`	Variant of `rename(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`renamenx(String arg0, String arg1)`	Redis command renamenx.
`Response`	`renamenxAndAwait(String arg0, String arg1)`	Blocking variant of `renamenx(String,String)`.
`RedisAPI`	`renamenxAndForget(String arg0, String arg1)`	Variant of `renamenx(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`replconf(List<String> args)`	Redis command replconf.
`Response`	`replconfAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#replconf(List)`.
`RedisAPI`	`replconfAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#replconf(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`replicaof(String arg0, String arg1)`	Redis command replicaof.
`Response`	`replicaofAndAwait(String arg0, String arg1)`	Blocking variant of `replicaof(String,String)`.
`RedisAPI`	`replicaofAndForget(String arg0, String arg1)`	Variant of `replicaof(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`restore(List<String> args)`	Redis command restore.
`Response`	`restoreAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#restore(List)`.
`RedisAPI`	`restoreAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#restore(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`restoreAsking(List<String> args)`	Redis command restoreAsking.
`Response`	`restoreAskingAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#restoreAsking(List)`.
`RedisAPI`	`restoreAskingAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#restoreAsking(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`role()`	Redis command role.
`Response`	`roleAndAwait()`	Blocking variant of `role()`.
`RedisAPI`	`roleAndForget()`	Variant of `role()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`rpop(String arg0)`	Redis command rpop.
`Response`	`rpopAndAwait(String arg0)`	Blocking variant of `rpop(String)`.
`RedisAPI`	`rpopAndForget(String arg0)`	Variant of `rpop(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`rpoplpush(String arg0, String arg1)`	Redis command rpoplpush.
`Response`	`rpoplpushAndAwait(String arg0, String arg1)`	Blocking variant of `rpoplpush(String,String)`.
`RedisAPI`	`rpoplpushAndForget(String arg0, String arg1)`	Variant of `rpoplpush(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`rpush(List<String> args)`	Redis command rpush.
`Response`	`rpushAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#rpush(List)`.
`RedisAPI`	`rpushAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#rpush(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`rpushx(List<String> args)`	Redis command rpushx.
`Response`	`rpushxAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#rpushx(List)`.
`RedisAPI`	`rpushxAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#rpushx(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`sadd(List<String> args)`	Redis command sadd.
`Response`	`saddAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#sadd(List)`.
`RedisAPI`	`saddAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#sadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`save()`	Redis command save.
`Response`	`saveAndAwait()`	Blocking variant of `save()`.
`RedisAPI`	`saveAndForget()`	Variant of `save()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`scan(List<String> args)`	Redis command scan.
`Response`	`scanAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#scan(List)`.
`RedisAPI`	`scanAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#scan(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`scard(String arg0)`	Redis command scard.
`Response`	`scardAndAwait(String arg0)`	Blocking variant of `scard(String)`.
`RedisAPI`	`scardAndForget(String arg0)`	Variant of `scard(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`script(List<String> args)`	Redis command script.
`Response`	`scriptAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#script(List)`.
`RedisAPI`	`scriptAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#script(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`sdiff(List<String> args)`	Redis command sdiff.
`Response`	`sdiffAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#sdiff(List)`.
`RedisAPI`	`sdiffAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#sdiff(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`sdiffstore(List<String> args)`	Redis command sdiffstore.
`Response`	`sdiffstoreAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#sdiffstore(List)`.
`RedisAPI`	`sdiffstoreAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#sdiffstore(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`select(String arg0)`	Redis command select.
`Response`	`selectAndAwait(String arg0)`	Blocking variant of `select(String)`.
`RedisAPI`	`selectAndForget(String arg0)`	Variant of `select(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`set(List<String> args)`	Redis command set.
`Response`	`setAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#set(List)`.
`RedisAPI`	`setAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#set(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`setbit(String arg0, String arg1, String arg2)`	Redis command setbit.
`Response`	`setbitAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `setbit(String,String,String)`.
`RedisAPI`	`setbitAndForget(String arg0, String arg1, String arg2)`	Variant of `setbit(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`setex(String arg0, String arg1, String arg2)`	Redis command setex.
`Response`	`setexAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `setex(String,String,String)`.
`RedisAPI`	`setexAndForget(String arg0, String arg1, String arg2)`	Variant of `setex(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`setnx(String arg0, String arg1)`	Redis command setnx.
`Response`	`setnxAndAwait(String arg0, String arg1)`	Blocking variant of `setnx(String,String)`.
`RedisAPI`	`setnxAndForget(String arg0, String arg1)`	Variant of `setnx(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`setrange(String arg0, String arg1, String arg2)`	Redis command setrange.
`Response`	`setrangeAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `setrange(String,String,String)`.
`RedisAPI`	`setrangeAndForget(String arg0, String arg1, String arg2)`	Variant of `setrange(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`shutdown(List<String> args)`	Redis command shutdown.
`Response`	`shutdownAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#shutdown(List)`.
`RedisAPI`	`shutdownAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#shutdown(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`sinter(List<String> args)`	Redis command sinter.
`Response`	`sinterAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#sinter(List)`.
`RedisAPI`	`sinterAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#sinter(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`sinterstore(List<String> args)`	Redis command sinterstore.
`Response`	`sinterstoreAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#sinterstore(List)`.
`RedisAPI`	`sinterstoreAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#sinterstore(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`sismember(String arg0, String arg1)`	Redis command sismember.
`Response`	`sismemberAndAwait(String arg0, String arg1)`	Blocking variant of `sismember(String,String)`.
`RedisAPI`	`sismemberAndForget(String arg0, String arg1)`	Variant of `sismember(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`slaveof(String arg0, String arg1)`	Redis command slaveof.
`Response`	`slaveofAndAwait(String arg0, String arg1)`	Blocking variant of `slaveof(String,String)`.
`RedisAPI`	`slaveofAndForget(String arg0, String arg1)`	Variant of `slaveof(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`slowlog(List<String> args)`	Redis command slowlog.
`Response`	`slowlogAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#slowlog(List)`.
`RedisAPI`	`slowlogAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#slowlog(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`smembers(String arg0)`	Redis command smembers.
`Response`	`smembersAndAwait(String arg0)`	Blocking variant of `smembers(String)`.
`RedisAPI`	`smembersAndForget(String arg0)`	Variant of `smembers(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`smove(String arg0, String arg1, String arg2)`	Redis command smove.
`Response`	`smoveAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `smove(String,String,String)`.
`RedisAPI`	`smoveAndForget(String arg0, String arg1, String arg2)`	Variant of `smove(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`sort(List<String> args)`	Redis command sort.
`Response`	`sortAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#sort(List)`.
`RedisAPI`	`sortAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#sort(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`spop(List<String> args)`	Redis command spop.
`Response`	`spopAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#spop(List)`.
`RedisAPI`	`spopAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#spop(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`srandmember(List<String> args)`	Redis command srandmember.
`Response`	`srandmemberAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#srandmember(List)`.
`RedisAPI`	`srandmemberAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#srandmember(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`srem(List<String> args)`	Redis command srem.
`Response`	`sremAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#srem(List)`.
`RedisAPI`	`sremAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#srem(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`sscan(List<String> args)`	Redis command sscan.
`Response`	`sscanAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#sscan(List)`.
`RedisAPI`	`sscanAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#sscan(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`stralgo(List<String> args)`	Redis command stralgo.
`Response`	`stralgoAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#stralgo(List)`.
`RedisAPI`	`stralgoAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#stralgo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`strlen(String arg0)`	Redis command strlen.
`Response`	`strlenAndAwait(String arg0)`	Blocking variant of `strlen(String)`.
`RedisAPI`	`strlenAndForget(String arg0)`	Variant of `strlen(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`subscribe(List<String> args)`	Redis command subscribe.
`Response`	`subscribeAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#subscribe(List)`.
`RedisAPI`	`subscribeAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#subscribe(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`substr(String arg0, String arg1, String arg2)`	Redis command substr.
`Response`	`substrAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `substr(String,String,String)`.
`RedisAPI`	`substrAndForget(String arg0, String arg1, String arg2)`	Variant of `substr(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`sunion(List<String> args)`	Redis command sunion.
`Response`	`sunionAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#sunion(List)`.
`RedisAPI`	`sunionAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#sunion(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`sunionstore(List<String> args)`	Redis command sunionstore.
`Response`	`sunionstoreAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#sunionstore(List)`.
`RedisAPI`	`sunionstoreAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#sunionstore(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`swapdb(String arg0, String arg1)`	Redis command swapdb.
`Response`	`swapdbAndAwait(String arg0, String arg1)`	Blocking variant of `swapdb(String,String)`.
`RedisAPI`	`swapdbAndForget(String arg0, String arg1)`	Variant of `swapdb(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`sync()`	Redis command sync.
`Response`	`syncAndAwait()`	Blocking variant of `sync()`.
`RedisAPI`	`syncAndForget()`	Variant of `sync()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`time()`	Redis command time.
`Response`	`timeAndAwait()`	Blocking variant of `time()`.
`RedisAPI`	`timeAndForget()`	Variant of `time()` that ignores the result of the operation.
`String`	`toString()`
`io.smallrye.mutiny.Uni<Response>`	`touch(List<String> args)`	Redis command touch.
`Response`	`touchAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#touch(List)`.
`RedisAPI`	`touchAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#touch(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ttl(String arg0)`	Redis command ttl.
`Response`	`ttlAndAwait(String arg0)`	Blocking variant of `ttl(String)`.
`RedisAPI`	`ttlAndForget(String arg0)`	Variant of `ttl(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`type(String arg0)`	Redis command type.
`Response`	`typeAndAwait(String arg0)`	Blocking variant of `type(String)`.
`RedisAPI`	`typeAndForget(String arg0)`	Variant of `type(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`unlink(List<String> args)`	Redis command unlink.
`Response`	`unlinkAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#unlink(List)`.
`RedisAPI`	`unlinkAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#unlink(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`unsubscribe(List<String> args)`	Redis command unsubscribe.
`Response`	`unsubscribeAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#unsubscribe(List)`.
`RedisAPI`	`unsubscribeAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#unsubscribe(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`unwatch()`	Redis command unwatch.
`Response`	`unwatchAndAwait()`	Blocking variant of `unwatch()`.
`RedisAPI`	`unwatchAndForget()`	Variant of `unwatch()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`wait(String arg0, String arg1)`	Redis command wait.
`Response`	`waitAndAwait(String arg0, String arg1)`	Blocking variant of `wait(String,String)`.
`RedisAPI`	`waitAndForget(String arg0, String arg1)`	Variant of `wait(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`watch(List<String> args)`	Redis command watch.
`Response`	`watchAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#watch(List)`.
`RedisAPI`	`watchAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#watch(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xack(List<String> args)`	Redis command xack.
`Response`	`xackAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xack(List)`.
`RedisAPI`	`xackAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xack(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xadd(List<String> args)`	Redis command xadd.
`Response`	`xaddAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xadd(List)`.
`RedisAPI`	`xaddAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xclaim(List<String> args)`	Redis command xclaim.
`Response`	`xclaimAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xclaim(List)`.
`RedisAPI`	`xclaimAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xclaim(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xdel(List<String> args)`	Redis command xdel.
`Response`	`xdelAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xdel(List)`.
`RedisAPI`	`xdelAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xdel(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xgroup(List<String> args)`	Redis command xgroup.
`Response`	`xgroupAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xgroup(List)`.
`RedisAPI`	`xgroupAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xgroup(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xinfo(List<String> args)`	Redis command xinfo.
`Response`	`xinfoAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xinfo(List)`.
`RedisAPI`	`xinfoAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xinfo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xlen(String arg0)`	Redis command xlen.
`Response`	`xlenAndAwait(String arg0)`	Blocking variant of `xlen(String)`.
`RedisAPI`	`xlenAndForget(String arg0)`	Variant of `xlen(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xpending(List<String> args)`	Redis command xpending.
`Response`	`xpendingAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xpending(List)`.
`RedisAPI`	`xpendingAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xpending(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xrange(List<String> args)`	Redis command xrange.
`Response`	`xrangeAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xrange(List)`.
`RedisAPI`	`xrangeAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xrange(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xread(List<String> args)`	Redis command xread.
`Response`	`xreadAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xread(List)`.
`RedisAPI`	`xreadAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xread(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xreadgroup(List<String> args)`	Redis command xreadgroup.
`Response`	`xreadgroupAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xreadgroup(List)`.
`RedisAPI`	`xreadgroupAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xreadgroup(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xrevrange(List<String> args)`	Redis command xrevrange.
`Response`	`xrevrangeAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xrevrange(List)`.
`RedisAPI`	`xrevrangeAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xrevrange(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xsetid(String arg0, String arg1)`	Redis command xsetid.
`Response`	`xsetidAndAwait(String arg0, String arg1)`	Blocking variant of `xsetid(String,String)`.
`RedisAPI`	`xsetidAndForget(String arg0, String arg1)`	Variant of `xsetid(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xtrim(List<String> args)`	Redis command xtrim.
`Response`	`xtrimAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#xtrim(List)`.
`RedisAPI`	`xtrimAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#xtrim(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zadd(List<String> args)`	Redis command zadd.
`Response`	`zaddAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zadd(List)`.
`RedisAPI`	`zaddAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zcard(String arg0)`	Redis command zcard.
`Response`	`zcardAndAwait(String arg0)`	Blocking variant of `zcard(String)`.
`RedisAPI`	`zcardAndForget(String arg0)`	Variant of `zcard(String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zcount(String arg0, String arg1, String arg2)`	Redis command zcount.
`Response`	`zcountAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `zcount(String,String,String)`.
`RedisAPI`	`zcountAndForget(String arg0, String arg1, String arg2)`	Variant of `zcount(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zincrby(String arg0, String arg1, String arg2)`	Redis command zincrby.
`Response`	`zincrbyAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `zincrby(String,String,String)`.
`RedisAPI`	`zincrbyAndForget(String arg0, String arg1, String arg2)`	Variant of `zincrby(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zinterstore(List<String> args)`	Redis command zinterstore.
`Response`	`zinterstoreAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zinterstore(List)`.
`RedisAPI`	`zinterstoreAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zinterstore(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zlexcount(String arg0, String arg1, String arg2)`	Redis command zlexcount.
`Response`	`zlexcountAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `zlexcount(String,String,String)`.
`RedisAPI`	`zlexcountAndForget(String arg0, String arg1, String arg2)`	Variant of `zlexcount(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zpopmax(List<String> args)`	Redis command zpopmax.
`Response`	`zpopmaxAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zpopmax(List)`.
`RedisAPI`	`zpopmaxAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zpopmax(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zpopmin(List<String> args)`	Redis command zpopmin.
`Response`	`zpopminAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zpopmin(List)`.
`RedisAPI`	`zpopminAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zpopmin(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zrange(List<String> args)`	Redis command zrange.
`Response`	`zrangeAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zrange(List)`.
`RedisAPI`	`zrangeAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zrange(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zrangebylex(List<String> args)`	Redis command zrangebylex.
`Response`	`zrangebylexAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zrangebylex(List)`.
`RedisAPI`	`zrangebylexAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zrangebylex(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zrangebyscore(List<String> args)`	Redis command zrangebyscore.
`Response`	`zrangebyscoreAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zrangebyscore(List)`.
`RedisAPI`	`zrangebyscoreAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zrangebyscore(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zrank(String arg0, String arg1)`	Redis command zrank.
`Response`	`zrankAndAwait(String arg0, String arg1)`	Blocking variant of `zrank(String,String)`.
`RedisAPI`	`zrankAndForget(String arg0, String arg1)`	Variant of `zrank(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zrem(List<String> args)`	Redis command zrem.
`Response`	`zremAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zrem(List)`.
`RedisAPI`	`zremAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zrem(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zremrangebylex(String arg0, String arg1, String arg2)`	Redis command zremrangebylex.
`Response`	`zremrangebylexAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `zremrangebylex(String,String,String)`.
`RedisAPI`	`zremrangebylexAndForget(String arg0, String arg1, String arg2)`	Variant of `zremrangebylex(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zremrangebyrank(String arg0, String arg1, String arg2)`	Redis command zremrangebyrank.
`Response`	`zremrangebyrankAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `zremrangebyrank(String,String,String)`.
`RedisAPI`	`zremrangebyrankAndForget(String arg0, String arg1, String arg2)`	Variant of `zremrangebyrank(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zremrangebyscore(String arg0, String arg1, String arg2)`	Redis command zremrangebyscore.
`Response`	`zremrangebyscoreAndAwait(String arg0, String arg1, String arg2)`	Blocking variant of `zremrangebyscore(String,String,String)`.
`RedisAPI`	`zremrangebyscoreAndForget(String arg0, String arg1, String arg2)`	Variant of `zremrangebyscore(String,String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zrevrange(List<String> args)`	Redis command zrevrange.
`Response`	`zrevrangeAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zrevrange(List)`.
`RedisAPI`	`zrevrangeAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zrevrange(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zrevrangebylex(List<String> args)`	Redis command zrevrangebylex.
`Response`	`zrevrangebylexAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zrevrangebylex(List)`.
`RedisAPI`	`zrevrangebylexAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zrevrangebylex(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zrevrangebyscore(List<String> args)`	Redis command zrevrangebyscore.
`Response`	`zrevrangebyscoreAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zrevrangebyscore(List)`.
`RedisAPI`	`zrevrangebyscoreAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zrevrangebyscore(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zrevrank(String arg0, String arg1)`	Redis command zrevrank.
`Response`	`zrevrankAndAwait(String arg0, String arg1)`	Blocking variant of `zrevrank(String,String)`.
`RedisAPI`	`zrevrankAndForget(String arg0, String arg1)`	Variant of `zrevrank(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zscan(List<String> args)`	Redis command zscan.
`Response`	`zscanAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zscan(List)`.
`RedisAPI`	`zscanAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zscan(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zscore(String arg0, String arg1)`	Redis command zscore.
`Response`	`zscoreAndAwait(String arg0, String arg1)`	Blocking variant of `zscore(String,String)`.
`RedisAPI`	`zscoreAndForget(String arg0, String arg1)`	Variant of `zscore(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zunionstore(List<String> args)`	Redis command zunionstore.
`Response`	`zunionstoreAndAwait(List<String> args)`	Blocking variant of `io.vertx.mutiny.redis.client.RedisAPI#zunionstore(List)`.
`RedisAPI`	`zunionstoreAndForget(List<String> args)`	Variant of `io.vertx.mutiny.redis.client.RedisAPI#zunionstore(List)` that ignores the result of the operation.

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

- Field Detail
  - __TYPE_ARG
```
public static final TypeArg<RedisAPI> __TYPE_ARG
```
- Constructor Detail
  - RedisAPI
```
public RedisAPI(io.vertx.redis.client.RedisAPI delegate)
```
  - RedisAPI
```
public RedisAPI(Object delegate)
```
- Method Detail
  - getDelegate
```
public io.vertx.redis.client.RedisAPI getDelegate()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - close
```
public void close()
```
  - acl
```
public io.smallrye.mutiny.Uni<Response> acl(List<String> args)
```
    Redis command acl.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - aclAndAwait
```
public Response aclAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#acl(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - aclAndForget
```
public RedisAPI aclAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#acl(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#acl(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#acl(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - append
```
public io.smallrye.mutiny.Uni<Response> append(String arg0,
                                               String arg1)
```
    Redis command append.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - appendAndAwait
```
public Response appendAndAwait(String arg0,
                               String arg1)
```
    Blocking variant of append(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - appendAndForget
```
public RedisAPI appendAndForget(String arg0,
                                String arg1)
```
    Variant of append(String,String) that ignores the result of the operation.
    This method subscribes on the result of append(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from append(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - asking
```
public io.smallrye.mutiny.Uni<Response> asking()
```
    Redis command asking.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - askingAndAwait
```
public Response askingAndAwait()
```
    Blocking variant of asking().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - askingAndForget
```
public RedisAPI askingAndForget()
```
    Variant of asking() that ignores the result of the operation.
    This method subscribes on the result of asking(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from asking() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - auth
```
public io.smallrye.mutiny.Uni<Response> auth(List<String> args)
```
    Redis command auth.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - authAndAwait
```
public Response authAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#auth(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - authAndForget
```
public RedisAPI authAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#auth(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#auth(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#auth(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bgrewriteaof
```
public io.smallrye.mutiny.Uni<Response> bgrewriteaof()
```
    Redis command bgrewriteaof.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - bgrewriteaofAndAwait
```
public Response bgrewriteaofAndAwait()
```
    Blocking variant of bgrewriteaof().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - bgrewriteaofAndForget
```
public RedisAPI bgrewriteaofAndForget()
```
    Variant of bgrewriteaof() that ignores the result of the operation.
    This method subscribes on the result of bgrewriteaof(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bgrewriteaof() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bgsave
```
public io.smallrye.mutiny.Uni<Response> bgsave(List<String> args)
```
    Redis command bgsave.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - bgsaveAndAwait
```
public Response bgsaveAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bgsave(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - bgsaveAndForget
```
public RedisAPI bgsaveAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#bgsave(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bgsave(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bgsave(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bitcount
```
public io.smallrye.mutiny.Uni<Response> bitcount(List<String> args)
```
    Redis command bitcount.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - bitcountAndAwait
```
public Response bitcountAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bitcount(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - bitcountAndForget
```
public RedisAPI bitcountAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#bitcount(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bitcount(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bitcount(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bitfield
```
public io.smallrye.mutiny.Uni<Response> bitfield(List<String> args)
```
    Redis command bitfield.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - bitfieldAndAwait
```
public Response bitfieldAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bitfield(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - bitfieldAndForget
```
public RedisAPI bitfieldAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#bitfield(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bitfield(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bitfield(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bitfieldRo
```
public io.smallrye.mutiny.Uni<Response> bitfieldRo(List<String> args)
```
    Redis command bitfieldRo.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - bitfieldRoAndAwait
```
public Response bitfieldRoAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bitfieldRo(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - bitfieldRoAndForget
```
public RedisAPI bitfieldRoAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#bitfieldRo(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bitfieldRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bitfieldRo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bitop
```
public io.smallrye.mutiny.Uni<Response> bitop(List<String> args)
```
    Redis command bitop.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - bitopAndAwait
```
public Response bitopAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bitop(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - bitopAndForget
```
public RedisAPI bitopAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#bitop(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bitop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bitop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bitpos
```
public io.smallrye.mutiny.Uni<Response> bitpos(List<String> args)
```
    Redis command bitpos.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - bitposAndAwait
```
public Response bitposAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bitpos(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - bitposAndForget
```
public RedisAPI bitposAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#bitpos(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bitpos(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bitpos(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - blpop
```
public io.smallrye.mutiny.Uni<Response> blpop(List<String> args)
```
    Redis command blpop.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - blpopAndAwait
```
public Response blpopAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#blpop(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - blpopAndForget
```
public RedisAPI blpopAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#blpop(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#blpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#blpop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - brpop
```
public io.smallrye.mutiny.Uni<Response> brpop(List<String> args)
```
    Redis command brpop.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - brpopAndAwait
```
public Response brpopAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#brpop(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - brpopAndForget
```
public RedisAPI brpopAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#brpop(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#brpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#brpop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - brpoplpush
```
public io.smallrye.mutiny.Uni<Response> brpoplpush(String arg0,
                                                   String arg1,
                                                   String arg2)
```
    Redis command brpoplpush.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - brpoplpushAndAwait
```
public Response brpoplpushAndAwait(String arg0,
                                   String arg1,
                                   String arg2)
```
    Blocking variant of brpoplpush(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - brpoplpushAndForget
```
public RedisAPI brpoplpushAndForget(String arg0,
                                    String arg1,
                                    String arg2)
```
    Variant of brpoplpush(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of brpoplpush(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from brpoplpush(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bzpopmax
```
public io.smallrye.mutiny.Uni<Response> bzpopmax(List<String> args)
```
    Redis command bzpopmax.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - bzpopmaxAndAwait
```
public Response bzpopmaxAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bzpopmax(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - bzpopmaxAndForget
```
public RedisAPI bzpopmaxAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#bzpopmax(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bzpopmax(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bzpopmax(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bzpopmin
```
public io.smallrye.mutiny.Uni<Response> bzpopmin(List<String> args)
```
    Redis command bzpopmin.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - bzpopminAndAwait
```
public Response bzpopminAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#bzpopmin(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - bzpopminAndForget
```
public RedisAPI bzpopminAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#bzpopmin(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#bzpopmin(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#bzpopmin(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - client
```
public io.smallrye.mutiny.Uni<Response> client(List<String> args)
```
    Redis command client.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - clientAndAwait
```
public Response clientAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#client(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - clientAndForget
```
public RedisAPI clientAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#client(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#client(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#client(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cluster
```
public io.smallrye.mutiny.Uni<Response> cluster(List<String> args)
```
    Redis command cluster.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - clusterAndAwait
```
public Response clusterAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#cluster(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - clusterAndForget
```
public RedisAPI clusterAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#cluster(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#cluster(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#cluster(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - command
```
public io.smallrye.mutiny.Uni<Response> command(List<String> args)
```
    Redis command command.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - commandAndAwait
```
public Response commandAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#command(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - commandAndForget
```
public RedisAPI commandAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#command(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#command(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#command(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - config
```
public io.smallrye.mutiny.Uni<Response> config(List<String> args)
```
    Redis command config.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - configAndAwait
```
public Response configAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#config(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - configAndForget
```
public RedisAPI configAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#config(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#config(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#config(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - dbsize
```
public io.smallrye.mutiny.Uni<Response> dbsize()
```
    Redis command dbsize.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - dbsizeAndAwait
```
public Response dbsizeAndAwait()
```
    Blocking variant of dbsize().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - dbsizeAndForget
```
public RedisAPI dbsizeAndForget()
```
    Variant of dbsize() that ignores the result of the operation.
    This method subscribes on the result of dbsize(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from dbsize() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - debug
```
public io.smallrye.mutiny.Uni<Response> debug(List<String> args)
```
    Redis command debug.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - debugAndAwait
```
public Response debugAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#debug(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - debugAndForget
```
public RedisAPI debugAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#debug(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#debug(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#debug(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - decr
```
public io.smallrye.mutiny.Uni<Response> decr(String arg0)
```
    Redis command decr.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - decrAndAwait
```
public Response decrAndAwait(String arg0)
```
    Blocking variant of decr(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - decrAndForget
```
public RedisAPI decrAndForget(String arg0)
```
    Variant of decr(String) that ignores the result of the operation.
    This method subscribes on the result of decr(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from decr(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - decrby
```
public io.smallrye.mutiny.Uni<Response> decrby(String arg0,
                                               String arg1)
```
    Redis command decrby.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - decrbyAndAwait
```
public Response decrbyAndAwait(String arg0,
                               String arg1)
```
    Blocking variant of decrby(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - decrbyAndForget
```
public RedisAPI decrbyAndForget(String arg0,
                                String arg1)
```
    Variant of decrby(String,String) that ignores the result of the operation.
    This method subscribes on the result of decrby(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from decrby(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - del
```
public io.smallrye.mutiny.Uni<Response> del(List<String> args)
```
    Redis command del.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - delAndAwait
```
public Response delAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#del(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - delAndForget
```
public RedisAPI delAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#del(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#del(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#del(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - discard
```
public io.smallrye.mutiny.Uni<Response> discard()
```
    Redis command discard.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - discardAndAwait
```
public Response discardAndAwait()
```
    Blocking variant of discard().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - discardAndForget
```
public RedisAPI discardAndForget()
```
    Variant of discard() that ignores the result of the operation.
    This method subscribes on the result of discard(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from discard() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - dump
```
public io.smallrye.mutiny.Uni<Response> dump(String arg0)
```
    Redis command dump.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - dumpAndAwait
```
public Response dumpAndAwait(String arg0)
```
    Blocking variant of dump(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - dumpAndForget
```
public RedisAPI dumpAndForget(String arg0)
```
    Variant of dump(String) that ignores the result of the operation.
    This method subscribes on the result of dump(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from dump(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - echo
```
public io.smallrye.mutiny.Uni<Response> echo(String arg0)
```
    Redis command echo.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - echoAndAwait
```
public Response echoAndAwait(String arg0)
```
    Blocking variant of echo(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - echoAndForget
```
public RedisAPI echoAndForget(String arg0)
```
    Variant of echo(String) that ignores the result of the operation.
    This method subscribes on the result of echo(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from echo(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - eval
```
public io.smallrye.mutiny.Uni<Response> eval(List<String> args)
```
    Redis command eval.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - evalAndAwait
```
public Response evalAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#eval(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - evalAndForget
```
public RedisAPI evalAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#eval(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#eval(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#eval(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - evalsha
```
public io.smallrye.mutiny.Uni<Response> evalsha(List<String> args)
```
    Redis command evalsha.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - evalshaAndAwait
```
public Response evalshaAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#evalsha(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - evalshaAndForget
```
public RedisAPI evalshaAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#evalsha(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#evalsha(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#evalsha(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - exec
```
public io.smallrye.mutiny.Uni<Response> exec()
```
    Redis command exec.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - execAndAwait
```
public Response execAndAwait()
```
    Blocking variant of exec().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - execAndForget
```
public RedisAPI execAndForget()
```
    Variant of exec() that ignores the result of the operation.
    This method subscribes on the result of exec(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from exec() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - exists
```
public io.smallrye.mutiny.Uni<Response> exists(List<String> args)
```
    Redis command exists.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - existsAndAwait
```
public Response existsAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#exists(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - existsAndForget
```
public RedisAPI existsAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#exists(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#exists(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#exists(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - expire
```
public io.smallrye.mutiny.Uni<Response> expire(String arg0,
                                               String arg1)
```
    Redis command expire.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - expireAndAwait
```
public Response expireAndAwait(String arg0,
                               String arg1)
```
    Blocking variant of expire(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - expireAndForget
```
public RedisAPI expireAndForget(String arg0,
                                String arg1)
```
    Variant of expire(String,String) that ignores the result of the operation.
    This method subscribes on the result of expire(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from expire(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - expireat
```
public io.smallrye.mutiny.Uni<Response> expireat(String arg0,
                                                 String arg1)
```
    Redis command expireat.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - expireatAndAwait
```
public Response expireatAndAwait(String arg0,
                                 String arg1)
```
    Blocking variant of expireat(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - expireatAndForget
```
public RedisAPI expireatAndForget(String arg0,
                                  String arg1)
```
    Variant of expireat(String,String) that ignores the result of the operation.
    This method subscribes on the result of expireat(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from expireat(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - flushall
```
public io.smallrye.mutiny.Uni<Response> flushall(List<String> args)
```
    Redis command flushall.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - flushallAndAwait
```
public Response flushallAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#flushall(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - flushallAndForget
```
public RedisAPI flushallAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#flushall(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#flushall(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#flushall(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - flushdb
```
public io.smallrye.mutiny.Uni<Response> flushdb(List<String> args)
```
    Redis command flushdb.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - flushdbAndAwait
```
public Response flushdbAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#flushdb(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - flushdbAndForget
```
public RedisAPI flushdbAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#flushdb(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#flushdb(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#flushdb(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - geoadd
```
public io.smallrye.mutiny.Uni<Response> geoadd(List<String> args)
```
    Redis command geoadd.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - geoaddAndAwait
```
public Response geoaddAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#geoadd(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - geoaddAndForget
```
public RedisAPI geoaddAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#geoadd(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#geoadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#geoadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - geodist
```
public io.smallrye.mutiny.Uni<Response> geodist(List<String> args)
```
    Redis command geodist.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - geodistAndAwait
```
public Response geodistAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#geodist(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - geodistAndForget
```
public RedisAPI geodistAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#geodist(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#geodist(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#geodist(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - geohash
```
public io.smallrye.mutiny.Uni<Response> geohash(List<String> args)
```
    Redis command geohash.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - geohashAndAwait
```
public Response geohashAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#geohash(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - geohashAndForget
```
public RedisAPI geohashAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#geohash(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#geohash(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#geohash(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - geopos
```
public io.smallrye.mutiny.Uni<Response> geopos(List<String> args)
```
    Redis command geopos.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - geoposAndAwait
```
public Response geoposAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#geopos(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - geoposAndForget
```
public RedisAPI geoposAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#geopos(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#geopos(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#geopos(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - georadius
```
public io.smallrye.mutiny.Uni<Response> georadius(List<String> args)
```
    Redis command georadius.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - georadiusAndAwait
```
public Response georadiusAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#georadius(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - georadiusAndForget
```
public RedisAPI georadiusAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#georadius(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#georadius(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#georadius(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - georadiusRo
```
public io.smallrye.mutiny.Uni<Response> georadiusRo(List<String> args)
```
    Redis command georadiusRo.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - georadiusRoAndAwait
```
public Response georadiusRoAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusRo(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - georadiusRoAndForget
```
public RedisAPI georadiusRoAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusRo(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#georadiusRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#georadiusRo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - georadiusbymember
```
public io.smallrye.mutiny.Uni<Response> georadiusbymember(List<String> args)
```
    Redis command georadiusbymember.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - georadiusbymemberAndAwait
```
public Response georadiusbymemberAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymember(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - georadiusbymemberAndForget
```
public RedisAPI georadiusbymemberAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymember(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymember(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#georadiusbymember(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - georadiusbymemberRo
```
public io.smallrye.mutiny.Uni<Response> georadiusbymemberRo(List<String> args)
```
    Redis command georadiusbymemberRo.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - georadiusbymemberRoAndAwait
```
public Response georadiusbymemberRoAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymemberRo(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - georadiusbymemberRoAndForget
```
public RedisAPI georadiusbymemberRoAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymemberRo(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#georadiusbymemberRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#georadiusbymemberRo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - get
```
public io.smallrye.mutiny.Uni<Response> get(String arg0)
```
    Redis command get.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getAndAwait
```
public Response getAndAwait(String arg0)
```
    Blocking variant of get(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - getAndForget
```
public RedisAPI getAndForget(String arg0)
```
    Variant of get(String) that ignores the result of the operation.
    This method subscribes on the result of get(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from get(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - getbit
```
public io.smallrye.mutiny.Uni<Response> getbit(String arg0,
                                               String arg1)
```
    Redis command getbit.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getbitAndAwait
```
public Response getbitAndAwait(String arg0,
                               String arg1)
```
    Blocking variant of getbit(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - getbitAndForget
```
public RedisAPI getbitAndForget(String arg0,
                                String arg1)
```
    Variant of getbit(String,String) that ignores the result of the operation.
    This method subscribes on the result of getbit(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getbit(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - getrange
```
public io.smallrye.mutiny.Uni<Response> getrange(String arg0,
                                                 String arg1,
                                                 String arg2)
```
    Redis command getrange.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getrangeAndAwait
```
public Response getrangeAndAwait(String arg0,
                                 String arg1,
                                 String arg2)
```
    Blocking variant of getrange(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - getrangeAndForget
```
public RedisAPI getrangeAndForget(String arg0,
                                  String arg1,
                                  String arg2)
```
    Variant of getrange(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of getrange(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getrange(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - getset
```
public io.smallrye.mutiny.Uni<Response> getset(String arg0,
                                               String arg1)
```
    Redis command getset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - getsetAndAwait
```
public Response getsetAndAwait(String arg0,
                               String arg1)
```
    Blocking variant of getset(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - getsetAndForget
```
public RedisAPI getsetAndForget(String arg0,
                                String arg1)
```
    Variant of getset(String,String) that ignores the result of the operation.
    This method subscribes on the result of getset(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getset(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hdel
```
public io.smallrye.mutiny.Uni<Response> hdel(List<String> args)
```
    Redis command hdel.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hdelAndAwait
```
public Response hdelAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hdel(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - hdelAndForget
```
public RedisAPI hdelAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#hdel(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hdel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hdel(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hello
```
public io.smallrye.mutiny.Uni<Response> hello(List<String> args)
```
    Redis command hello.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - helloAndAwait
```
public Response helloAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hello(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - helloAndForget
```
public RedisAPI helloAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#hello(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hello(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hello(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hexists
```
public io.smallrye.mutiny.Uni<Response> hexists(String arg0,
                                                String arg1)
```
    Redis command hexists.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hexistsAndAwait
```
public Response hexistsAndAwait(String arg0,
                                String arg1)
```
    Blocking variant of hexists(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - hexistsAndForget
```
public RedisAPI hexistsAndForget(String arg0,
                                 String arg1)
```
    Variant of hexists(String,String) that ignores the result of the operation.
    This method subscribes on the result of hexists(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hexists(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hget
```
public io.smallrye.mutiny.Uni<Response> hget(String arg0,
                                             String arg1)
```
    Redis command hget.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hgetAndAwait
```
public Response hgetAndAwait(String arg0,
                             String arg1)
```
    Blocking variant of hget(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - hgetAndForget
```
public RedisAPI hgetAndForget(String arg0,
                              String arg1)
```
    Variant of hget(String,String) that ignores the result of the operation.
    This method subscribes on the result of hget(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hget(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hgetall
```
public io.smallrye.mutiny.Uni<Response> hgetall(String arg0)
```
    Redis command hgetall.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hgetallAndAwait
```
public Response hgetallAndAwait(String arg0)
```
    Blocking variant of hgetall(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - hgetallAndForget
```
public RedisAPI hgetallAndForget(String arg0)
```
    Variant of hgetall(String) that ignores the result of the operation.
    This method subscribes on the result of hgetall(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hgetall(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hincrby
```
public io.smallrye.mutiny.Uni<Response> hincrby(String arg0,
                                                String arg1,
                                                String arg2)
```
    Redis command hincrby.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hincrbyAndAwait
```
public Response hincrbyAndAwait(String arg0,
                                String arg1,
                                String arg2)
```
    Blocking variant of hincrby(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - hincrbyAndForget
```
public RedisAPI hincrbyAndForget(String arg0,
                                 String arg1,
                                 String arg2)
```
    Variant of hincrby(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of hincrby(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hincrby(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hincrbyfloat
```
public io.smallrye.mutiny.Uni<Response> hincrbyfloat(String arg0,
                                                     String arg1,
                                                     String arg2)
```
    Redis command hincrbyfloat.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hincrbyfloatAndAwait
```
public Response hincrbyfloatAndAwait(String arg0,
                                     String arg1,
                                     String arg2)
```
    Blocking variant of hincrbyfloat(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - hincrbyfloatAndForget
```
public RedisAPI hincrbyfloatAndForget(String arg0,
                                      String arg1,
                                      String arg2)
```
    Variant of hincrbyfloat(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of hincrbyfloat(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hincrbyfloat(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hkeys
```
public io.smallrye.mutiny.Uni<Response> hkeys(String arg0)
```
    Redis command hkeys.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hkeysAndAwait
```
public Response hkeysAndAwait(String arg0)
```
    Blocking variant of hkeys(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - hkeysAndForget
```
public RedisAPI hkeysAndForget(String arg0)
```
    Variant of hkeys(String) that ignores the result of the operation.
    This method subscribes on the result of hkeys(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hkeys(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hlen
```
public io.smallrye.mutiny.Uni<Response> hlen(String arg0)
```
    Redis command hlen.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hlenAndAwait
```
public Response hlenAndAwait(String arg0)
```
    Blocking variant of hlen(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - hlenAndForget
```
public RedisAPI hlenAndForget(String arg0)
```
    Variant of hlen(String) that ignores the result of the operation.
    This method subscribes on the result of hlen(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hlen(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hmget
```
public io.smallrye.mutiny.Uni<Response> hmget(List<String> args)
```
    Redis command hmget.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hmgetAndAwait
```
public Response hmgetAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hmget(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - hmgetAndForget
```
public RedisAPI hmgetAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#hmget(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hmget(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hmget(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hmset
```
public io.smallrye.mutiny.Uni<Response> hmset(List<String> args)
```
    Redis command hmset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hmsetAndAwait
```
public Response hmsetAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hmset(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - hmsetAndForget
```
public RedisAPI hmsetAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#hmset(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hmset(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hmset(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - host
```
public io.smallrye.mutiny.Uni<Response> host(List<String> args)
```
    Redis command host.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hostAndAwait
```
public Response hostAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#host(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - hostAndForget
```
public RedisAPI hostAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#host(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#host(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#host(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hscan
```
public io.smallrye.mutiny.Uni<Response> hscan(List<String> args)
```
    Redis command hscan.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hscanAndAwait
```
public Response hscanAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hscan(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - hscanAndForget
```
public RedisAPI hscanAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#hscan(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hscan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hscan(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hset
```
public io.smallrye.mutiny.Uni<Response> hset(List<String> args)
```
    Redis command hset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hsetAndAwait
```
public Response hsetAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#hset(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - hsetAndForget
```
public RedisAPI hsetAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#hset(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#hset(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#hset(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hsetnx
```
public io.smallrye.mutiny.Uni<Response> hsetnx(String arg0,
                                               String arg1,
                                               String arg2)
```
    Redis command hsetnx.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hsetnxAndAwait
```
public Response hsetnxAndAwait(String arg0,
                               String arg1,
                               String arg2)
```
    Blocking variant of hsetnx(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - hsetnxAndForget
```
public RedisAPI hsetnxAndForget(String arg0,
                                String arg1,
                                String arg2)
```
    Variant of hsetnx(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of hsetnx(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hsetnx(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hstrlen
```
public io.smallrye.mutiny.Uni<Response> hstrlen(String arg0,
                                                String arg1)
```
    Redis command hstrlen.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hstrlenAndAwait
```
public Response hstrlenAndAwait(String arg0,
                                String arg1)
```
    Blocking variant of hstrlen(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - hstrlenAndForget
```
public RedisAPI hstrlenAndForget(String arg0,
                                 String arg1)
```
    Variant of hstrlen(String,String) that ignores the result of the operation.
    This method subscribes on the result of hstrlen(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hstrlen(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hvals
```
public io.smallrye.mutiny.Uni<Response> hvals(String arg0)
```
    Redis command hvals.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - hvalsAndAwait
```
public Response hvalsAndAwait(String arg0)
```
    Blocking variant of hvals(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - hvalsAndForget
```
public RedisAPI hvalsAndForget(String arg0)
```
    Variant of hvals(String) that ignores the result of the operation.
    This method subscribes on the result of hvals(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hvals(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - incr
```
public io.smallrye.mutiny.Uni<Response> incr(String arg0)
```
    Redis command incr.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - incrAndAwait
```
public Response incrAndAwait(String arg0)
```
    Blocking variant of incr(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - incrAndForget
```
public RedisAPI incrAndForget(String arg0)
```
    Variant of incr(String) that ignores the result of the operation.
    This method subscribes on the result of incr(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from incr(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - incrby
```
public io.smallrye.mutiny.Uni<Response> incrby(String arg0,
                                               String arg1)
```
    Redis command incrby.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - incrbyAndAwait
```
public Response incrbyAndAwait(String arg0,
                               String arg1)
```
    Blocking variant of incrby(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - incrbyAndForget
```
public RedisAPI incrbyAndForget(String arg0,
                                String arg1)
```
    Variant of incrby(String,String) that ignores the result of the operation.
    This method subscribes on the result of incrby(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from incrby(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - incrbyfloat
```
public io.smallrye.mutiny.Uni<Response> incrbyfloat(String arg0,
                                                    String arg1)
```
    Redis command incrbyfloat.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - incrbyfloatAndAwait
```
public Response incrbyfloatAndAwait(String arg0,
                                    String arg1)
```
    Blocking variant of incrbyfloat(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - incrbyfloatAndForget
```
public RedisAPI incrbyfloatAndForget(String arg0,
                                     String arg1)
```
    Variant of incrbyfloat(String,String) that ignores the result of the operation.
    This method subscribes on the result of incrbyfloat(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from incrbyfloat(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - info
```
public io.smallrye.mutiny.Uni<Response> info(List<String> args)
```
    Redis command info.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - infoAndAwait
```
public Response infoAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#info(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - infoAndForget
```
public RedisAPI infoAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#info(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#info(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#info(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - keys
```
public io.smallrye.mutiny.Uni<Response> keys(String arg0)
```
    Redis command keys.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - keysAndAwait
```
public Response keysAndAwait(String arg0)
```
    Blocking variant of keys(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - keysAndForget
```
public RedisAPI keysAndForget(String arg0)
```
    Variant of keys(String) that ignores the result of the operation.
    This method subscribes on the result of keys(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from keys(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - lastsave
```
public io.smallrye.mutiny.Uni<Response> lastsave()
```
    Redis command lastsave.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - lastsaveAndAwait
```
public Response lastsaveAndAwait()
```
    Blocking variant of lastsave().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - lastsaveAndForget
```
public RedisAPI lastsaveAndForget()
```
    Variant of lastsave() that ignores the result of the operation.
    This method subscribes on the result of lastsave(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lastsave() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - latency
```
public io.smallrye.mutiny.Uni<Response> latency(List<String> args)
```
    Redis command latency.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - latencyAndAwait
```
public Response latencyAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#latency(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - latencyAndForget
```
public RedisAPI latencyAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#latency(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#latency(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#latency(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - lindex
```
public io.smallrye.mutiny.Uni<Response> lindex(String arg0,
                                               String arg1)
```
    Redis command lindex.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - lindexAndAwait
```
public Response lindexAndAwait(String arg0,
                               String arg1)
```
    Blocking variant of lindex(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - lindexAndForget
```
public RedisAPI lindexAndForget(String arg0,
                                String arg1)
```
    Variant of lindex(String,String) that ignores the result of the operation.
    This method subscribes on the result of lindex(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lindex(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - linsert
```
public io.smallrye.mutiny.Uni<Response> linsert(String arg0,
                                                String arg1,
                                                String arg2,
                                                String arg3)
```
    Redis command linsert.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    arg3 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - linsertAndAwait
```
public Response linsertAndAwait(String arg0,
                                String arg1,
                                String arg2,
                                String arg3)
```
    Blocking variant of linsert(String,String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    arg3 -
    
    Returns:
    
    the Response instance produced by the operation.
  - linsertAndForget
```
public RedisAPI linsertAndForget(String arg0,
                                 String arg1,
                                 String arg2,
                                 String arg3)
```
    Variant of linsert(String,String,String,String) that ignores the result of the operation.
    This method subscribes on the result of linsert(String,String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from linsert(String,String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    arg3 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - llen
```
public io.smallrye.mutiny.Uni<Response> llen(String arg0)
```
    Redis command llen.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - llenAndAwait
```
public Response llenAndAwait(String arg0)
```
    Blocking variant of llen(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - llenAndForget
```
public RedisAPI llenAndForget(String arg0)
```
    Variant of llen(String) that ignores the result of the operation.
    This method subscribes on the result of llen(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from llen(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - lolwut
```
public io.smallrye.mutiny.Uni<Response> lolwut(List<String> args)
```
    Redis command lolwut.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - lolwutAndAwait
```
public Response lolwutAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#lolwut(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - lolwutAndForget
```
public RedisAPI lolwutAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#lolwut(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#lolwut(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#lolwut(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - lpop
```
public io.smallrye.mutiny.Uni<Response> lpop(String arg0)
```
    Redis command lpop.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - lpopAndAwait
```
public Response lpopAndAwait(String arg0)
```
    Blocking variant of lpop(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - lpopAndForget
```
public RedisAPI lpopAndForget(String arg0)
```
    Variant of lpop(String) that ignores the result of the operation.
    This method subscribes on the result of lpop(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lpop(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - lpush
```
public io.smallrye.mutiny.Uni<Response> lpush(List<String> args)
```
    Redis command lpush.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - lpushAndAwait
```
public Response lpushAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#lpush(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - lpushAndForget
```
public RedisAPI lpushAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#lpush(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#lpush(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#lpush(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - lpushx
```
public io.smallrye.mutiny.Uni<Response> lpushx(List<String> args)
```
    Redis command lpushx.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - lpushxAndAwait
```
public Response lpushxAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#lpushx(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - lpushxAndForget
```
public RedisAPI lpushxAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#lpushx(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#lpushx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#lpushx(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - lrange
```
public io.smallrye.mutiny.Uni<Response> lrange(String arg0,
                                               String arg1,
                                               String arg2)
```
    Redis command lrange.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - lrangeAndAwait
```
public Response lrangeAndAwait(String arg0,
                               String arg1,
                               String arg2)
```
    Blocking variant of lrange(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - lrangeAndForget
```
public RedisAPI lrangeAndForget(String arg0,
                                String arg1,
                                String arg2)
```
    Variant of lrange(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of lrange(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lrange(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - lrem
```
public io.smallrye.mutiny.Uni<Response> lrem(String arg0,
                                             String arg1,
                                             String arg2)
```
    Redis command lrem.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - lremAndAwait
```
public Response lremAndAwait(String arg0,
                             String arg1,
                             String arg2)
```
    Blocking variant of lrem(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - lremAndForget
```
public RedisAPI lremAndForget(String arg0,
                              String arg1,
                              String arg2)
```
    Variant of lrem(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of lrem(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lrem(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - lset
```
public io.smallrye.mutiny.Uni<Response> lset(String arg0,
                                             String arg1,
                                             String arg2)
```
    Redis command lset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - lsetAndAwait
```
public Response lsetAndAwait(String arg0,
                             String arg1,
                             String arg2)
```
    Blocking variant of lset(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - lsetAndForget
```
public RedisAPI lsetAndForget(String arg0,
                              String arg1,
                              String arg2)
```
    Variant of lset(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of lset(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lset(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ltrim
```
public io.smallrye.mutiny.Uni<Response> ltrim(String arg0,
                                              String arg1,
                                              String arg2)
```
    Redis command ltrim.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - ltrimAndAwait
```
public Response ltrimAndAwait(String arg0,
                              String arg1,
                              String arg2)
```
    Blocking variant of ltrim(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - ltrimAndForget
```
public RedisAPI ltrimAndForget(String arg0,
                               String arg1,
                               String arg2)
```
    Variant of ltrim(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of ltrim(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ltrim(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - memory
```
public io.smallrye.mutiny.Uni<Response> memory(List<String> args)
```
    Redis command memory.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - memoryAndAwait
```
public Response memoryAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#memory(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - memoryAndForget
```
public RedisAPI memoryAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#memory(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#memory(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#memory(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - mget
```
public io.smallrye.mutiny.Uni<Response> mget(List<String> args)
```
    Redis command mget.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - mgetAndAwait
```
public Response mgetAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#mget(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - mgetAndForget
```
public RedisAPI mgetAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#mget(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#mget(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#mget(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - migrate
```
public io.smallrye.mutiny.Uni<Response> migrate(List<String> args)
```
    Redis command migrate.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - migrateAndAwait
```
public Response migrateAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#migrate(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - migrateAndForget
```
public RedisAPI migrateAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#migrate(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#migrate(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#migrate(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - module
```
public io.smallrye.mutiny.Uni<Response> module(List<String> args)
```
    Redis command module.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - moduleAndAwait
```
public Response moduleAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#module(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - moduleAndForget
```
public RedisAPI moduleAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#module(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#module(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#module(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - monitor
```
public io.smallrye.mutiny.Uni<Response> monitor()
```
    Redis command monitor.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - monitorAndAwait
```
public Response monitorAndAwait()
```
    Blocking variant of monitor().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - monitorAndForget
```
public RedisAPI monitorAndForget()
```
    Variant of monitor() that ignores the result of the operation.
    This method subscribes on the result of monitor(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from monitor() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - move
```
public io.smallrye.mutiny.Uni<Response> move(String arg0,
                                             String arg1)
```
    Redis command move.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - moveAndAwait
```
public Response moveAndAwait(String arg0,
                             String arg1)
```
    Blocking variant of move(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - moveAndForget
```
public RedisAPI moveAndForget(String arg0,
                              String arg1)
```
    Variant of move(String,String) that ignores the result of the operation.
    This method subscribes on the result of move(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from move(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - mset
```
public io.smallrye.mutiny.Uni<Response> mset(List<String> args)
```
    Redis command mset.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - msetAndAwait
```
public Response msetAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#mset(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - msetAndForget
```
public RedisAPI msetAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#mset(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#mset(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#mset(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - msetnx
```
public io.smallrye.mutiny.Uni<Response> msetnx(List<String> args)
```
    Redis command msetnx.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - msetnxAndAwait
```
public Response msetnxAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#msetnx(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - msetnxAndForget
```
public RedisAPI msetnxAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#msetnx(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#msetnx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#msetnx(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - multi
```
public io.smallrye.mutiny.Uni<Response> multi()
```
    Redis command multi.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - multiAndAwait
```
public Response multiAndAwait()
```
    Blocking variant of multi().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - multiAndForget
```
public RedisAPI multiAndForget()
```
    Variant of multi() that ignores the result of the operation.
    This method subscribes on the result of multi(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from multi() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - object
```
public io.smallrye.mutiny.Uni<Response> object(List<String> args)
```
    Redis command object.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - objectAndAwait
```
public Response objectAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#object(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - objectAndForget
```
public RedisAPI objectAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#object(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#object(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#object(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - persist
```
public io.smallrye.mutiny.Uni<Response> persist(String arg0)
```
    Redis command persist.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - persistAndAwait
```
public Response persistAndAwait(String arg0)
```
    Blocking variant of persist(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - persistAndForget
```
public RedisAPI persistAndForget(String arg0)
```
    Variant of persist(String) that ignores the result of the operation.
    This method subscribes on the result of persist(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from persist(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pexpire
```
public io.smallrye.mutiny.Uni<Response> pexpire(String arg0,
                                                String arg1)
```
    Redis command pexpire.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pexpireAndAwait
```
public Response pexpireAndAwait(String arg0,
                                String arg1)
```
    Blocking variant of pexpire(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - pexpireAndForget
```
public RedisAPI pexpireAndForget(String arg0,
                                 String arg1)
```
    Variant of pexpire(String,String) that ignores the result of the operation.
    This method subscribes on the result of pexpire(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pexpire(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pexpireat
```
public io.smallrye.mutiny.Uni<Response> pexpireat(String arg0,
                                                  String arg1)
```
    Redis command pexpireat.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pexpireatAndAwait
```
public Response pexpireatAndAwait(String arg0,
                                  String arg1)
```
    Blocking variant of pexpireat(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - pexpireatAndForget
```
public RedisAPI pexpireatAndForget(String arg0,
                                   String arg1)
```
    Variant of pexpireat(String,String) that ignores the result of the operation.
    This method subscribes on the result of pexpireat(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pexpireat(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pfadd
```
public io.smallrye.mutiny.Uni<Response> pfadd(List<String> args)
```
    Redis command pfadd.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pfaddAndAwait
```
public Response pfaddAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#pfadd(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - pfaddAndForget
```
public RedisAPI pfaddAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#pfadd(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#pfadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#pfadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pfcount
```
public io.smallrye.mutiny.Uni<Response> pfcount(List<String> args)
```
    Redis command pfcount.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pfcountAndAwait
```
public Response pfcountAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#pfcount(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - pfcountAndForget
```
public RedisAPI pfcountAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#pfcount(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#pfcount(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#pfcount(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pfdebug
```
public io.smallrye.mutiny.Uni<Response> pfdebug(List<String> args)
```
    Redis command pfdebug.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pfdebugAndAwait
```
public Response pfdebugAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#pfdebug(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - pfdebugAndForget
```
public RedisAPI pfdebugAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#pfdebug(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#pfdebug(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#pfdebug(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pfmerge
```
public io.smallrye.mutiny.Uni<Response> pfmerge(List<String> args)
```
    Redis command pfmerge.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pfmergeAndAwait
```
public Response pfmergeAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#pfmerge(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - pfmergeAndForget
```
public RedisAPI pfmergeAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#pfmerge(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#pfmerge(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#pfmerge(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pfselftest
```
public io.smallrye.mutiny.Uni<Response> pfselftest()
```
    Redis command pfselftest.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pfselftestAndAwait
```
public Response pfselftestAndAwait()
```
    Blocking variant of pfselftest().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - pfselftestAndForget
```
public RedisAPI pfselftestAndForget()
```
    Variant of pfselftest() that ignores the result of the operation.
    This method subscribes on the result of pfselftest(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pfselftest() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ping
```
public io.smallrye.mutiny.Uni<Response> ping(List<String> args)
```
    Redis command ping.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pingAndAwait
```
public Response pingAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#ping(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - pingAndForget
```
public RedisAPI pingAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#ping(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#ping(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#ping(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - post
```
public io.smallrye.mutiny.Uni<Response> post(List<String> args)
```
    Redis command post.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - postAndAwait
```
public Response postAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#post(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - postAndForget
```
public RedisAPI postAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#post(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#post(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#post(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - psetex
```
public io.smallrye.mutiny.Uni<Response> psetex(String arg0,
                                               String arg1,
                                               String arg2)
```
    Redis command psetex.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - psetexAndAwait
```
public Response psetexAndAwait(String arg0,
                               String arg1,
                               String arg2)
```
    Blocking variant of psetex(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - psetexAndForget
```
public RedisAPI psetexAndForget(String arg0,
                                String arg1,
                                String arg2)
```
    Variant of psetex(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of psetex(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from psetex(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - psubscribe
```
public io.smallrye.mutiny.Uni<Response> psubscribe(List<String> args)
```
    Redis command psubscribe.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - psubscribeAndAwait
```
public Response psubscribeAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#psubscribe(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - psubscribeAndForget
```
public RedisAPI psubscribeAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#psubscribe(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#psubscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#psubscribe(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - psync
```
public io.smallrye.mutiny.Uni<Response> psync(String arg0,
                                              String arg1)
```
    Redis command psync.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - psyncAndAwait
```
public Response psyncAndAwait(String arg0,
                              String arg1)
```
    Blocking variant of psync(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - psyncAndForget
```
public RedisAPI psyncAndForget(String arg0,
                               String arg1)
```
    Variant of psync(String,String) that ignores the result of the operation.
    This method subscribes on the result of psync(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from psync(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pttl
```
public io.smallrye.mutiny.Uni<Response> pttl(String arg0)
```
    Redis command pttl.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pttlAndAwait
```
public Response pttlAndAwait(String arg0)
```
    Blocking variant of pttl(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - pttlAndForget
```
public RedisAPI pttlAndForget(String arg0)
```
    Variant of pttl(String) that ignores the result of the operation.
    This method subscribes on the result of pttl(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pttl(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - publish
```
public io.smallrye.mutiny.Uni<Response> publish(String arg0,
                                                String arg1)
```
    Redis command publish.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - publishAndAwait
```
public Response publishAndAwait(String arg0,
                                String arg1)
```
    Blocking variant of publish(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - publishAndForget
```
public RedisAPI publishAndForget(String arg0,
                                 String arg1)
```
    Variant of publish(String,String) that ignores the result of the operation.
    This method subscribes on the result of publish(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from publish(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pubsub
```
public io.smallrye.mutiny.Uni<Response> pubsub(List<String> args)
```
    Redis command pubsub.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pubsubAndAwait
```
public Response pubsubAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#pubsub(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - pubsubAndForget
```
public RedisAPI pubsubAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#pubsub(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#pubsub(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#pubsub(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - punsubscribe
```
public io.smallrye.mutiny.Uni<Response> punsubscribe(List<String> args)
```
    Redis command punsubscribe.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - punsubscribeAndAwait
```
public Response punsubscribeAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#punsubscribe(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - punsubscribeAndForget
```
public RedisAPI punsubscribeAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#punsubscribe(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#punsubscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#punsubscribe(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - randomkey
```
public io.smallrye.mutiny.Uni<Response> randomkey()
```
    Redis command randomkey.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - randomkeyAndAwait
```
public Response randomkeyAndAwait()
```
    Blocking variant of randomkey().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - randomkeyAndForget
```
public RedisAPI randomkeyAndForget()
```
    Variant of randomkey() that ignores the result of the operation.
    This method subscribes on the result of randomkey(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from randomkey() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - readonly
```
public io.smallrye.mutiny.Uni<Response> readonly()
```
    Redis command readonly.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - readonlyAndAwait
```
public Response readonlyAndAwait()
```
    Blocking variant of readonly().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - readonlyAndForget
```
public RedisAPI readonlyAndForget()
```
    Variant of readonly() that ignores the result of the operation.
    This method subscribes on the result of readonly(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from readonly() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - readwrite
```
public io.smallrye.mutiny.Uni<Response> readwrite()
```
    Redis command readwrite.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - readwriteAndAwait
```
public Response readwriteAndAwait()
```
    Blocking variant of readwrite().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - readwriteAndForget
```
public RedisAPI readwriteAndForget()
```
    Variant of readwrite() that ignores the result of the operation.
    This method subscribes on the result of readwrite(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from readwrite() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - rename
```
public io.smallrye.mutiny.Uni<Response> rename(String arg0,
                                               String arg1)
```
    Redis command rename.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - renameAndAwait
```
public Response renameAndAwait(String arg0,
                               String arg1)
```
    Blocking variant of rename(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - renameAndForget
```
public RedisAPI renameAndForget(String arg0,
                                String arg1)
```
    Variant of rename(String,String) that ignores the result of the operation.
    This method subscribes on the result of rename(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from rename(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - renamenx
```
public io.smallrye.mutiny.Uni<Response> renamenx(String arg0,
                                                 String arg1)
```
    Redis command renamenx.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - renamenxAndAwait
```
public Response renamenxAndAwait(String arg0,
                                 String arg1)
```
    Blocking variant of renamenx(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - renamenxAndForget
```
public RedisAPI renamenxAndForget(String arg0,
                                  String arg1)
```
    Variant of renamenx(String,String) that ignores the result of the operation.
    This method subscribes on the result of renamenx(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from renamenx(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - replconf
```
public io.smallrye.mutiny.Uni<Response> replconf(List<String> args)
```
    Redis command replconf.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - replconfAndAwait
```
public Response replconfAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#replconf(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - replconfAndForget
```
public RedisAPI replconfAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#replconf(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#replconf(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#replconf(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - replicaof
```
public io.smallrye.mutiny.Uni<Response> replicaof(String arg0,
                                                  String arg1)
```
    Redis command replicaof.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - replicaofAndAwait
```
public Response replicaofAndAwait(String arg0,
                                  String arg1)
```
    Blocking variant of replicaof(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - replicaofAndForget
```
public RedisAPI replicaofAndForget(String arg0,
                                   String arg1)
```
    Variant of replicaof(String,String) that ignores the result of the operation.
    This method subscribes on the result of replicaof(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from replicaof(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - restore
```
public io.smallrye.mutiny.Uni<Response> restore(List<String> args)
```
    Redis command restore.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - restoreAndAwait
```
public Response restoreAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#restore(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - restoreAndForget
```
public RedisAPI restoreAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#restore(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#restore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#restore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - restoreAsking
```
public io.smallrye.mutiny.Uni<Response> restoreAsking(List<String> args)
```
    Redis command restoreAsking.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - restoreAskingAndAwait
```
public Response restoreAskingAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#restoreAsking(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - restoreAskingAndForget
```
public RedisAPI restoreAskingAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#restoreAsking(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#restoreAsking(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#restoreAsking(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - role
```
public io.smallrye.mutiny.Uni<Response> role()
```
    Redis command role.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - roleAndAwait
```
public Response roleAndAwait()
```
    Blocking variant of role().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - roleAndForget
```
public RedisAPI roleAndForget()
```
    Variant of role() that ignores the result of the operation.
    This method subscribes on the result of role(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from role() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - rpop
```
public io.smallrye.mutiny.Uni<Response> rpop(String arg0)
```
    Redis command rpop.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - rpopAndAwait
```
public Response rpopAndAwait(String arg0)
```
    Blocking variant of rpop(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - rpopAndForget
```
public RedisAPI rpopAndForget(String arg0)
```
    Variant of rpop(String) that ignores the result of the operation.
    This method subscribes on the result of rpop(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from rpop(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - rpoplpush
```
public io.smallrye.mutiny.Uni<Response> rpoplpush(String arg0,
                                                  String arg1)
```
    Redis command rpoplpush.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - rpoplpushAndAwait
```
public Response rpoplpushAndAwait(String arg0,
                                  String arg1)
```
    Blocking variant of rpoplpush(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - rpoplpushAndForget
```
public RedisAPI rpoplpushAndForget(String arg0,
                                   String arg1)
```
    Variant of rpoplpush(String,String) that ignores the result of the operation.
    This method subscribes on the result of rpoplpush(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from rpoplpush(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - rpush
```
public io.smallrye.mutiny.Uni<Response> rpush(List<String> args)
```
    Redis command rpush.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - rpushAndAwait
```
public Response rpushAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#rpush(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - rpushAndForget
```
public RedisAPI rpushAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#rpush(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#rpush(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#rpush(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - rpushx
```
public io.smallrye.mutiny.Uni<Response> rpushx(List<String> args)
```
    Redis command rpushx.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - rpushxAndAwait
```
public Response rpushxAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#rpushx(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - rpushxAndForget
```
public RedisAPI rpushxAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#rpushx(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#rpushx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#rpushx(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - sadd
```
public io.smallrye.mutiny.Uni<Response> sadd(List<String> args)
```
    Redis command sadd.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - saddAndAwait
```
public Response saddAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sadd(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - saddAndForget
```
public RedisAPI saddAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#sadd(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - save
```
public io.smallrye.mutiny.Uni<Response> save()
```
    Redis command save.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - saveAndAwait
```
public Response saveAndAwait()
```
    Blocking variant of save().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - saveAndForget
```
public RedisAPI saveAndForget()
```
    Variant of save() that ignores the result of the operation.
    This method subscribes on the result of save(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from save() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - scan
```
public io.smallrye.mutiny.Uni<Response> scan(List<String> args)
```
    Redis command scan.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - scanAndAwait
```
public Response scanAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#scan(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - scanAndForget
```
public RedisAPI scanAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#scan(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#scan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#scan(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - scard
```
public io.smallrye.mutiny.Uni<Response> scard(String arg0)
```
    Redis command scard.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - scardAndAwait
```
public Response scardAndAwait(String arg0)
```
    Blocking variant of scard(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - scardAndForget
```
public RedisAPI scardAndForget(String arg0)
```
    Variant of scard(String) that ignores the result of the operation.
    This method subscribes on the result of scard(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from scard(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - script
```
public io.smallrye.mutiny.Uni<Response> script(List<String> args)
```
    Redis command script.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - scriptAndAwait
```
public Response scriptAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#script(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - scriptAndForget
```
public RedisAPI scriptAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#script(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#script(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#script(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - sdiff
```
public io.smallrye.mutiny.Uni<Response> sdiff(List<String> args)
```
    Redis command sdiff.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sdiffAndAwait
```
public Response sdiffAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sdiff(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - sdiffAndForget
```
public RedisAPI sdiffAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#sdiff(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sdiff(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sdiff(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - sdiffstore
```
public io.smallrye.mutiny.Uni<Response> sdiffstore(List<String> args)
```
    Redis command sdiffstore.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sdiffstoreAndAwait
```
public Response sdiffstoreAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sdiffstore(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - sdiffstoreAndForget
```
public RedisAPI sdiffstoreAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#sdiffstore(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sdiffstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sdiffstore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - select
```
public io.smallrye.mutiny.Uni<Response> select(String arg0)
```
    Redis command select.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - selectAndAwait
```
public Response selectAndAwait(String arg0)
```
    Blocking variant of select(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - selectAndForget
```
public RedisAPI selectAndForget(String arg0)
```
    Variant of select(String) that ignores the result of the operation.
    This method subscribes on the result of select(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from select(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - set
```
public io.smallrye.mutiny.Uni<Response> set(List<String> args)
```
    Redis command set.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - setAndAwait
```
public Response setAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#set(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - setAndForget
```
public RedisAPI setAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#set(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#set(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#set(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - setbit
```
public io.smallrye.mutiny.Uni<Response> setbit(String arg0,
                                               String arg1,
                                               String arg2)
```
    Redis command setbit.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - setbitAndAwait
```
public Response setbitAndAwait(String arg0,
                               String arg1,
                               String arg2)
```
    Blocking variant of setbit(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - setbitAndForget
```
public RedisAPI setbitAndForget(String arg0,
                                String arg1,
                                String arg2)
```
    Variant of setbit(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of setbit(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from setbit(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - setex
```
public io.smallrye.mutiny.Uni<Response> setex(String arg0,
                                              String arg1,
                                              String arg2)
```
    Redis command setex.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - setexAndAwait
```
public Response setexAndAwait(String arg0,
                              String arg1,
                              String arg2)
```
    Blocking variant of setex(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - setexAndForget
```
public RedisAPI setexAndForget(String arg0,
                               String arg1,
                               String arg2)
```
    Variant of setex(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of setex(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from setex(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - setnx
```
public io.smallrye.mutiny.Uni<Response> setnx(String arg0,
                                              String arg1)
```
    Redis command setnx.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - setnxAndAwait
```
public Response setnxAndAwait(String arg0,
                              String arg1)
```
    Blocking variant of setnx(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - setnxAndForget
```
public RedisAPI setnxAndForget(String arg0,
                               String arg1)
```
    Variant of setnx(String,String) that ignores the result of the operation.
    This method subscribes on the result of setnx(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from setnx(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - setrange
```
public io.smallrye.mutiny.Uni<Response> setrange(String arg0,
                                                 String arg1,
                                                 String arg2)
```
    Redis command setrange.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - setrangeAndAwait
```
public Response setrangeAndAwait(String arg0,
                                 String arg1,
                                 String arg2)
```
    Blocking variant of setrange(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - setrangeAndForget
```
public RedisAPI setrangeAndForget(String arg0,
                                  String arg1,
                                  String arg2)
```
    Variant of setrange(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of setrange(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from setrange(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - shutdown
```
public io.smallrye.mutiny.Uni<Response> shutdown(List<String> args)
```
    Redis command shutdown.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - shutdownAndAwait
```
public Response shutdownAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#shutdown(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - shutdownAndForget
```
public RedisAPI shutdownAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#shutdown(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#shutdown(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#shutdown(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - sinter
```
public io.smallrye.mutiny.Uni<Response> sinter(List<String> args)
```
    Redis command sinter.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sinterAndAwait
```
public Response sinterAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sinter(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - sinterAndForget
```
public RedisAPI sinterAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#sinter(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sinter(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sinter(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - sinterstore
```
public io.smallrye.mutiny.Uni<Response> sinterstore(List<String> args)
```
    Redis command sinterstore.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sinterstoreAndAwait
```
public Response sinterstoreAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sinterstore(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - sinterstoreAndForget
```
public RedisAPI sinterstoreAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#sinterstore(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sinterstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sinterstore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - sismember
```
public io.smallrye.mutiny.Uni<Response> sismember(String arg0,
                                                  String arg1)
```
    Redis command sismember.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sismemberAndAwait
```
public Response sismemberAndAwait(String arg0,
                                  String arg1)
```
    Blocking variant of sismember(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - sismemberAndForget
```
public RedisAPI sismemberAndForget(String arg0,
                                   String arg1)
```
    Variant of sismember(String,String) that ignores the result of the operation.
    This method subscribes on the result of sismember(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from sismember(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - slaveof
```
public io.smallrye.mutiny.Uni<Response> slaveof(String arg0,
                                                String arg1)
```
    Redis command slaveof.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - slaveofAndAwait
```
public Response slaveofAndAwait(String arg0,
                                String arg1)
```
    Blocking variant of slaveof(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - slaveofAndForget
```
public RedisAPI slaveofAndForget(String arg0,
                                 String arg1)
```
    Variant of slaveof(String,String) that ignores the result of the operation.
    This method subscribes on the result of slaveof(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from slaveof(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - slowlog
```
public io.smallrye.mutiny.Uni<Response> slowlog(List<String> args)
```
    Redis command slowlog.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - slowlogAndAwait
```
public Response slowlogAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#slowlog(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - slowlogAndForget
```
public RedisAPI slowlogAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#slowlog(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#slowlog(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#slowlog(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - smembers
```
public io.smallrye.mutiny.Uni<Response> smembers(String arg0)
```
    Redis command smembers.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - smembersAndAwait
```
public Response smembersAndAwait(String arg0)
```
    Blocking variant of smembers(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - smembersAndForget
```
public RedisAPI smembersAndForget(String arg0)
```
    Variant of smembers(String) that ignores the result of the operation.
    This method subscribes on the result of smembers(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from smembers(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - smove
```
public io.smallrye.mutiny.Uni<Response> smove(String arg0,
                                              String arg1,
                                              String arg2)
```
    Redis command smove.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - smoveAndAwait
```
public Response smoveAndAwait(String arg0,
                              String arg1,
                              String arg2)
```
    Blocking variant of smove(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - smoveAndForget
```
public RedisAPI smoveAndForget(String arg0,
                               String arg1,
                               String arg2)
```
    Variant of smove(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of smove(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from smove(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - sort
```
public io.smallrye.mutiny.Uni<Response> sort(List<String> args)
```
    Redis command sort.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sortAndAwait
```
public Response sortAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sort(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - sortAndForget
```
public RedisAPI sortAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#sort(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sort(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sort(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - spop
```
public io.smallrye.mutiny.Uni<Response> spop(List<String> args)
```
    Redis command spop.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - spopAndAwait
```
public Response spopAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#spop(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - spopAndForget
```
public RedisAPI spopAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#spop(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#spop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#spop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - srandmember
```
public io.smallrye.mutiny.Uni<Response> srandmember(List<String> args)
```
    Redis command srandmember.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - srandmemberAndAwait
```
public Response srandmemberAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#srandmember(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - srandmemberAndForget
```
public RedisAPI srandmemberAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#srandmember(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#srandmember(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#srandmember(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - srem
```
public io.smallrye.mutiny.Uni<Response> srem(List<String> args)
```
    Redis command srem.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sremAndAwait
```
public Response sremAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#srem(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - sremAndForget
```
public RedisAPI sremAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#srem(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#srem(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#srem(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - sscan
```
public io.smallrye.mutiny.Uni<Response> sscan(List<String> args)
```
    Redis command sscan.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sscanAndAwait
```
public Response sscanAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sscan(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - sscanAndForget
```
public RedisAPI sscanAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#sscan(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sscan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sscan(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - stralgo
```
public io.smallrye.mutiny.Uni<Response> stralgo(List<String> args)
```
    Redis command stralgo.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - stralgoAndAwait
```
public Response stralgoAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#stralgo(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - stralgoAndForget
```
public RedisAPI stralgoAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#stralgo(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#stralgo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#stralgo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - strlen
```
public io.smallrye.mutiny.Uni<Response> strlen(String arg0)
```
    Redis command strlen.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - strlenAndAwait
```
public Response strlenAndAwait(String arg0)
```
    Blocking variant of strlen(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - strlenAndForget
```
public RedisAPI strlenAndForget(String arg0)
```
    Variant of strlen(String) that ignores the result of the operation.
    This method subscribes on the result of strlen(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from strlen(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - subscribe
```
public io.smallrye.mutiny.Uni<Response> subscribe(List<String> args)
```
    Redis command subscribe.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - subscribeAndAwait
```
public Response subscribeAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#subscribe(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - subscribeAndForget
```
public RedisAPI subscribeAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#subscribe(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#subscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#subscribe(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - substr
```
public io.smallrye.mutiny.Uni<Response> substr(String arg0,
                                               String arg1,
                                               String arg2)
```
    Redis command substr.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - substrAndAwait
```
public Response substrAndAwait(String arg0,
                               String arg1,
                               String arg2)
```
    Blocking variant of substr(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - substrAndForget
```
public RedisAPI substrAndForget(String arg0,
                                String arg1,
                                String arg2)
```
    Variant of substr(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of substr(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from substr(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - sunion
```
public io.smallrye.mutiny.Uni<Response> sunion(List<String> args)
```
    Redis command sunion.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sunionAndAwait
```
public Response sunionAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sunion(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - sunionAndForget
```
public RedisAPI sunionAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#sunion(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sunion(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sunion(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - sunionstore
```
public io.smallrye.mutiny.Uni<Response> sunionstore(List<String> args)
```
    Redis command sunionstore.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - sunionstoreAndAwait
```
public Response sunionstoreAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#sunionstore(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - sunionstoreAndForget
```
public RedisAPI sunionstoreAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#sunionstore(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#sunionstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#sunionstore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - swapdb
```
public io.smallrye.mutiny.Uni<Response> swapdb(String arg0,
                                               String arg1)
```
    Redis command swapdb.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - swapdbAndAwait
```
public Response swapdbAndAwait(String arg0,
                               String arg1)
```
    Blocking variant of swapdb(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - swapdbAndForget
```
public RedisAPI swapdbAndForget(String arg0,
                                String arg1)
```
    Variant of swapdb(String,String) that ignores the result of the operation.
    This method subscribes on the result of swapdb(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from swapdb(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - sync
```
public io.smallrye.mutiny.Uni<Response> sync()
```
    Redis command sync.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - syncAndAwait
```
public Response syncAndAwait()
```
    Blocking variant of sync().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - syncAndForget
```
public RedisAPI syncAndForget()
```
    Variant of sync() that ignores the result of the operation.
    This method subscribes on the result of sync(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from sync() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - time
```
public io.smallrye.mutiny.Uni<Response> time()
```
    Redis command time.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - timeAndAwait
```
public Response timeAndAwait()
```
    Blocking variant of time().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - timeAndForget
```
public RedisAPI timeAndForget()
```
    Variant of time() that ignores the result of the operation.
    This method subscribes on the result of time(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from time() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - touch
```
public io.smallrye.mutiny.Uni<Response> touch(List<String> args)
```
    Redis command touch.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - touchAndAwait
```
public Response touchAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#touch(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - touchAndForget
```
public RedisAPI touchAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#touch(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#touch(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#touch(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ttl
```
public io.smallrye.mutiny.Uni<Response> ttl(String arg0)
```
    Redis command ttl.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - ttlAndAwait
```
public Response ttlAndAwait(String arg0)
```
    Blocking variant of ttl(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - ttlAndForget
```
public RedisAPI ttlAndForget(String arg0)
```
    Variant of ttl(String) that ignores the result of the operation.
    This method subscribes on the result of ttl(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ttl(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - type
```
public io.smallrye.mutiny.Uni<Response> type(String arg0)
```
    Redis command type.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - typeAndAwait
```
public Response typeAndAwait(String arg0)
```
    Blocking variant of type(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - typeAndForget
```
public RedisAPI typeAndForget(String arg0)
```
    Variant of type(String) that ignores the result of the operation.
    This method subscribes on the result of type(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from type(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - unlink
```
public io.smallrye.mutiny.Uni<Response> unlink(List<String> args)
```
    Redis command unlink.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - unlinkAndAwait
```
public Response unlinkAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#unlink(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - unlinkAndForget
```
public RedisAPI unlinkAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#unlink(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#unlink(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#unlink(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - unsubscribe
```
public io.smallrye.mutiny.Uni<Response> unsubscribe(List<String> args)
```
    Redis command unsubscribe.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - unsubscribeAndAwait
```
public Response unsubscribeAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#unsubscribe(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - unsubscribeAndForget
```
public RedisAPI unsubscribeAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#unsubscribe(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#unsubscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#unsubscribe(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - unwatch
```
public io.smallrye.mutiny.Uni<Response> unwatch()
```
    Redis command unwatch.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - unwatchAndAwait
```
public Response unwatchAndAwait()
```
    Blocking variant of unwatch().
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Returns:
    
    the Response instance produced by the operation.
  - unwatchAndForget
```
public RedisAPI unwatchAndForget()
```
    Variant of unwatch() that ignores the result of the operation.
    This method subscribes on the result of unwatch(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from unwatch() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - wait
```
public io.smallrye.mutiny.Uni<Response> wait(String arg0,
                                             String arg1)
```
    Redis command wait.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - waitAndAwait
```
public Response waitAndAwait(String arg0,
                             String arg1)
```
    Blocking variant of wait(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - waitAndForget
```
public RedisAPI waitAndForget(String arg0,
                              String arg1)
```
    Variant of wait(String,String) that ignores the result of the operation.
    This method subscribes on the result of wait(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from wait(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - watch
```
public io.smallrye.mutiny.Uni<Response> watch(List<String> args)
```
    Redis command watch.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - watchAndAwait
```
public Response watchAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#watch(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - watchAndForget
```
public RedisAPI watchAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#watch(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#watch(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#watch(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xack
```
public io.smallrye.mutiny.Uni<Response> xack(List<String> args)
```
    Redis command xack.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xackAndAwait
```
public Response xackAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xack(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xackAndForget
```
public RedisAPI xackAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xack(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xack(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xack(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xadd
```
public io.smallrye.mutiny.Uni<Response> xadd(List<String> args)
```
    Redis command xadd.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xaddAndAwait
```
public Response xaddAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xadd(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xaddAndForget
```
public RedisAPI xaddAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xadd(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xclaim
```
public io.smallrye.mutiny.Uni<Response> xclaim(List<String> args)
```
    Redis command xclaim.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xclaimAndAwait
```
public Response xclaimAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xclaim(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xclaimAndForget
```
public RedisAPI xclaimAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xclaim(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xclaim(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xclaim(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xdel
```
public io.smallrye.mutiny.Uni<Response> xdel(List<String> args)
```
    Redis command xdel.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xdelAndAwait
```
public Response xdelAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xdel(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xdelAndForget
```
public RedisAPI xdelAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xdel(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xdel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xdel(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xgroup
```
public io.smallrye.mutiny.Uni<Response> xgroup(List<String> args)
```
    Redis command xgroup.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xgroupAndAwait
```
public Response xgroupAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xgroup(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xgroupAndForget
```
public RedisAPI xgroupAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xgroup(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xgroup(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xgroup(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xinfo
```
public io.smallrye.mutiny.Uni<Response> xinfo(List<String> args)
```
    Redis command xinfo.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xinfoAndAwait
```
public Response xinfoAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xinfo(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xinfoAndForget
```
public RedisAPI xinfoAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xinfo(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xinfo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xinfo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xlen
```
public io.smallrye.mutiny.Uni<Response> xlen(String arg0)
```
    Redis command xlen.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xlenAndAwait
```
public Response xlenAndAwait(String arg0)
```
    Blocking variant of xlen(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - xlenAndForget
```
public RedisAPI xlenAndForget(String arg0)
```
    Variant of xlen(String) that ignores the result of the operation.
    This method subscribes on the result of xlen(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from xlen(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xpending
```
public io.smallrye.mutiny.Uni<Response> xpending(List<String> args)
```
    Redis command xpending.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xpendingAndAwait
```
public Response xpendingAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xpending(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xpendingAndForget
```
public RedisAPI xpendingAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xpending(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xpending(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xpending(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xrange
```
public io.smallrye.mutiny.Uni<Response> xrange(List<String> args)
```
    Redis command xrange.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xrangeAndAwait
```
public Response xrangeAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xrange(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xrangeAndForget
```
public RedisAPI xrangeAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xrange(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xrange(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xread
```
public io.smallrye.mutiny.Uni<Response> xread(List<String> args)
```
    Redis command xread.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xreadAndAwait
```
public Response xreadAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xread(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xreadAndForget
```
public RedisAPI xreadAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xread(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xread(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xread(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xreadgroup
```
public io.smallrye.mutiny.Uni<Response> xreadgroup(List<String> args)
```
    Redis command xreadgroup.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xreadgroupAndAwait
```
public Response xreadgroupAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xreadgroup(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xreadgroupAndForget
```
public RedisAPI xreadgroupAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xreadgroup(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xreadgroup(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xreadgroup(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xrevrange
```
public io.smallrye.mutiny.Uni<Response> xrevrange(List<String> args)
```
    Redis command xrevrange.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xrevrangeAndAwait
```
public Response xrevrangeAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xrevrange(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xrevrangeAndForget
```
public RedisAPI xrevrangeAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xrevrange(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xrevrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xrevrange(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xsetid
```
public io.smallrye.mutiny.Uni<Response> xsetid(String arg0,
                                               String arg1)
```
    Redis command xsetid.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xsetidAndAwait
```
public Response xsetidAndAwait(String arg0,
                               String arg1)
```
    Blocking variant of xsetid(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - xsetidAndForget
```
public RedisAPI xsetidAndForget(String arg0,
                                String arg1)
```
    Variant of xsetid(String,String) that ignores the result of the operation.
    This method subscribes on the result of xsetid(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from xsetid(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xtrim
```
public io.smallrye.mutiny.Uni<Response> xtrim(List<String> args)
```
    Redis command xtrim.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xtrimAndAwait
```
public Response xtrimAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#xtrim(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - xtrimAndForget
```
public RedisAPI xtrimAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#xtrim(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#xtrim(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#xtrim(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zadd
```
public io.smallrye.mutiny.Uni<Response> zadd(List<String> args)
```
    Redis command zadd.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zaddAndAwait
```
public Response zaddAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zadd(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zaddAndForget
```
public RedisAPI zaddAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zadd(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zcard
```
public io.smallrye.mutiny.Uni<Response> zcard(String arg0)
```
    Redis command zcard.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zcardAndAwait
```
public Response zcardAndAwait(String arg0)
```
    Blocking variant of zcard(String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the Response instance produced by the operation.
  - zcardAndForget
```
public RedisAPI zcardAndForget(String arg0)
```
    Variant of zcard(String) that ignores the result of the operation.
    This method subscribes on the result of zcard(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zcard(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zcount
```
public io.smallrye.mutiny.Uni<Response> zcount(String arg0,
                                               String arg1,
                                               String arg2)
```
    Redis command zcount.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zcountAndAwait
```
public Response zcountAndAwait(String arg0,
                               String arg1,
                               String arg2)
```
    Blocking variant of zcount(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - zcountAndForget
```
public RedisAPI zcountAndForget(String arg0,
                                String arg1,
                                String arg2)
```
    Variant of zcount(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of zcount(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zcount(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zincrby
```
public io.smallrye.mutiny.Uni<Response> zincrby(String arg0,
                                                String arg1,
                                                String arg2)
```
    Redis command zincrby.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zincrbyAndAwait
```
public Response zincrbyAndAwait(String arg0,
                                String arg1,
                                String arg2)
```
    Blocking variant of zincrby(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - zincrbyAndForget
```
public RedisAPI zincrbyAndForget(String arg0,
                                 String arg1,
                                 String arg2)
```
    Variant of zincrby(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of zincrby(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zincrby(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zinterstore
```
public io.smallrye.mutiny.Uni<Response> zinterstore(List<String> args)
```
    Redis command zinterstore.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zinterstoreAndAwait
```
public Response zinterstoreAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zinterstore(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zinterstoreAndForget
```
public RedisAPI zinterstoreAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zinterstore(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zinterstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zinterstore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zlexcount
```
public io.smallrye.mutiny.Uni<Response> zlexcount(String arg0,
                                                  String arg1,
                                                  String arg2)
```
    Redis command zlexcount.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zlexcountAndAwait
```
public Response zlexcountAndAwait(String arg0,
                                  String arg1,
                                  String arg2)
```
    Blocking variant of zlexcount(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - zlexcountAndForget
```
public RedisAPI zlexcountAndForget(String arg0,
                                   String arg1,
                                   String arg2)
```
    Variant of zlexcount(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of zlexcount(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zlexcount(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zpopmax
```
public io.smallrye.mutiny.Uni<Response> zpopmax(List<String> args)
```
    Redis command zpopmax.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zpopmaxAndAwait
```
public Response zpopmaxAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zpopmax(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zpopmaxAndForget
```
public RedisAPI zpopmaxAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zpopmax(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zpopmax(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zpopmax(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zpopmin
```
public io.smallrye.mutiny.Uni<Response> zpopmin(List<String> args)
```
    Redis command zpopmin.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zpopminAndAwait
```
public Response zpopminAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zpopmin(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zpopminAndForget
```
public RedisAPI zpopminAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zpopmin(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zpopmin(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zpopmin(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrange
```
public io.smallrye.mutiny.Uni<Response> zrange(List<String> args)
```
    Redis command zrange.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zrangeAndAwait
```
public Response zrangeAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrange(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zrangeAndForget
```
public RedisAPI zrangeAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zrange(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrange(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrangebylex
```
public io.smallrye.mutiny.Uni<Response> zrangebylex(List<String> args)
```
    Redis command zrangebylex.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zrangebylexAndAwait
```
public Response zrangebylexAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrangebylex(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zrangebylexAndForget
```
public RedisAPI zrangebylexAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zrangebylex(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrangebylex(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrangebylex(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrangebyscore
```
public io.smallrye.mutiny.Uni<Response> zrangebyscore(List<String> args)
```
    Redis command zrangebyscore.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zrangebyscoreAndAwait
```
public Response zrangebyscoreAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrangebyscore(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zrangebyscoreAndForget
```
public RedisAPI zrangebyscoreAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zrangebyscore(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrangebyscore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrangebyscore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrank
```
public io.smallrye.mutiny.Uni<Response> zrank(String arg0,
                                              String arg1)
```
    Redis command zrank.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zrankAndAwait
```
public Response zrankAndAwait(String arg0,
                              String arg1)
```
    Blocking variant of zrank(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - zrankAndForget
```
public RedisAPI zrankAndForget(String arg0,
                               String arg1)
```
    Variant of zrank(String,String) that ignores the result of the operation.
    This method subscribes on the result of zrank(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zrank(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrem
```
public io.smallrye.mutiny.Uni<Response> zrem(List<String> args)
```
    Redis command zrem.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zremAndAwait
```
public Response zremAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrem(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zremAndForget
```
public RedisAPI zremAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zrem(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrem(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrem(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zremrangebylex
```
public io.smallrye.mutiny.Uni<Response> zremrangebylex(String arg0,
                                                       String arg1,
                                                       String arg2)
```
    Redis command zremrangebylex.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zremrangebylexAndAwait
```
public Response zremrangebylexAndAwait(String arg0,
                                       String arg1,
                                       String arg2)
```
    Blocking variant of zremrangebylex(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - zremrangebylexAndForget
```
public RedisAPI zremrangebylexAndForget(String arg0,
                                        String arg1,
                                        String arg2)
```
    Variant of zremrangebylex(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of zremrangebylex(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zremrangebylex(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zremrangebyrank
```
public io.smallrye.mutiny.Uni<Response> zremrangebyrank(String arg0,
                                                        String arg1,
                                                        String arg2)
```
    Redis command zremrangebyrank.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zremrangebyrankAndAwait
```
public Response zremrangebyrankAndAwait(String arg0,
                                        String arg1,
                                        String arg2)
```
    Blocking variant of zremrangebyrank(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - zremrangebyrankAndForget
```
public RedisAPI zremrangebyrankAndForget(String arg0,
                                         String arg1,
                                         String arg2)
```
    Variant of zremrangebyrank(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of zremrangebyrank(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zremrangebyrank(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zremrangebyscore
```
public io.smallrye.mutiny.Uni<Response> zremrangebyscore(String arg0,
                                                         String arg1,
                                                         String arg2)
```
    Redis command zremrangebyscore.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zremrangebyscoreAndAwait
```
public Response zremrangebyscoreAndAwait(String arg0,
                                         String arg1,
                                         String arg2)
```
    Blocking variant of zremrangebyscore(String,String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the Response instance produced by the operation.
  - zremrangebyscoreAndForget
```
public RedisAPI zremrangebyscoreAndForget(String arg0,
                                          String arg1,
                                          String arg2)
```
    Variant of zremrangebyscore(String,String,String) that ignores the result of the operation.
    This method subscribes on the result of zremrangebyscore(String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zremrangebyscore(String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrevrange
```
public io.smallrye.mutiny.Uni<Response> zrevrange(List<String> args)
```
    Redis command zrevrange.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zrevrangeAndAwait
```
public Response zrevrangeAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrange(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zrevrangeAndForget
```
public RedisAPI zrevrangeAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrange(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrevrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrevrange(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrevrangebylex
```
public io.smallrye.mutiny.Uni<Response> zrevrangebylex(List<String> args)
```
    Redis command zrevrangebylex.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zrevrangebylexAndAwait
```
public Response zrevrangebylexAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebylex(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zrevrangebylexAndForget
```
public RedisAPI zrevrangebylexAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebylex(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebylex(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrevrangebylex(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrevrangebyscore
```
public io.smallrye.mutiny.Uni<Response> zrevrangebyscore(List<String> args)
```
    Redis command zrevrangebyscore.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zrevrangebyscoreAndAwait
```
public Response zrevrangebyscoreAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebyscore(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zrevrangebyscoreAndForget
```
public RedisAPI zrevrangebyscoreAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebyscore(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zrevrangebyscore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zrevrangebyscore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrevrank
```
public io.smallrye.mutiny.Uni<Response> zrevrank(String arg0,
                                                 String arg1)
```
    Redis command zrevrank.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zrevrankAndAwait
```
public Response zrevrankAndAwait(String arg0,
                                 String arg1)
```
    Blocking variant of zrevrank(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - zrevrankAndForget
```
public RedisAPI zrevrankAndForget(String arg0,
                                  String arg1)
```
    Variant of zrevrank(String,String) that ignores the result of the operation.
    This method subscribes on the result of zrevrank(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zrevrank(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zscan
```
public io.smallrye.mutiny.Uni<Response> zscan(List<String> args)
```
    Redis command zscan.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zscanAndAwait
```
public Response zscanAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zscan(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zscanAndForget
```
public RedisAPI zscanAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zscan(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zscan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zscan(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zscore
```
public io.smallrye.mutiny.Uni<Response> zscore(String arg0,
                                               String arg1)
```
    Redis command zscore.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zscoreAndAwait
```
public Response zscoreAndAwait(String arg0,
                               String arg1)
```
    Blocking variant of zscore(String,String).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the Response instance produced by the operation.
  - zscoreAndForget
```
public RedisAPI zscoreAndForget(String arg0,
                                String arg1)
```
    Variant of zscore(String,String) that ignores the result of the operation.
    This method subscribes on the result of zscore(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zscore(String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zunionstore
```
public io.smallrye.mutiny.Uni<Response> zunionstore(List<String> args)
```
    Redis command zunionstore.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - zunionstoreAndAwait
```
public Response zunionstoreAndAwait(List<String> args)
```
    Blocking variant of io.vertx.mutiny.redis.client.RedisAPI#zunionstore(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - zunionstoreAndForget
```
public RedisAPI zunionstoreAndForget(List<String> args)
```
    Variant of io.vertx.mutiny.redis.client.RedisAPI#zunionstore(List) that ignores the result of the operation.
    This method subscribes on the result of io.vertx.mutiny.redis.client.RedisAPI#zunionstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from io.vertx.mutiny.redis.client.RedisAPI#zunionstore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - api
```
public static RedisAPI api(Redis client)
```
  - api
```
public static RedisAPI api(RedisConnection connection)
```
  - newInstance
```
public static RedisAPI newInstance(io.vertx.redis.client.RedisAPI arg)
```

Constructor	Description
`RedisAPI(io.vertx.redis.client.RedisAPI delegate)`
`RedisAPI(Object delegate)`

Class RedisAPI

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

RedisAPI

RedisAPI

Method Detail

getDelegate

toString

equals

hashCode

close

acl

aclAndAwait

aclAndForget

append

appendAndAwait

appendAndForget

asking

askingAndAwait

askingAndForget

auth

authAndAwait

authAndForget

bgrewriteaof

bgrewriteaofAndAwait

bgrewriteaofAndForget

bgsave

bgsaveAndAwait

bgsaveAndForget

bitcount

bitcountAndAwait

bitcountAndForget

bitfield

bitfieldAndAwait

bitfieldAndForget

bitfieldRo

bitfieldRoAndAwait

bitfieldRoAndForget

bitop

bitopAndAwait

bitopAndForget

bitpos

bitposAndAwait

bitposAndForget

blpop

blpopAndAwait

blpopAndForget

brpop

brpopAndAwait

brpopAndForget

brpoplpush

brpoplpushAndAwait

brpoplpushAndForget

bzpopmax

bzpopmaxAndAwait

bzpopmaxAndForget

bzpopmin

bzpopminAndAwait

bzpopminAndForget

client

clientAndAwait

clientAndForget

cluster

clusterAndAwait

clusterAndForget

command

commandAndAwait

commandAndForget

config

configAndAwait

configAndForget

dbsize

dbsizeAndAwait

dbsizeAndForget

debug