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 `acl(List)`.
`RedisAPI`	`aclAndForget(List<String> args)`	Variant of `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 `auth(List)`.
`RedisAPI`	`authAndForget(List<String> args)`	Variant of `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 `bgsave(List)`.
`RedisAPI`	`bgsaveAndForget(List<String> args)`	Variant of `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 `bitcount(List)`.
`RedisAPI`	`bitcountAndForget(List<String> args)`	Variant of `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 `bitfield(List)`.
`RedisAPI`	`bitfieldAndForget(List<String> args)`	Variant of `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 `bitfieldRo(List)`.
`RedisAPI`	`bitfieldRoAndForget(List<String> args)`	Variant of `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 `bitop(List)`.
`RedisAPI`	`bitopAndForget(List<String> args)`	Variant of `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 `bitpos(List)`.
`RedisAPI`	`bitposAndForget(List<String> args)`	Variant of `bitpos(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`blmove(String arg0, String arg1, String arg2, String arg3, String arg4)`	Redis command blmove.
`Response`	`blmoveAndAwait(String arg0, String arg1, String arg2, String arg3, String arg4)`	Blocking variant of `blmove(String,String,String,String,String)`.
`RedisAPI`	`blmoveAndForget(String arg0, String arg1, String arg2, String arg3, String arg4)`	Variant of `blmove(String,String,String,String,String)` 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 `blpop(List)`.
`RedisAPI`	`blpopAndForget(List<String> args)`	Variant of `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 `brpop(List)`.
`RedisAPI`	`brpopAndForget(List<String> args)`	Variant of `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 `bzpopmax(List)`.
`RedisAPI`	`bzpopmaxAndForget(List<String> args)`	Variant of `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 `bzpopmin(List)`.
`RedisAPI`	`bzpopminAndForget(List<String> args)`	Variant of `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 `client(List)`.
`RedisAPI`	`clientAndForget(List<String> args)`	Variant of `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 `cluster(List)`.
`RedisAPI`	`clusterAndForget(List<String> args)`	Variant of `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 `command(List)`.
`RedisAPI`	`commandAndForget(List<String> args)`	Variant of `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 `config(List)`.
`RedisAPI`	`configAndForget(List<String> args)`	Variant of `config(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`copy(List<String> args)`	Redis command copy.
`Response`	`copyAndAwait(List<String> args)`	Blocking variant of `copy(List)`.
`RedisAPI`	`copyAndForget(List<String> args)`	Variant of `copy(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 `debug(List)`.
`RedisAPI`	`debugAndForget(List<String> args)`	Variant of `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 `del(List)`.
`RedisAPI`	`delAndForget(List<String> args)`	Variant of `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 `eval(List)`.
`RedisAPI`	`evalAndForget(List<String> args)`	Variant of `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 `evalsha(List)`.
`RedisAPI`	`evalshaAndForget(List<String> args)`	Variant of `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 `exists(List)`.
`RedisAPI`	`existsAndForget(List<String> args)`	Variant of `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>`	`failover(List<String> args)`	Redis command failover.
`Response`	`failoverAndAwait(List<String> args)`	Blocking variant of `failover(List)`.
`RedisAPI`	`failoverAndForget(List<String> args)`	Variant of `failover(List)` 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 `flushall(List)`.
`RedisAPI`	`flushallAndForget(List<String> args)`	Variant of `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 `flushdb(List)`.
`RedisAPI`	`flushdbAndForget(List<String> args)`	Variant of `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 `geoadd(List)`.
`RedisAPI`	`geoaddAndForget(List<String> args)`	Variant of `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 `geodist(List)`.
`RedisAPI`	`geodistAndForget(List<String> args)`	Variant of `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 `geohash(List)`.
`RedisAPI`	`geohashAndForget(List<String> args)`	Variant of `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 `geopos(List)`.
`RedisAPI`	`geoposAndForget(List<String> args)`	Variant of `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 `georadius(List)`.
`RedisAPI`	`georadiusAndForget(List<String> args)`	Variant of `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 `georadiusbymember(List)`.
`RedisAPI`	`georadiusbymemberAndForget(List<String> args)`	Variant of `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 `georadiusbymemberRo(List)`.
`RedisAPI`	`georadiusbymemberRoAndForget(List<String> args)`	Variant of `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 `georadiusRo(List)`.
`RedisAPI`	`georadiusRoAndForget(List<String> args)`	Variant of `georadiusRo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`geosearch(List<String> args)`	Redis command geosearch.
`Response`	`geosearchAndAwait(List<String> args)`	Blocking variant of `geosearch(List)`.
`RedisAPI`	`geosearchAndForget(List<String> args)`	Variant of `geosearch(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`geosearchstore(List<String> args)`	Redis command geosearchstore.
`Response`	`geosearchstoreAndAwait(List<String> args)`	Blocking variant of `geosearchstore(List)`.
`RedisAPI`	`geosearchstoreAndForget(List<String> args)`	Variant of `geosearchstore(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.smallrye.mutiny.Uni<Response>`	`getdel(String arg0)`	Redis command getdel.
`Response`	`getdelAndAwait(String arg0)`	Blocking variant of `getdel(String)`.
`RedisAPI`	`getdelAndForget(String arg0)`	Variant of `getdel(String)` that ignores the result of the operation.
`io.vertx.redis.client.RedisAPI`	`getDelegate()`
`io.smallrye.mutiny.Uni<Response>`	`getex(List<String> args)`	Redis command getex.
`Response`	`getexAndAwait(List<String> args)`	Blocking variant of `getex(List)`.
`RedisAPI`	`getexAndForget(List<String> args)`	Variant of `getex(List)` that ignores the result of the operation.
`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 `hdel(List)`.
`RedisAPI`	`hdelAndForget(List<String> args)`	Variant of `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 `hello(List)`.
`RedisAPI`	`helloAndForget(List<String> args)`	Variant of `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 `hmget(List)`.
`RedisAPI`	`hmgetAndForget(List<String> args)`	Variant of `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 `hmset(List)`.
`RedisAPI`	`hmsetAndForget(List<String> args)`	Variant of `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 `host(List)`.
`RedisAPI`	`hostAndForget(List<String> args)`	Variant of `host(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`hrandfield(List<String> args)`	Redis command hrandfield.
`Response`	`hrandfieldAndAwait(List<String> args)`	Blocking variant of `hrandfield(List)`.
`RedisAPI`	`hrandfieldAndForget(List<String> args)`	Variant of `hrandfield(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 `hscan(List)`.
`RedisAPI`	`hscanAndForget(List<String> args)`	Variant of `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 `hset(List)`.
`RedisAPI`	`hsetAndForget(List<String> args)`	Variant of `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 `info(List)`.
`RedisAPI`	`infoAndForget(List<String> args)`	Variant of `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 `latency(List)`.
`RedisAPI`	`latencyAndForget(List<String> args)`	Variant of `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>`	`lmove(String arg0, String arg1, String arg2, String arg3)`	Redis command lmove.
`Response`	`lmoveAndAwait(String arg0, String arg1, String arg2, String arg3)`	Blocking variant of `lmove(String,String,String,String)`.
`RedisAPI`	`lmoveAndForget(String arg0, String arg1, String arg2, String arg3)`	Variant of `lmove(String,String,String,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 `lolwut(List)`.
`RedisAPI`	`lolwutAndForget(List<String> args)`	Variant of `lolwut(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`lpop(List<String> args)`	Redis command lpop.
`Response`	`lpopAndAwait(List<String> args)`	Blocking variant of `lpop(List)`.
`RedisAPI`	`lpopAndForget(List<String> args)`	Variant of `lpop(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`lpos(List<String> args)`	Redis command lpos.
`Response`	`lposAndAwait(List<String> args)`	Blocking variant of `lpos(List)`.
`RedisAPI`	`lposAndForget(List<String> args)`	Variant of `lpos(List)` 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 `lpush(List)`.
`RedisAPI`	`lpushAndForget(List<String> args)`	Variant of `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 `lpushx(List)`.
`RedisAPI`	`lpushxAndForget(List<String> args)`	Variant of `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 `memory(List)`.
`RedisAPI`	`memoryAndForget(List<String> args)`	Variant of `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 `mget(List)`.
`RedisAPI`	`mgetAndForget(List<String> args)`	Variant of `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 `migrate(List)`.
`RedisAPI`	`migrateAndForget(List<String> args)`	Variant of `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 `module(List)`.
`RedisAPI`	`moduleAndForget(List<String> args)`	Variant of `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 `mset(List)`.
`RedisAPI`	`msetAndForget(List<String> args)`	Variant of `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 `msetnx(List)`.
`RedisAPI`	`msetnxAndForget(List<String> args)`	Variant of `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 `object(List)`.
`RedisAPI`	`objectAndForget(List<String> args)`	Variant of `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 `pfadd(List)`.
`RedisAPI`	`pfaddAndForget(List<String> args)`	Variant of `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 `pfcount(List)`.
`RedisAPI`	`pfcountAndForget(List<String> args)`	Variant of `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 `pfdebug(List)`.
`RedisAPI`	`pfdebugAndForget(List<String> args)`	Variant of `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 `pfmerge(List)`.
`RedisAPI`	`pfmergeAndForget(List<String> args)`	Variant of `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 `ping(List)`.
`RedisAPI`	`pingAndForget(List<String> args)`	Variant of `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 `post(List)`.
`RedisAPI`	`postAndForget(List<String> args)`	Variant of `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 `psubscribe(List)`.
`RedisAPI`	`psubscribeAndForget(List<String> args)`	Variant of `psubscribe(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`psync(List<String> args)`	Redis command psync.
`Response`	`psyncAndAwait(List<String> args)`	Blocking variant of `psync(List)`.
`RedisAPI`	`psyncAndForget(List<String> args)`	Variant of `psync(List)` 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 `pubsub(List)`.
`RedisAPI`	`pubsubAndForget(List<String> args)`	Variant of `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 `punsubscribe(List)`.
`RedisAPI`	`punsubscribeAndForget(List<String> args)`	Variant of `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 `replconf(List)`.
`RedisAPI`	`replconfAndForget(List<String> args)`	Variant of `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>`	`reset()`	Redis command reset.
`Response`	`resetAndAwait()`	Blocking variant of `reset()`.
`RedisAPI`	`resetAndForget()`	Variant of `reset()` 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 `restore(List)`.
`RedisAPI`	`restoreAndForget(List<String> args)`	Variant of `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 `restoreAsking(List)`.
`RedisAPI`	`restoreAskingAndForget(List<String> args)`	Variant of `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(List<String> args)`	Redis command rpop.
`Response`	`rpopAndAwait(List<String> args)`	Blocking variant of `rpop(List)`.
`RedisAPI`	`rpopAndForget(List<String> args)`	Variant of `rpop(List)` 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 `rpush(List)`.
`RedisAPI`	`rpushAndForget(List<String> args)`	Variant of `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 `rpushx(List)`.
`RedisAPI`	`rpushxAndForget(List<String> args)`	Variant of `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 `sadd(List)`.
`RedisAPI`	`saddAndForget(List<String> args)`	Variant of `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 `scan(List)`.
`RedisAPI`	`scanAndForget(List<String> args)`	Variant of `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 `script(List)`.
`RedisAPI`	`scriptAndForget(List<String> args)`	Variant of `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 `sdiff(List)`.
`RedisAPI`	`sdiffAndForget(List<String> args)`	Variant of `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 `sdiffstore(List)`.
`RedisAPI`	`sdiffstoreAndForget(List<String> args)`	Variant of `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 `set(List)`.
`RedisAPI`	`setAndForget(List<String> args)`	Variant of `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 `shutdown(List)`.
`RedisAPI`	`shutdownAndForget(List<String> args)`	Variant of `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 `sinter(List)`.
`RedisAPI`	`sinterAndForget(List<String> args)`	Variant of `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 `sinterstore(List)`.
`RedisAPI`	`sinterstoreAndForget(List<String> args)`	Variant of `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 `slowlog(List)`.
`RedisAPI`	`slowlogAndForget(List<String> args)`	Variant of `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>`	`smismember(List<String> args)`	Redis command smismember.
`Response`	`smismemberAndAwait(List<String> args)`	Blocking variant of `smismember(List)`.
`RedisAPI`	`smismemberAndForget(List<String> args)`	Variant of `smismember(List)` 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 `sort(List)`.
`RedisAPI`	`sortAndForget(List<String> args)`	Variant of `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 `spop(List)`.
`RedisAPI`	`spopAndForget(List<String> args)`	Variant of `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 `srandmember(List)`.
`RedisAPI`	`srandmemberAndForget(List<String> args)`	Variant of `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 `srem(List)`.
`RedisAPI`	`sremAndForget(List<String> args)`	Variant of `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 `sscan(List)`.
`RedisAPI`	`sscanAndForget(List<String> args)`	Variant of `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 `stralgo(List)`.
`RedisAPI`	`stralgoAndForget(List<String> args)`	Variant of `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 `subscribe(List)`.
`RedisAPI`	`subscribeAndForget(List<String> args)`	Variant of `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 `sunion(List)`.
`RedisAPI`	`sunionAndForget(List<String> args)`	Variant of `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 `sunionstore(List)`.
`RedisAPI`	`sunionstoreAndForget(List<String> args)`	Variant of `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 `touch(List)`.
`RedisAPI`	`touchAndForget(List<String> args)`	Variant of `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 `unlink(List)`.
`RedisAPI`	`unlinkAndForget(List<String> args)`	Variant of `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 `unsubscribe(List)`.
`RedisAPI`	`unsubscribeAndForget(List<String> args)`	Variant of `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 `watch(List)`.
`RedisAPI`	`watchAndForget(List<String> args)`	Variant of `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 `xack(List)`.
`RedisAPI`	`xackAndForget(List<String> args)`	Variant of `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 `xadd(List)`.
`RedisAPI`	`xaddAndForget(List<String> args)`	Variant of `xadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`xautoclaim(List<String> args)`	Redis command xautoclaim.
`Response`	`xautoclaimAndAwait(List<String> args)`	Blocking variant of `xautoclaim(List)`.
`RedisAPI`	`xautoclaimAndForget(List<String> args)`	Variant of `xautoclaim(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 `xclaim(List)`.
`RedisAPI`	`xclaimAndForget(List<String> args)`	Variant of `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 `xdel(List)`.
`RedisAPI`	`xdelAndForget(List<String> args)`	Variant of `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 `xgroup(List)`.
`RedisAPI`	`xgroupAndForget(List<String> args)`	Variant of `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 `xinfo(List)`.
`RedisAPI`	`xinfoAndForget(List<String> args)`	Variant of `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 `xpending(List)`.
`RedisAPI`	`xpendingAndForget(List<String> args)`	Variant of `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 `xrange(List)`.
`RedisAPI`	`xrangeAndForget(List<String> args)`	Variant of `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 `xread(List)`.
`RedisAPI`	`xreadAndForget(List<String> args)`	Variant of `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 `xreadgroup(List)`.
`RedisAPI`	`xreadgroupAndForget(List<String> args)`	Variant of `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 `xrevrange(List)`.
`RedisAPI`	`xrevrangeAndForget(List<String> args)`	Variant of `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 `xtrim(List)`.
`RedisAPI`	`xtrimAndForget(List<String> args)`	Variant of `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 `zadd(List)`.
`RedisAPI`	`zaddAndForget(List<String> args)`	Variant of `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>`	`zdiff(List<String> args)`	Redis command zdiff.
`Response`	`zdiffAndAwait(List<String> args)`	Blocking variant of `zdiff(List)`.
`RedisAPI`	`zdiffAndForget(List<String> args)`	Variant of `zdiff(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zdiffstore(List<String> args)`	Redis command zdiffstore.
`Response`	`zdiffstoreAndAwait(List<String> args)`	Blocking variant of `zdiffstore(List)`.
`RedisAPI`	`zdiffstoreAndForget(List<String> args)`	Variant of `zdiffstore(List)` 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>`	`zinter(List<String> args)`	Redis command zinter.
`Response`	`zinterAndAwait(List<String> args)`	Blocking variant of `zinter(List)`.
`RedisAPI`	`zinterAndForget(List<String> args)`	Variant of `zinter(List)` 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 `zinterstore(List)`.
`RedisAPI`	`zinterstoreAndForget(List<String> args)`	Variant of `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>`	`zmscore(List<String> args)`	Redis command zmscore.
`Response`	`zmscoreAndAwait(List<String> args)`	Blocking variant of `zmscore(List)`.
`RedisAPI`	`zmscoreAndForget(List<String> args)`	Variant of `zmscore(List)` 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 `zpopmax(List)`.
`RedisAPI`	`zpopmaxAndForget(List<String> args)`	Variant of `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 `zpopmin(List)`.
`RedisAPI`	`zpopminAndForget(List<String> args)`	Variant of `zpopmin(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zrandmember(List<String> args)`	Redis command zrandmember.
`Response`	`zrandmemberAndAwait(List<String> args)`	Blocking variant of `zrandmember(List)`.
`RedisAPI`	`zrandmemberAndForget(List<String> args)`	Variant of `zrandmember(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 `zrange(List)`.
`RedisAPI`	`zrangeAndForget(List<String> args)`	Variant of `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 `zrangebylex(List)`.
`RedisAPI`	`zrangebylexAndForget(List<String> args)`	Variant of `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 `zrangebyscore(List)`.
`RedisAPI`	`zrangebyscoreAndForget(List<String> args)`	Variant of `zrangebyscore(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`zrangestore(List<String> args)`	Redis command zrangestore.
`Response`	`zrangestoreAndAwait(List<String> args)`	Blocking variant of `zrangestore(List)`.
`RedisAPI`	`zrangestoreAndForget(List<String> args)`	Variant of `zrangestore(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 `zrem(List)`.
`RedisAPI`	`zremAndForget(List<String> args)`	Variant of `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 `zrevrange(List)`.
`RedisAPI`	`zrevrangeAndForget(List<String> args)`	Variant of `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 `zrevrangebylex(List)`.
`RedisAPI`	`zrevrangebylexAndForget(List<String> args)`	Variant of `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 `zrevrangebyscore(List)`.
`RedisAPI`	`zrevrangebyscoreAndForget(List<String> args)`	Variant of `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 `zscan(List)`.
`RedisAPI`	`zscanAndForget(List<String> args)`	Variant of `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>`	`zunion(List<String> args)`	Redis command zunion.
`Response`	`zunionAndAwait(List<String> args)`	Blocking variant of `zunion(List)`.
`RedisAPI`	`zunionAndForget(List<String> args)`	Variant of `zunion(List)` 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 `zunionstore(List)`.
`RedisAPI`	`zunionstoreAndForget(List<String> args)`	Variant of `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
```
@CheckReturnValue
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 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 acl(List) that ignores the result of the operation.
    This method subscribes on the result of acl(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 auth(List) that ignores the result of the operation.
    This method subscribes on the result of auth(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 bgsave(List) that ignores the result of the operation.
    This method subscribes on the result of bgsave(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 bitcount(List) that ignores the result of the operation.
    This method subscribes on the result of bitcount(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 bitfield(List) that ignores the result of the operation.
    This method subscribes on the result of bitfield(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 bitfieldRo(List) that ignores the result of the operation.
    This method subscribes on the result of bitfieldRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 bitop(List) that ignores the result of the operation.
    This method subscribes on the result of bitop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 bitpos(List) that ignores the result of the operation.
    This method subscribes on the result of bitpos(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bitpos(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - blmove
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> blmove(String arg0,
                                               String arg1,
                                               String arg2,
                                               String arg3,
                                               String arg4)
```
    Redis command blmove.
    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 -
    
    arg4 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - blmoveAndAwait
```
public Response blmoveAndAwait(String arg0,
                               String arg1,
                               String arg2,
                               String arg3,
                               String arg4)
```
    Blocking variant of blmove(String,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 -
    
    arg4 -
    
    Returns:
    
    the Response instance produced by the operation.
  - blmoveAndForget
```
public RedisAPI blmoveAndForget(String arg0,
                                String arg1,
                                String arg2,
                                String arg3,
                                String arg4)
```
    Variant of blmove(String,String,String,String,String) that ignores the result of the operation.
    This method subscribes on the result of blmove(String,String,String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from blmove(String,String,String,String,String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    arg3 -
    
    arg4 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - blpop
```
@CheckReturnValue
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 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 blpop(List) that ignores the result of the operation.
    This method subscribes on the result of blpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 brpop(List) that ignores the result of the operation.
    This method subscribes on the result of brpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 bzpopmax(List) that ignores the result of the operation.
    This method subscribes on the result of bzpopmax(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 bzpopmin(List) that ignores the result of the operation.
    This method subscribes on the result of bzpopmin(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 client(List) that ignores the result of the operation.
    This method subscribes on the result of client(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 cluster(List) that ignores the result of the operation.
    This method subscribes on the result of cluster(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 command(List) that ignores the result of the operation.
    This method subscribes on the result of command(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 config(List) that ignores the result of the operation.
    This method subscribes on the result of config(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from config(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - copy
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> copy(List<String> args)
```
    Redis command copy.
    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.
  - copyAndAwait
```
public Response copyAndAwait(List<String> args)
```
    Blocking variant of copy(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.
  - copyAndForget
```
public RedisAPI copyAndForget(List<String> args)
```
    Variant of copy(List) that ignores the result of the operation.
    This method subscribes on the result of copy(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from copy(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - dbsize
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 debug(List) that ignores the result of the operation.
    This method subscribes on the result of debug(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 del(List) that ignores the result of the operation.
    This method subscribes on the result of del(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 eval(List) that ignores the result of the operation.
    This method subscribes on the result of eval(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 evalsha(List) that ignores the result of the operation.
    This method subscribes on the result of evalsha(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 exists(List) that ignores the result of the operation.
    This method subscribes on the result of exists(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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.
  - failover
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> failover(List<String> args)
```
    Redis command failover.
    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.
  - failoverAndAwait
```
public Response failoverAndAwait(List<String> args)
```
    Blocking variant of failover(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.
  - failoverAndForget
```
public RedisAPI failoverAndForget(List<String> args)
```
    Variant of failover(List) that ignores the result of the operation.
    This method subscribes on the result of failover(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from failover(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - flushall
```
@CheckReturnValue
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 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 flushall(List) that ignores the result of the operation.
    This method subscribes on the result of flushall(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 flushdb(List) that ignores the result of the operation.
    This method subscribes on the result of flushdb(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 geoadd(List) that ignores the result of the operation.
    This method subscribes on the result of geoadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 geodist(List) that ignores the result of the operation.
    This method subscribes on the result of geodist(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 geohash(List) that ignores the result of the operation.
    This method subscribes on the result of geohash(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 geopos(List) that ignores the result of the operation.
    This method subscribes on the result of geopos(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 georadius(List) that ignores the result of the operation.
    This method subscribes on the result of georadius(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 georadiusRo(List) that ignores the result of the operation.
    This method subscribes on the result of georadiusRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 georadiusbymember(List) that ignores the result of the operation.
    This method subscribes on the result of georadiusbymember(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 georadiusbymemberRo(List) that ignores the result of the operation.
    This method subscribes on the result of georadiusbymemberRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from georadiusbymemberRo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - geosearch
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> geosearch(List<String> args)
```
    Redis command geosearch.
    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.
  - geosearchAndAwait
```
public Response geosearchAndAwait(List<String> args)
```
    Blocking variant of geosearch(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.
  - geosearchAndForget
```
public RedisAPI geosearchAndForget(List<String> args)
```
    Variant of geosearch(List) that ignores the result of the operation.
    This method subscribes on the result of geosearch(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from geosearch(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - geosearchstore
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> geosearchstore(List<String> args)
```
    Redis command geosearchstore.
    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.
  - geosearchstoreAndAwait
```
public Response geosearchstoreAndAwait(List<String> args)
```
    Blocking variant of geosearchstore(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.
  - geosearchstoreAndForget
```
public RedisAPI geosearchstoreAndForget(List<String> args)
```
    Variant of geosearchstore(List) that ignores the result of the operation.
    This method subscribes on the result of geosearchstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from geosearchstore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - get
```
@CheckReturnValue
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
```
@CheckReturnValue
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.
  - getdel
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> getdel(String arg0)
```
    Redis command getdel.
    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.
  - getdelAndAwait
```
public Response getdelAndAwait(String arg0)
```
    Blocking variant of getdel(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.
  - getdelAndForget
```
public RedisAPI getdelAndForget(String arg0)
```
    Variant of getdel(String) that ignores the result of the operation.
    This method subscribes on the result of getdel(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getdel(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - getex
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> getex(List<String> args)
```
    Redis command getex.
    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.
  - getexAndAwait
```
public Response getexAndAwait(List<String> args)
```
    Blocking variant of getex(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.
  - getexAndForget
```
public RedisAPI getexAndForget(List<String> args)
```
    Variant of getex(List) that ignores the result of the operation.
    This method subscribes on the result of getex(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from getex(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - getrange
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 hdel(List) that ignores the result of the operation.
    This method subscribes on the result of hdel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 hello(List) that ignores the result of the operation.
    This method subscribes on the result of hello(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 hmget(List) that ignores the result of the operation.
    This method subscribes on the result of hmget(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 hmset(List) that ignores the result of the operation.
    This method subscribes on the result of hmset(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 host(List) that ignores the result of the operation.
    This method subscribes on the result of host(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from host(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hrandfield
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> hrandfield(List<String> args)
```
    Redis command hrandfield.
    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.
  - hrandfieldAndAwait
```
public Response hrandfieldAndAwait(List<String> args)
```
    Blocking variant of hrandfield(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.
  - hrandfieldAndForget
```
public RedisAPI hrandfieldAndForget(List<String> args)
```
    Variant of hrandfield(List) that ignores the result of the operation.
    This method subscribes on the result of hrandfield(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from hrandfield(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - hscan
```
@CheckReturnValue
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 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 hscan(List) that ignores the result of the operation.
    This method subscribes on the result of hscan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 hset(List) that ignores the result of the operation.
    This method subscribes on the result of hset(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 info(List) that ignores the result of the operation.
    This method subscribes on the result of info(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 latency(List) that ignores the result of the operation.
    This method subscribes on the result of latency(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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.
  - lmove
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> lmove(String arg0,
                                              String arg1,
                                              String arg2,
                                              String arg3)
```
    Redis command lmove.
    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.
  - lmoveAndAwait
```
public Response lmoveAndAwait(String arg0,
                              String arg1,
                              String arg2,
                              String arg3)
```
    Blocking variant of lmove(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.
  - lmoveAndForget
```
public RedisAPI lmoveAndForget(String arg0,
                               String arg1,
                               String arg2,
                               String arg3)
```
    Variant of lmove(String,String,String,String) that ignores the result of the operation.
    This method subscribes on the result of lmove(String,String,String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lmove(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.
  - lolwut
```
@CheckReturnValue
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 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 lolwut(List) that ignores the result of the operation.
    This method subscribes on the result of lolwut(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> lpop(List<String> args)
```
    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:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - lpopAndAwait
```
public Response lpopAndAwait(List<String> args)
```
    Blocking variant of lpop(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.
  - lpopAndForget
```
public RedisAPI lpopAndForget(List<String> args)
```
    Variant of lpop(List) that ignores the result of the operation.
    This method subscribes on the result of lpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lpop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - lpos
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> lpos(List<String> args)
```
    Redis command lpos.
    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.
  - lposAndAwait
```
public Response lposAndAwait(List<String> args)
```
    Blocking variant of lpos(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.
  - lposAndForget
```
public RedisAPI lposAndForget(List<String> args)
```
    Variant of lpos(List) that ignores the result of the operation.
    This method subscribes on the result of lpos(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lpos(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - lpush
```
@CheckReturnValue
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 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 lpush(List) that ignores the result of the operation.
    This method subscribes on the result of lpush(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 lpushx(List) that ignores the result of the operation.
    This method subscribes on the result of lpushx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 memory(List) that ignores the result of the operation.
    This method subscribes on the result of memory(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 mget(List) that ignores the result of the operation.
    This method subscribes on the result of mget(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 migrate(List) that ignores the result of the operation.
    This method subscribes on the result of migrate(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 module(List) that ignores the result of the operation.
    This method subscribes on the result of module(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 mset(List) that ignores the result of the operation.
    This method subscribes on the result of mset(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 msetnx(List) that ignores the result of the operation.
    This method subscribes on the result of msetnx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 object(List) that ignores the result of the operation.
    This method subscribes on the result of object(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 pfadd(List) that ignores the result of the operation.
    This method subscribes on the result of pfadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 pfcount(List) that ignores the result of the operation.
    This method subscribes on the result of pfcount(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 pfdebug(List) that ignores the result of the operation.
    This method subscribes on the result of pfdebug(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 pfmerge(List) that ignores the result of the operation.
    This method subscribes on the result of pfmerge(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 ping(List) that ignores the result of the operation.
    This method subscribes on the result of ping(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 post(List) that ignores the result of the operation.
    This method subscribes on the result of post(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 psubscribe(List) that ignores the result of the operation.
    This method subscribes on the result of psubscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> psync(List<String> args)
```
    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:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - psyncAndAwait
```
public Response psyncAndAwait(List<String> args)
```
    Blocking variant of psync(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.
  - psyncAndForget
```
public RedisAPI psyncAndForget(List<String> args)
```
    Variant of psync(List) that ignores the result of the operation.
    This method subscribes on the result of psync(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from psync(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pttl
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 pubsub(List) that ignores the result of the operation.
    This method subscribes on the result of pubsub(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 punsubscribe(List) that ignores the result of the operation.
    This method subscribes on the result of punsubscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 replconf(List) that ignores the result of the operation.
    This method subscribes on the result of replconf(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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.
  - reset
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> reset()
```
    Redis command reset.
    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.
  - resetAndAwait
```
public Response resetAndAwait()
```
    Blocking variant of reset().
    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.
  - resetAndForget
```
public RedisAPI resetAndForget()
```
    Variant of reset() that ignores the result of the operation.
    This method subscribes on the result of reset(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from reset() but you don't need to compose it with other operations.
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - restore
```
@CheckReturnValue
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 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 restore(List) that ignores the result of the operation.
    This method subscribes on the result of restore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 restoreAsking(List) that ignores the result of the operation.
    This method subscribes on the result of restoreAsking(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> rpop(List<String> args)
```
    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:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - rpopAndAwait
```
public Response rpopAndAwait(List<String> args)
```
    Blocking variant of rpop(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.
  - rpopAndForget
```
public RedisAPI rpopAndForget(List<String> args)
```
    Variant of rpop(List) that ignores the result of the operation.
    This method subscribes on the result of rpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from rpop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - rpoplpush
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 rpush(List) that ignores the result of the operation.
    This method subscribes on the result of rpush(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 rpushx(List) that ignores the result of the operation.
    This method subscribes on the result of rpushx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 sadd(List) that ignores the result of the operation.
    This method subscribes on the result of sadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 scan(List) that ignores the result of the operation.
    This method subscribes on the result of scan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 script(List) that ignores the result of the operation.
    This method subscribes on the result of script(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 sdiff(List) that ignores the result of the operation.
    This method subscribes on the result of sdiff(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 sdiffstore(List) that ignores the result of the operation.
    This method subscribes on the result of sdiffstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 set(List) that ignores the result of the operation.
    This method subscribes on the result of set(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 shutdown(List) that ignores the result of the operation.
    This method subscribes on the result of shutdown(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 sinter(List) that ignores the result of the operation.
    This method subscribes on the result of sinter(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 sinterstore(List) that ignores the result of the operation.
    This method subscribes on the result of sinterstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 slowlog(List) that ignores the result of the operation.
    This method subscribes on the result of slowlog(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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.
  - smismember
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> smismember(List<String> args)
```
    Redis command smismember.
    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.
  - smismemberAndAwait
```
public Response smismemberAndAwait(List<String> args)
```
    Blocking variant of smismember(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.
  - smismemberAndForget
```
public RedisAPI smismemberAndForget(List<String> args)
```
    Variant of smismember(List) that ignores the result of the operation.
    This method subscribes on the result of smismember(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from smismember(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - smove
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 sort(List) that ignores the result of the operation.
    This method subscribes on the result of sort(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 spop(List) that ignores the result of the operation.
    This method subscribes on the result of spop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 srandmember(List) that ignores the result of the operation.
    This method subscribes on the result of srandmember(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 srem(List) that ignores the result of the operation.
    This method subscribes on the result of srem(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 sscan(List) that ignores the result of the operation.
    This method subscribes on the result of sscan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 stralgo(List) that ignores the result of the operation.
    This method subscribes on the result of stralgo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 subscribe(List) that ignores the result of the operation.
    This method subscribes on the result of subscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 sunion(List) that ignores the result of the operation.
    This method subscribes on the result of sunion(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 sunionstore(List) that ignores the result of the operation.
    This method subscribes on the result of sunionstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 touch(List) that ignores the result of the operation.
    This method subscribes on the result of touch(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 unlink(List) that ignores the result of the operation.
    This method subscribes on the result of unlink(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 unsubscribe(List) that ignores the result of the operation.
    This method subscribes on the result of unsubscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 watch(List) that ignores the result of the operation.
    This method subscribes on the result of watch(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 xack(List) that ignores the result of the operation.
    This method subscribes on the result of xack(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 xadd(List) that ignores the result of the operation.
    This method subscribes on the result of xadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from xadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xautoclaim
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> xautoclaim(List<String> args)
```
    Redis command xautoclaim.
    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.
  - xautoclaimAndAwait
```
public Response xautoclaimAndAwait(List<String> args)
```
    Blocking variant of xautoclaim(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.
  - xautoclaimAndForget
```
public RedisAPI xautoclaimAndForget(List<String> args)
```
    Variant of xautoclaim(List) that ignores the result of the operation.
    This method subscribes on the result of xautoclaim(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from xautoclaim(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - xclaim
```
@CheckReturnValue
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 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 xclaim(List) that ignores the result of the operation.
    This method subscribes on the result of xclaim(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 xdel(List) that ignores the result of the operation.
    This method subscribes on the result of xdel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 xgroup(List) that ignores the result of the operation.
    This method subscribes on the result of xgroup(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 xinfo(List) that ignores the result of the operation.
    This method subscribes on the result of xinfo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 xpending(List) that ignores the result of the operation.
    This method subscribes on the result of xpending(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 xrange(List) that ignores the result of the operation.
    This method subscribes on the result of xrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 xread(List) that ignores the result of the operation.
    This method subscribes on the result of xread(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 xreadgroup(List) that ignores the result of the operation.
    This method subscribes on the result of xreadgroup(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 xrevrange(List) that ignores the result of the operation.
    This method subscribes on the result of xrevrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 xtrim(List) that ignores the result of the operation.
    This method subscribes on the result of xtrim(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 zadd(List) that ignores the result of the operation.
    This method subscribes on the result of zadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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.
  - zdiff
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> zdiff(List<String> args)
```
    Redis command zdiff.
    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.
  - zdiffAndAwait
```
public Response zdiffAndAwait(List<String> args)
```
    Blocking variant of zdiff(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.
  - zdiffAndForget
```
public RedisAPI zdiffAndForget(List<String> args)
```
    Variant of zdiff(List) that ignores the result of the operation.
    This method subscribes on the result of zdiff(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zdiff(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zdiffstore
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> zdiffstore(List<String> args)
```
    Redis command zdiffstore.
    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.
  - zdiffstoreAndAwait
```
public Response zdiffstoreAndAwait(List<String> args)
```
    Blocking variant of zdiffstore(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.
  - zdiffstoreAndForget
```
public RedisAPI zdiffstoreAndForget(List<String> args)
```
    Variant of zdiffstore(List) that ignores the result of the operation.
    This method subscribes on the result of zdiffstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zdiffstore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zincrby
```
@CheckReturnValue
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.
  - zinter
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> zinter(List<String> args)
```
    Redis command zinter.
    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.
  - zinterAndAwait
```
public Response zinterAndAwait(List<String> args)
```
    Blocking variant of zinter(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.
  - zinterAndForget
```
public RedisAPI zinterAndForget(List<String> args)
```
    Variant of zinter(List) that ignores the result of the operation.
    This method subscribes on the result of zinter(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zinter(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zinterstore
```
@CheckReturnValue
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 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 zinterstore(List) that ignores the result of the operation.
    This method subscribes on the result of zinterstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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.
  - zmscore
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> zmscore(List<String> args)
```
    Redis command zmscore.
    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.
  - zmscoreAndAwait
```
public Response zmscoreAndAwait(List<String> args)
```
    Blocking variant of zmscore(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.
  - zmscoreAndForget
```
public RedisAPI zmscoreAndForget(List<String> args)
```
    Variant of zmscore(List) that ignores the result of the operation.
    This method subscribes on the result of zmscore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zmscore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zpopmax
```
@CheckReturnValue
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 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 zpopmax(List) that ignores the result of the operation.
    This method subscribes on the result of zpopmax(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 zpopmin(List) that ignores the result of the operation.
    This method subscribes on the result of zpopmin(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zpopmin(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrandmember
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> zrandmember(List<String> args)
```
    Redis command zrandmember.
    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.
  - zrandmemberAndAwait
```
public Response zrandmemberAndAwait(List<String> args)
```
    Blocking variant of zrandmember(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.
  - zrandmemberAndForget
```
public RedisAPI zrandmemberAndForget(List<String> args)
```
    Variant of zrandmember(List) that ignores the result of the operation.
    This method subscribes on the result of zrandmember(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zrandmember(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrange
```
@CheckReturnValue
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 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 zrange(List) that ignores the result of the operation.
    This method subscribes on the result of zrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 zrangebylex(List) that ignores the result of the operation.
    This method subscribes on the result of zrangebylex(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 zrangebyscore(List) that ignores the result of the operation.
    This method subscribes on the result of zrangebyscore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zrangebyscore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrangestore
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> zrangestore(List<String> args)
```
    Redis command zrangestore.
    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.
  - zrangestoreAndAwait
```
public Response zrangestoreAndAwait(List<String> args)
```
    Blocking variant of zrangestore(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.
  - zrangestoreAndForget
```
public RedisAPI zrangestoreAndForget(List<String> args)
```
    Variant of zrangestore(List) that ignores the result of the operation.
    This method subscribes on the result of zrangestore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zrangestore(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zrank
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 zrem(List) that ignores the result of the operation.
    This method subscribes on the result of zrem(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 zrevrange(List) that ignores the result of the operation.
    This method subscribes on the result of zrevrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 zrevrangebylex(List) that ignores the result of the operation.
    This method subscribes on the result of zrevrangebylex(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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 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 zrevrangebyscore(List) that ignores the result of the operation.
    This method subscribes on the result of zrevrangebyscore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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
```
@CheckReturnValue
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 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 zscan(List) that ignores the result of the operation.
    This method subscribes on the result of zscan(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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
```
@CheckReturnValue
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.
  - zunion
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> zunion(List<String> args)
```
    Redis command zunion.
    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.
  - zunionAndAwait
```
public Response zunionAndAwait(List<String> args)
```
    Blocking variant of zunion(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.
  - zunionAndForget
```
public RedisAPI zunionAndForget(List<String> args)
```
    Variant of zunion(List) that ignores the result of the operation.
    This method subscribes on the result of zunion(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zunion(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - zunionstore
```
@CheckReturnValue
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 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 zunionstore(List) that ignores the result of the operation.
    This method subscribes on the result of zunionstore(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from 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

blmove

blmoveAndAwait

blmoveAndForget

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

copy