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>`	`bfAdd(List<String> args)`	Redis command bfAdd.
`Response`	`bfAddAndAwait(List<String> args)`	Blocking variant of `bfAdd(List)`.
`RedisAPI`	`bfAddAndForget(List<String> args)`	Variant of `bfAdd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bfDebug(List<String> args)`	Redis command bfDebug.
`Response`	`bfDebugAndAwait(List<String> args)`	Blocking variant of `bfDebug(List)`.
`RedisAPI`	`bfDebugAndForget(List<String> args)`	Variant of `bfDebug(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bfExists(List<String> args)`	Redis command bfExists.
`Response`	`bfExistsAndAwait(List<String> args)`	Blocking variant of `bfExists(List)`.
`RedisAPI`	`bfExistsAndForget(List<String> args)`	Variant of `bfExists(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bfInfo(List<String> args)`	Redis command bfInfo.
`Response`	`bfInfoAndAwait(List<String> args)`	Blocking variant of `bfInfo(List)`.
`RedisAPI`	`bfInfoAndForget(List<String> args)`	Variant of `bfInfo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bfInsert(List<String> args)`	Redis command bfInsert.
`Response`	`bfInsertAndAwait(List<String> args)`	Blocking variant of `bfInsert(List)`.
`RedisAPI`	`bfInsertAndForget(List<String> args)`	Variant of `bfInsert(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bfLoadchunk(List<String> args)`	Redis command bfLoadchunk.
`Response`	`bfLoadchunkAndAwait(List<String> args)`	Blocking variant of `bfLoadchunk(List)`.
`RedisAPI`	`bfLoadchunkAndForget(List<String> args)`	Variant of `bfLoadchunk(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bfMadd(List<String> args)`	Redis command bfMadd.
`Response`	`bfMaddAndAwait(List<String> args)`	Blocking variant of `bfMadd(List)`.
`RedisAPI`	`bfMaddAndForget(List<String> args)`	Variant of `bfMadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bfMexists(List<String> args)`	Redis command bfMexists.
`Response`	`bfMexistsAndAwait(List<String> args)`	Blocking variant of `bfMexists(List)`.
`RedisAPI`	`bfMexistsAndForget(List<String> args)`	Variant of `bfMexists(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bfReserve(List<String> args)`	Redis command bfReserve.
`Response`	`bfReserveAndAwait(List<String> args)`	Blocking variant of `bfReserve(List)`.
`RedisAPI`	`bfReserveAndForget(List<String> args)`	Variant of `bfReserve(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bfScandump(List<String> args)`	Redis command bfScandump.
`Response`	`bfScandumpAndAwait(List<String> args)`	Blocking variant of `bfScandump(List)`.
`RedisAPI`	`bfScandumpAndForget(List<String> args)`	Variant of `bfScandump(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>`	`blmpop(List<String> args)`	Redis command blmpop.
`Response`	`blmpopAndAwait(List<String> args)`	Blocking variant of `blmpop(List)`.
`RedisAPI`	`blmpopAndForget(List<String> args)`	Variant of `blmpop(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`blpop(List<String> args)`	Redis command blpop.
`Response`	`blpopAndAwait(List<String> args)`	Blocking variant of `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>`	`bzmpop(List<String> args)`	Redis command bzmpop.
`Response`	`bzmpopAndAwait(List<String> args)`	Blocking variant of `bzmpop(List)`.
`RedisAPI`	`bzmpopAndForget(List<String> args)`	Variant of `bzmpop(List)` 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>`	`cfAdd(List<String> args)`	Redis command cfAdd.
`Response`	`cfAddAndAwait(List<String> args)`	Blocking variant of `cfAdd(List)`.
`RedisAPI`	`cfAddAndForget(List<String> args)`	Variant of `cfAdd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfAddnx(List<String> args)`	Redis command cfAddnx.
`Response`	`cfAddnxAndAwait(List<String> args)`	Blocking variant of `cfAddnx(List)`.
`RedisAPI`	`cfAddnxAndForget(List<String> args)`	Variant of `cfAddnx(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfCompact(List<String> args)`	Redis command cfCompact.
`Response`	`cfCompactAndAwait(List<String> args)`	Blocking variant of `cfCompact(List)`.
`RedisAPI`	`cfCompactAndForget(List<String> args)`	Variant of `cfCompact(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfCount(List<String> args)`	Redis command cfCount.
`Response`	`cfCountAndAwait(List<String> args)`	Blocking variant of `cfCount(List)`.
`RedisAPI`	`cfCountAndForget(List<String> args)`	Variant of `cfCount(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfDebug(List<String> args)`	Redis command cfDebug.
`Response`	`cfDebugAndAwait(List<String> args)`	Blocking variant of `cfDebug(List)`.
`RedisAPI`	`cfDebugAndForget(List<String> args)`	Variant of `cfDebug(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfDel(List<String> args)`	Redis command cfDel.
`Response`	`cfDelAndAwait(List<String> args)`	Blocking variant of `cfDel(List)`.
`RedisAPI`	`cfDelAndForget(List<String> args)`	Variant of `cfDel(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfExists(List<String> args)`	Redis command cfExists.
`Response`	`cfExistsAndAwait(List<String> args)`	Blocking variant of `cfExists(List)`.
`RedisAPI`	`cfExistsAndForget(List<String> args)`	Variant of `cfExists(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfInfo(List<String> args)`	Redis command cfInfo.
`Response`	`cfInfoAndAwait(List<String> args)`	Blocking variant of `cfInfo(List)`.
`RedisAPI`	`cfInfoAndForget(List<String> args)`	Variant of `cfInfo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfInsert(List<String> args)`	Redis command cfInsert.
`Response`	`cfInsertAndAwait(List<String> args)`	Blocking variant of `cfInsert(List)`.
`RedisAPI`	`cfInsertAndForget(List<String> args)`	Variant of `cfInsert(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfInsertnx(List<String> args)`	Redis command cfInsertnx.
`Response`	`cfInsertnxAndAwait(List<String> args)`	Blocking variant of `cfInsertnx(List)`.
`RedisAPI`	`cfInsertnxAndForget(List<String> args)`	Variant of `cfInsertnx(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfLoadchunk(List<String> args)`	Redis command cfLoadchunk.
`Response`	`cfLoadchunkAndAwait(List<String> args)`	Blocking variant of `cfLoadchunk(List)`.
`RedisAPI`	`cfLoadchunkAndForget(List<String> args)`	Variant of `cfLoadchunk(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfMexists(List<String> args)`	Redis command cfMexists.
`Response`	`cfMexistsAndAwait(List<String> args)`	Blocking variant of `cfMexists(List)`.
`RedisAPI`	`cfMexistsAndForget(List<String> args)`	Variant of `cfMexists(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfReserve(List<String> args)`	Redis command cfReserve.
`Response`	`cfReserveAndAwait(List<String> args)`	Blocking variant of `cfReserve(List)`.
`RedisAPI`	`cfReserveAndForget(List<String> args)`	Variant of `cfReserve(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cfScandump(List<String> args)`	Redis command cfScandump.
`Response`	`cfScandumpAndAwait(List<String> args)`	Blocking variant of `cfScandump(List)`.
`RedisAPI`	`cfScandumpAndForget(List<String> args)`	Variant of `cfScandump(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>`	`cmsIncrby(List<String> args)`	Redis command cmsIncrby.
`Response`	`cmsIncrbyAndAwait(List<String> args)`	Blocking variant of `cmsIncrby(List)`.
`RedisAPI`	`cmsIncrbyAndForget(List<String> args)`	Variant of `cmsIncrby(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cmsInfo(List<String> args)`	Redis command cmsInfo.
`Response`	`cmsInfoAndAwait(List<String> args)`	Blocking variant of `cmsInfo(List)`.
`RedisAPI`	`cmsInfoAndForget(List<String> args)`	Variant of `cmsInfo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cmsInitbydim(List<String> args)`	Redis command cmsInitbydim.
`Response`	`cmsInitbydimAndAwait(List<String> args)`	Blocking variant of `cmsInitbydim(List)`.
`RedisAPI`	`cmsInitbydimAndForget(List<String> args)`	Variant of `cmsInitbydim(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cmsInitbyprob(List<String> args)`	Redis command cmsInitbyprob.
`Response`	`cmsInitbyprobAndAwait(List<String> args)`	Blocking variant of `cmsInitbyprob(List)`.
`RedisAPI`	`cmsInitbyprobAndForget(List<String> args)`	Variant of `cmsInitbyprob(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cmsMerge(List<String> args)`	Redis command cmsMerge.
`Response`	`cmsMergeAndAwait(List<String> args)`	Blocking variant of `cmsMerge(List)`.
`RedisAPI`	`cmsMergeAndForget(List<String> args)`	Variant of `cmsMerge(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`cmsQuery(List<String> args)`	Redis command cmsQuery.
`Response`	`cmsQueryAndAwait(List<String> args)`	Blocking variant of `cmsQuery(List)`.
`RedisAPI`	`cmsQueryAndForget(List<String> args)`	Variant of `cmsQuery(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>`	`evalRo(List<String> args)`	Redis command evalRo.
`Response`	`evalRoAndAwait(List<String> args)`	Blocking variant of `evalRo(List)`.
`RedisAPI`	`evalRoAndForget(List<String> args)`	Variant of `evalRo(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>`	`evalshaRo(List<String> args)`	Redis command evalshaRo.
`Response`	`evalshaRoAndAwait(List<String> args)`	Blocking variant of `evalshaRo(List)`.
`RedisAPI`	`evalshaRoAndForget(List<String> args)`	Variant of `evalshaRo(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(List<String> args)`	Redis command expire.
`Response`	`expireAndAwait(List<String> args)`	Blocking variant of `expire(List)`.
`RedisAPI`	`expireAndForget(List<String> args)`	Variant of `expire(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`expireat(List<String> args)`	Redis command expireat.
`Response`	`expireatAndAwait(List<String> args)`	Blocking variant of `expireat(List)`.
`RedisAPI`	`expireatAndForget(List<String> args)`	Variant of `expireat(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`expiretime(String arg0)`	Redis command expiretime.
`Response`	`expiretimeAndAwait(String arg0)`	Blocking variant of `expiretime(String)`.
`RedisAPI`	`expiretimeAndForget(String arg0)`	Variant of `expiretime(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>`	`fcall(List<String> args)`	Redis command fcall.
`Response`	`fcallAndAwait(List<String> args)`	Blocking variant of `fcall(List)`.
`RedisAPI`	`fcallAndForget(List<String> args)`	Variant of `fcall(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`fcallRo(List<String> args)`	Redis command fcallRo.
`Response`	`fcallRoAndAwait(List<String> args)`	Blocking variant of `fcallRo(List)`.
`RedisAPI`	`fcallRoAndForget(List<String> args)`	Variant of `fcallRo(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>`	`ftAdd(List<String> args)`	Redis command ftAdd.
`Response`	`ftAddAndAwait(List<String> args)`	Blocking variant of `ftAdd(List)`.
`RedisAPI`	`ftAddAndForget(List<String> args)`	Variant of `ftAdd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftAggregate(List<String> args)`	Redis command ftAggregate.
`Response`	`ftAggregateAndAwait(List<String> args)`	Blocking variant of `ftAggregate(List)`.
`RedisAPI`	`ftAggregateAndForget(List<String> args)`	Variant of `ftAggregate(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftAliasadd(List<String> args)`	Redis command ftAliasadd.
`Response`	`ftAliasaddAndAwait(List<String> args)`	Blocking variant of `ftAliasadd(List)`.
`RedisAPI`	`ftAliasaddAndForget(List<String> args)`	Variant of `ftAliasadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftAliasaddifnx(List<String> args)`	Redis command ftAliasaddifnx.
`Response`	`ftAliasaddifnxAndAwait(List<String> args)`	Blocking variant of `ftAliasaddifnx(List)`.
`RedisAPI`	`ftAliasaddifnxAndForget(List<String> args)`	Variant of `ftAliasaddifnx(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftAliasdel(List<String> args)`	Redis command ftAliasdel.
`Response`	`ftAliasdelAndAwait(List<String> args)`	Blocking variant of `ftAliasdel(List)`.
`RedisAPI`	`ftAliasdelAndForget(List<String> args)`	Variant of `ftAliasdel(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftAliasdelifx(List<String> args)`	Redis command ftAliasdelifx.
`Response`	`ftAliasdelifxAndAwait(List<String> args)`	Blocking variant of `ftAliasdelifx(List)`.
`RedisAPI`	`ftAliasdelifxAndForget(List<String> args)`	Variant of `ftAliasdelifx(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftAliasupdate(List<String> args)`	Redis command ftAliasupdate.
`Response`	`ftAliasupdateAndAwait(List<String> args)`	Blocking variant of `ftAliasupdate(List)`.
`RedisAPI`	`ftAliasupdateAndForget(List<String> args)`	Variant of `ftAliasupdate(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftAlter(List<String> args)`	Redis command ftAlter.
`Response`	`ftAlterAndAwait(List<String> args)`	Blocking variant of `ftAlter(List)`.
`RedisAPI`	`ftAlterAndForget(List<String> args)`	Variant of `ftAlter(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftAlterifnx(List<String> args)`	Redis command ftAlterifnx.
`Response`	`ftAlterifnxAndAwait(List<String> args)`	Blocking variant of `ftAlterifnx(List)`.
`RedisAPI`	`ftAlterifnxAndForget(List<String> args)`	Variant of `ftAlterifnx(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftConfig(List<String> args)`	Redis command ftConfig.
`Response`	`ftConfigAndAwait(List<String> args)`	Blocking variant of `ftConfig(List)`.
`RedisAPI`	`ftConfigAndForget(List<String> args)`	Variant of `ftConfig(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftCreate(List<String> args)`	Redis command ftCreate.
`Response`	`ftCreateAndAwait(List<String> args)`	Blocking variant of `ftCreate(List)`.
`RedisAPI`	`ftCreateAndForget(List<String> args)`	Variant of `ftCreate(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftCreateifnx(List<String> args)`	Redis command ftCreateifnx.
`Response`	`ftCreateifnxAndAwait(List<String> args)`	Blocking variant of `ftCreateifnx(List)`.
`RedisAPI`	`ftCreateifnxAndForget(List<String> args)`	Variant of `ftCreateifnx(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftCursor(List<String> args)`	Redis command ftCursor.
`Response`	`ftCursorAndAwait(List<String> args)`	Blocking variant of `ftCursor(List)`.
`RedisAPI`	`ftCursorAndForget(List<String> args)`	Variant of `ftCursor(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftDebug(List<String> args)`	Redis command ftDebug.
`Response`	`ftDebugAndAwait(List<String> args)`	Blocking variant of `ftDebug(List)`.
`RedisAPI`	`ftDebugAndForget(List<String> args)`	Variant of `ftDebug(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftDel(List<String> args)`	Redis command ftDel.
`Response`	`ftDelAndAwait(List<String> args)`	Blocking variant of `ftDel(List)`.
`RedisAPI`	`ftDelAndForget(List<String> args)`	Variant of `ftDel(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftDictadd(List<String> args)`	Redis command ftDictadd.
`Response`	`ftDictaddAndAwait(List<String> args)`	Blocking variant of `ftDictadd(List)`.
`RedisAPI`	`ftDictaddAndForget(List<String> args)`	Variant of `ftDictadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftDictdel(List<String> args)`	Redis command ftDictdel.
`Response`	`ftDictdelAndAwait(List<String> args)`	Blocking variant of `ftDictdel(List)`.
`RedisAPI`	`ftDictdelAndForget(List<String> args)`	Variant of `ftDictdel(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftDictdump(List<String> args)`	Redis command ftDictdump.
`Response`	`ftDictdumpAndAwait(List<String> args)`	Blocking variant of `ftDictdump(List)`.
`RedisAPI`	`ftDictdumpAndForget(List<String> args)`	Variant of `ftDictdump(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftDrop(List<String> args)`	Redis command ftDrop.
`Response`	`ftDropAndAwait(List<String> args)`	Blocking variant of `ftDrop(List)`.
`RedisAPI`	`ftDropAndForget(List<String> args)`	Variant of `ftDrop(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftDropifx(List<String> args)`	Redis command ftDropifx.
`Response`	`ftDropifxAndAwait(List<String> args)`	Blocking variant of `ftDropifx(List)`.
`RedisAPI`	`ftDropifxAndForget(List<String> args)`	Variant of `ftDropifx(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftDropindex(List<String> args)`	Redis command ftDropindex.
`Response`	`ftDropindexAndAwait(List<String> args)`	Blocking variant of `ftDropindex(List)`.
`RedisAPI`	`ftDropindexAndForget(List<String> args)`	Variant of `ftDropindex(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftDropindexifx(List<String> args)`	Redis command ftDropindexifx.
`Response`	`ftDropindexifxAndAwait(List<String> args)`	Blocking variant of `ftDropindexifx(List)`.
`RedisAPI`	`ftDropindexifxAndForget(List<String> args)`	Variant of `ftDropindexifx(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftExplain(List<String> args)`	Redis command ftExplain.
`Response`	`ftExplainAndAwait(List<String> args)`	Blocking variant of `ftExplain(List)`.
`RedisAPI`	`ftExplainAndForget(List<String> args)`	Variant of `ftExplain(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftExplaincli(List<String> args)`	Redis command ftExplaincli.
`Response`	`ftExplaincliAndAwait(List<String> args)`	Blocking variant of `ftExplaincli(List)`.
`RedisAPI`	`ftExplaincliAndForget(List<String> args)`	Variant of `ftExplaincli(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftGet(List<String> args)`	Redis command ftGet.
`Response`	`ftGetAndAwait(List<String> args)`	Blocking variant of `ftGet(List)`.
`RedisAPI`	`ftGetAndForget(List<String> args)`	Variant of `ftGet(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftInfo(List<String> args)`	Redis command ftInfo.
`Response`	`ftInfoAndAwait(List<String> args)`	Blocking variant of `ftInfo(List)`.
`RedisAPI`	`ftInfoAndForget(List<String> args)`	Variant of `ftInfo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftList(List<String> args)`	Redis command ftList.
`Response`	`ftListAndAwait(List<String> args)`	Blocking variant of `ftList(List)`.
`RedisAPI`	`ftListAndForget(List<String> args)`	Variant of `ftList(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftMget(List<String> args)`	Redis command ftMget.
`Response`	`ftMgetAndAwait(List<String> args)`	Blocking variant of `ftMget(List)`.
`RedisAPI`	`ftMgetAndForget(List<String> args)`	Variant of `ftMget(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftProfile(List<String> args)`	Redis command ftProfile.
`Response`	`ftProfileAndAwait(List<String> args)`	Blocking variant of `ftProfile(List)`.
`RedisAPI`	`ftProfileAndForget(List<String> args)`	Variant of `ftProfile(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftSafeadd(List<String> args)`	Redis command ftSafeadd.
`Response`	`ftSafeaddAndAwait(List<String> args)`	Blocking variant of `ftSafeadd(List)`.
`RedisAPI`	`ftSafeaddAndForget(List<String> args)`	Variant of `ftSafeadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftSearch(List<String> args)`	Redis command ftSearch.
`Response`	`ftSearchAndAwait(List<String> args)`	Blocking variant of `ftSearch(List)`.
`RedisAPI`	`ftSearchAndForget(List<String> args)`	Variant of `ftSearch(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftSpellcheck(List<String> args)`	Redis command ftSpellcheck.
`Response`	`ftSpellcheckAndAwait(List<String> args)`	Blocking variant of `ftSpellcheck(List)`.
`RedisAPI`	`ftSpellcheckAndForget(List<String> args)`	Variant of `ftSpellcheck(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftSugadd(List<String> args)`	Redis command ftSugadd.
`Response`	`ftSugaddAndAwait(List<String> args)`	Blocking variant of `ftSugadd(List)`.
`RedisAPI`	`ftSugaddAndForget(List<String> args)`	Variant of `ftSugadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftSugdel(List<String> args)`	Redis command ftSugdel.
`Response`	`ftSugdelAndAwait(List<String> args)`	Blocking variant of `ftSugdel(List)`.
`RedisAPI`	`ftSugdelAndForget(List<String> args)`	Variant of `ftSugdel(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftSugget(List<String> args)`	Redis command ftSugget.
`Response`	`ftSuggetAndAwait(List<String> args)`	Blocking variant of `ftSugget(List)`.
`RedisAPI`	`ftSuggetAndForget(List<String> args)`	Variant of `ftSugget(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftSuglen(List<String> args)`	Redis command ftSuglen.
`Response`	`ftSuglenAndAwait(List<String> args)`	Blocking variant of `ftSuglen(List)`.
`RedisAPI`	`ftSuglenAndForget(List<String> args)`	Variant of `ftSuglen(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftSynadd(List<String> args)`	Redis command ftSynadd.
`Response`	`ftSynaddAndAwait(List<String> args)`	Blocking variant of `ftSynadd(List)`.
`RedisAPI`	`ftSynaddAndForget(List<String> args)`	Variant of `ftSynadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftSyndump(List<String> args)`	Redis command ftSyndump.
`Response`	`ftSyndumpAndAwait(List<String> args)`	Blocking variant of `ftSyndump(List)`.
`RedisAPI`	`ftSyndumpAndForget(List<String> args)`	Variant of `ftSyndump(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftSynupdate(List<String> args)`	Redis command ftSynupdate.
`Response`	`ftSynupdateAndAwait(List<String> args)`	Blocking variant of `ftSynupdate(List)`.
`RedisAPI`	`ftSynupdateAndForget(List<String> args)`	Variant of `ftSynupdate(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`ftTagvals(List<String> args)`	Redis command ftTagvals.
`Response`	`ftTagvalsAndAwait(List<String> args)`	Blocking variant of `ftTagvals(List)`.
`RedisAPI`	`ftTagvalsAndForget(List<String> args)`	Variant of `ftTagvals(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`function(List<String> args)`	Redis command function.
`Response`	`functionAndAwait(List<String> args)`	Blocking variant of `function(List)`.
`RedisAPI`	`functionAndForget(List<String> args)`	Variant of `function(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.
`io.smallrye.mutiny.Uni<Response>`	`graphBulk(List<String> args)`	Redis command graphBulk.
`Response`	`graphBulkAndAwait(List<String> args)`	Blocking variant of `graphBulk(List)`.
`RedisAPI`	`graphBulkAndForget(List<String> args)`	Variant of `graphBulk(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`graphConfig(List<String> args)`	Redis command graphConfig.
`Response`	`graphConfigAndAwait(List<String> args)`	Blocking variant of `graphConfig(List)`.
`RedisAPI`	`graphConfigAndForget(List<String> args)`	Variant of `graphConfig(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`graphDebug(List<String> args)`	Redis command graphDebug.
`Response`	`graphDebugAndAwait(List<String> args)`	Blocking variant of `graphDebug(List)`.
`RedisAPI`	`graphDebugAndForget(List<String> args)`	Variant of `graphDebug(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`graphDelete(List<String> args)`	Redis command graphDelete.
`Response`	`graphDeleteAndAwait(List<String> args)`	Blocking variant of `graphDelete(List)`.
`RedisAPI`	`graphDeleteAndForget(List<String> args)`	Variant of `graphDelete(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`graphExplain(List<String> args)`	Redis command graphExplain.
`Response`	`graphExplainAndAwait(List<String> args)`	Blocking variant of `graphExplain(List)`.
`RedisAPI`	`graphExplainAndForget(List<String> args)`	Variant of `graphExplain(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`graphList(List<String> args)`	Redis command graphList.
`Response`	`graphListAndAwait(List<String> args)`	Blocking variant of `graphList(List)`.
`RedisAPI`	`graphListAndForget(List<String> args)`	Variant of `graphList(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`graphProfile(List<String> args)`	Redis command graphProfile.
`Response`	`graphProfileAndAwait(List<String> args)`	Blocking variant of `graphProfile(List)`.
`RedisAPI`	`graphProfileAndForget(List<String> args)`	Variant of `graphProfile(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`graphQuery(List<String> args)`	Redis command graphQuery.
`Response`	`graphQueryAndAwait(List<String> args)`	Blocking variant of `graphQuery(List)`.
`RedisAPI`	`graphQueryAndForget(List<String> args)`	Variant of `graphQuery(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`graphRoQuery(List<String> args)`	Redis command graphRoQuery.
`Response`	`graphRoQueryAndAwait(List<String> args)`	Blocking variant of `graphRoQuery(List)`.
`RedisAPI`	`graphRoQueryAndForget(List<String> args)`	Variant of `graphRoQuery(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`graphSlowlog(List<String> args)`	Redis command graphSlowlog.
`Response`	`graphSlowlogAndAwait(List<String> args)`	Blocking variant of `graphSlowlog(List)`.
`RedisAPI`	`graphSlowlogAndForget(List<String> args)`	Variant of `graphSlowlog(List)` 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>`	`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>`	`jsonArrappend(List<String> args)`	Redis command jsonArrappend.
`Response`	`jsonArrappendAndAwait(List<String> args)`	Blocking variant of `jsonArrappend(List)`.
`RedisAPI`	`jsonArrappendAndForget(List<String> args)`	Variant of `jsonArrappend(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonArrindex(List<String> args)`	Redis command jsonArrindex.
`Response`	`jsonArrindexAndAwait(List<String> args)`	Blocking variant of `jsonArrindex(List)`.
`RedisAPI`	`jsonArrindexAndForget(List<String> args)`	Variant of `jsonArrindex(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonArrinsert(List<String> args)`	Redis command jsonArrinsert.
`Response`	`jsonArrinsertAndAwait(List<String> args)`	Blocking variant of `jsonArrinsert(List)`.
`RedisAPI`	`jsonArrinsertAndForget(List<String> args)`	Variant of `jsonArrinsert(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonArrlen(List<String> args)`	Redis command jsonArrlen.
`Response`	`jsonArrlenAndAwait(List<String> args)`	Blocking variant of `jsonArrlen(List)`.
`RedisAPI`	`jsonArrlenAndForget(List<String> args)`	Variant of `jsonArrlen(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonArrpop(List<String> args)`	Redis command jsonArrpop.
`Response`	`jsonArrpopAndAwait(List<String> args)`	Blocking variant of `jsonArrpop(List)`.
`RedisAPI`	`jsonArrpopAndForget(List<String> args)`	Variant of `jsonArrpop(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonArrtrim(List<String> args)`	Redis command jsonArrtrim.
`Response`	`jsonArrtrimAndAwait(List<String> args)`	Blocking variant of `jsonArrtrim(List)`.
`RedisAPI`	`jsonArrtrimAndForget(List<String> args)`	Variant of `jsonArrtrim(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonClear(List<String> args)`	Redis command jsonClear.
`Response`	`jsonClearAndAwait(List<String> args)`	Blocking variant of `jsonClear(List)`.
`RedisAPI`	`jsonClearAndForget(List<String> args)`	Variant of `jsonClear(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonDebug(List<String> args)`	Redis command jsonDebug.
`Response`	`jsonDebugAndAwait(List<String> args)`	Blocking variant of `jsonDebug(List)`.
`RedisAPI`	`jsonDebugAndForget(List<String> args)`	Variant of `jsonDebug(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonDel(List<String> args)`	Redis command jsonDel.
`Response`	`jsonDelAndAwait(List<String> args)`	Blocking variant of `jsonDel(List)`.
`RedisAPI`	`jsonDelAndForget(List<String> args)`	Variant of `jsonDel(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonForget(List<String> args)`	Redis command jsonForget.
`Response`	`jsonForgetAndAwait(List<String> args)`	Blocking variant of `jsonForget(List)`.
`RedisAPI`	`jsonForgetAndForget(List<String> args)`	Variant of `jsonForget(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonGet(List<String> args)`	Redis command jsonGet.
`Response`	`jsonGetAndAwait(List<String> args)`	Blocking variant of `jsonGet(List)`.
`RedisAPI`	`jsonGetAndForget(List<String> args)`	Variant of `jsonGet(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonMget(List<String> args)`	Redis command jsonMget.
`Response`	`jsonMgetAndAwait(List<String> args)`	Blocking variant of `jsonMget(List)`.
`RedisAPI`	`jsonMgetAndForget(List<String> args)`	Variant of `jsonMget(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonNumincrby(List<String> args)`	Redis command jsonNumincrby.
`Response`	`jsonNumincrbyAndAwait(List<String> args)`	Blocking variant of `jsonNumincrby(List)`.
`RedisAPI`	`jsonNumincrbyAndForget(List<String> args)`	Variant of `jsonNumincrby(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonNummultby(List<String> args)`	Redis command jsonNummultby.
`Response`	`jsonNummultbyAndAwait(List<String> args)`	Blocking variant of `jsonNummultby(List)`.
`RedisAPI`	`jsonNummultbyAndForget(List<String> args)`	Variant of `jsonNummultby(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonNumpowby(List<String> args)`	Redis command jsonNumpowby.
`Response`	`jsonNumpowbyAndAwait(List<String> args)`	Blocking variant of `jsonNumpowby(List)`.
`RedisAPI`	`jsonNumpowbyAndForget(List<String> args)`	Variant of `jsonNumpowby(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonObjkeys(List<String> args)`	Redis command jsonObjkeys.
`Response`	`jsonObjkeysAndAwait(List<String> args)`	Blocking variant of `jsonObjkeys(List)`.
`RedisAPI`	`jsonObjkeysAndForget(List<String> args)`	Variant of `jsonObjkeys(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonObjlen(List<String> args)`	Redis command jsonObjlen.
`Response`	`jsonObjlenAndAwait(List<String> args)`	Blocking variant of `jsonObjlen(List)`.
`RedisAPI`	`jsonObjlenAndForget(List<String> args)`	Variant of `jsonObjlen(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonResp(List<String> args)`	Redis command jsonResp.
`Response`	`jsonRespAndAwait(List<String> args)`	Blocking variant of `jsonResp(List)`.
`RedisAPI`	`jsonRespAndForget(List<String> args)`	Variant of `jsonResp(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonSet(List<String> args)`	Redis command jsonSet.
`Response`	`jsonSetAndAwait(List<String> args)`	Blocking variant of `jsonSet(List)`.
`RedisAPI`	`jsonSetAndForget(List<String> args)`	Variant of `jsonSet(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonStrappend(List<String> args)`	Redis command jsonStrappend.
`Response`	`jsonStrappendAndAwait(List<String> args)`	Blocking variant of `jsonStrappend(List)`.
`RedisAPI`	`jsonStrappendAndForget(List<String> args)`	Variant of `jsonStrappend(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonStrlen(List<String> args)`	Redis command jsonStrlen.
`Response`	`jsonStrlenAndAwait(List<String> args)`	Blocking variant of `jsonStrlen(List)`.
`RedisAPI`	`jsonStrlenAndForget(List<String> args)`	Variant of `jsonStrlen(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonToggle(List<String> args)`	Redis command jsonToggle.
`Response`	`jsonToggleAndAwait(List<String> args)`	Blocking variant of `jsonToggle(List)`.
`RedisAPI`	`jsonToggleAndForget(List<String> args)`	Variant of `jsonToggle(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`jsonType(List<String> args)`	Redis command jsonType.
`Response`	`jsonTypeAndAwait(List<String> args)`	Blocking variant of `jsonType(List)`.
`RedisAPI`	`jsonTypeAndForget(List<String> args)`	Variant of `jsonType(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>`	`lcs(List<String> args)`	Redis command lcs.
`Response`	`lcsAndAwait(List<String> args)`	Blocking variant of `lcs(List)`.
`RedisAPI`	`lcsAndForget(List<String> args)`	Variant of `lcs(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>`	`lmpop(List<String> args)`	Redis command lmpop.
`Response`	`lmpopAndAwait(List<String> args)`	Blocking variant of `lmpop(List)`.
`RedisAPI`	`lmpopAndForget(List<String> args)`	Variant of `lmpop(List)` 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(List<String> args)`	Redis command pexpire.
`Response`	`pexpireAndAwait(List<String> args)`	Blocking variant of `pexpire(List)`.
`RedisAPI`	`pexpireAndForget(List<String> args)`	Variant of `pexpire(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pexpireat(List<String> args)`	Redis command pexpireat.
`Response`	`pexpireatAndAwait(List<String> args)`	Blocking variant of `pexpireat(List)`.
`RedisAPI`	`pexpireatAndForget(List<String> args)`	Variant of `pexpireat(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pexpiretime(String arg0)`	Redis command pexpiretime.
`Response`	`pexpiretimeAndAwait(String arg0)`	Blocking variant of `pexpiretime(String)`.
`RedisAPI`	`pexpiretimeAndForget(String arg0)`	Variant of `pexpiretime(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>`	`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>`	`quit(List<String> args)`	Redis command quit.
`Response`	`quitAndAwait(List<String> args)`	Blocking variant of `quit(List)`.
`RedisAPI`	`quitAndForget(List<String> args)`	Variant of `quit(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>`	`sintercard(List<String> args)`	Redis command sintercard.
`Response`	`sintercardAndAwait(List<String> args)`	Blocking variant of `sintercard(List)`.
`RedisAPI`	`sintercardAndForget(List<String> args)`	Variant of `sintercard(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>`	`sortRo(List<String> args)`	Redis command sortRo.
`Response`	`sortRoAndAwait(List<String> args)`	Blocking variant of `sortRo(List)`.
`RedisAPI`	`sortRoAndForget(List<String> args)`	Variant of `sortRo(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>`	`spublish(String arg0, String arg1)`	Redis command spublish.
`Response`	`spublishAndAwait(String arg0, String arg1)`	Blocking variant of `spublish(String,String)`.
`RedisAPI`	`spublishAndForget(String arg0, String arg1)`	Variant of `spublish(String,String)` 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>`	`ssubscribe(List<String> args)`	Redis command ssubscribe.
`Response`	`ssubscribeAndAwait(List<String> args)`	Blocking variant of `ssubscribe(List)`.
`RedisAPI`	`ssubscribeAndForget(List<String> args)`	Variant of `ssubscribe(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>`	`sunsubscribe(List<String> args)`	Redis command sunsubscribe.
`Response`	`sunsubscribeAndAwait(List<String> args)`	Blocking variant of `sunsubscribe(List)`.
`RedisAPI`	`sunsubscribeAndForget(List<String> args)`	Variant of `sunsubscribe(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.
`io.smallrye.mutiny.Uni<Response>`	`timeseriesClusterset(List<String> args)`	Redis command timeseriesClusterset.
`Response`	`timeseriesClustersetAndAwait(List<String> args)`	Blocking variant of `timeseriesClusterset(List)`.
`RedisAPI`	`timeseriesClustersetAndForget(List<String> args)`	Variant of `timeseriesClusterset(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`timeseriesClustersetfromshard(List<String> args)`	Redis command timeseriesClustersetfromshard.
`Response`	`timeseriesClustersetfromshardAndAwait(List<String> args)`	Blocking variant of `timeseriesClustersetfromshard(List)`.
`RedisAPI`	`timeseriesClustersetfromshardAndForget(List<String> args)`	Variant of `timeseriesClustersetfromshard(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`timeseriesHello(List<String> args)`	Redis command timeseriesHello.
`Response`	`timeseriesHelloAndAwait(List<String> args)`	Blocking variant of `timeseriesHello(List)`.
`RedisAPI`	`timeseriesHelloAndForget(List<String> args)`	Variant of `timeseriesHello(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`timeseriesInfocluster(List<String> args)`	Redis command timeseriesInfocluster.
`Response`	`timeseriesInfoclusterAndAwait(List<String> args)`	Blocking variant of `timeseriesInfocluster(List)`.
`RedisAPI`	`timeseriesInfoclusterAndForget(List<String> args)`	Variant of `timeseriesInfocluster(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`timeseriesInnercommunication(List<String> args)`	Redis command timeseriesInnercommunication.
`Response`	`timeseriesInnercommunicationAndAwait(List<String> args)`	Blocking variant of `timeseriesInnercommunication(List)`.
`RedisAPI`	`timeseriesInnercommunicationAndForget(List<String> args)`	Variant of `timeseriesInnercommunication(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`timeseriesNetworktest(List<String> args)`	Redis command timeseriesNetworktest.
`Response`	`timeseriesNetworktestAndAwait(List<String> args)`	Blocking variant of `timeseriesNetworktest(List)`.
`RedisAPI`	`timeseriesNetworktestAndForget(List<String> args)`	Variant of `timeseriesNetworktest(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`timeseriesRefreshcluster(List<String> args)`	Redis command timeseriesRefreshcluster.
`Response`	`timeseriesRefreshclusterAndAwait(List<String> args)`	Blocking variant of `timeseriesRefreshcluster(List)`.
`RedisAPI`	`timeseriesRefreshclusterAndForget(List<String> args)`	Variant of `timeseriesRefreshcluster(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`topkAdd(List<String> args)`	Redis command topkAdd.
`Response`	`topkAddAndAwait(List<String> args)`	Blocking variant of `topkAdd(List)`.
`RedisAPI`	`topkAddAndForget(List<String> args)`	Variant of `topkAdd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`topkCount(List<String> args)`	Redis command topkCount.
`Response`	`topkCountAndAwait(List<String> args)`	Blocking variant of `topkCount(List)`.
`RedisAPI`	`topkCountAndForget(List<String> args)`	Variant of `topkCount(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`topkIncrby(List<String> args)`	Redis command topkIncrby.
`Response`	`topkIncrbyAndAwait(List<String> args)`	Blocking variant of `topkIncrby(List)`.
`RedisAPI`	`topkIncrbyAndForget(List<String> args)`	Variant of `topkIncrby(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`topkInfo(List<String> args)`	Redis command topkInfo.
`Response`	`topkInfoAndAwait(List<String> args)`	Blocking variant of `topkInfo(List)`.
`RedisAPI`	`topkInfoAndForget(List<String> args)`	Variant of `topkInfo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`topkList(List<String> args)`	Redis command topkList.
`Response`	`topkListAndAwait(List<String> args)`	Blocking variant of `topkList(List)`.
`RedisAPI`	`topkListAndForget(List<String> args)`	Variant of `topkList(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`topkQuery(List<String> args)`	Redis command topkQuery.
`Response`	`topkQueryAndAwait(List<String> args)`	Blocking variant of `topkQuery(List)`.
`RedisAPI`	`topkQueryAndForget(List<String> args)`	Variant of `topkQuery(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`topkReserve(List<String> args)`	Redis command topkReserve.
`Response`	`topkReserveAndAwait(List<String> args)`	Blocking variant of `topkReserve(List)`.
`RedisAPI`	`topkReserveAndForget(List<String> args)`	Variant of `topkReserve(List)` 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>`	`tsAdd(List<String> args)`	Redis command tsAdd.
`Response`	`tsAddAndAwait(List<String> args)`	Blocking variant of `tsAdd(List)`.
`RedisAPI`	`tsAddAndForget(List<String> args)`	Variant of `tsAdd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsAlter(List<String> args)`	Redis command tsAlter.
`Response`	`tsAlterAndAwait(List<String> args)`	Blocking variant of `tsAlter(List)`.
`RedisAPI`	`tsAlterAndForget(List<String> args)`	Variant of `tsAlter(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsCreate(List<String> args)`	Redis command tsCreate.
`Response`	`tsCreateAndAwait(List<String> args)`	Blocking variant of `tsCreate(List)`.
`RedisAPI`	`tsCreateAndForget(List<String> args)`	Variant of `tsCreate(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsCreaterule(List<String> args)`	Redis command tsCreaterule.
`Response`	`tsCreateruleAndAwait(List<String> args)`	Blocking variant of `tsCreaterule(List)`.
`RedisAPI`	`tsCreateruleAndForget(List<String> args)`	Variant of `tsCreaterule(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsDecrby(List<String> args)`	Redis command tsDecrby.
`Response`	`tsDecrbyAndAwait(List<String> args)`	Blocking variant of `tsDecrby(List)`.
`RedisAPI`	`tsDecrbyAndForget(List<String> args)`	Variant of `tsDecrby(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsDel(List<String> args)`	Redis command tsDel.
`Response`	`tsDelAndAwait(List<String> args)`	Blocking variant of `tsDel(List)`.
`RedisAPI`	`tsDelAndForget(List<String> args)`	Variant of `tsDel(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsDeleterule(List<String> args)`	Redis command tsDeleterule.
`Response`	`tsDeleteruleAndAwait(List<String> args)`	Blocking variant of `tsDeleterule(List)`.
`RedisAPI`	`tsDeleteruleAndForget(List<String> args)`	Variant of `tsDeleterule(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsGet(List<String> args)`	Redis command tsGet.
`Response`	`tsGetAndAwait(List<String> args)`	Blocking variant of `tsGet(List)`.
`RedisAPI`	`tsGetAndForget(List<String> args)`	Variant of `tsGet(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsIncrby(List<String> args)`	Redis command tsIncrby.
`Response`	`tsIncrbyAndAwait(List<String> args)`	Blocking variant of `tsIncrby(List)`.
`RedisAPI`	`tsIncrbyAndForget(List<String> args)`	Variant of `tsIncrby(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsInfo(List<String> args)`	Redis command tsInfo.
`Response`	`tsInfoAndAwait(List<String> args)`	Blocking variant of `tsInfo(List)`.
`RedisAPI`	`tsInfoAndForget(List<String> args)`	Variant of `tsInfo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsMadd(List<String> args)`	Redis command tsMadd.
`Response`	`tsMaddAndAwait(List<String> args)`	Blocking variant of `tsMadd(List)`.
`RedisAPI`	`tsMaddAndForget(List<String> args)`	Variant of `tsMadd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsMget(List<String> args)`	Redis command tsMget.
`Response`	`tsMgetAndAwait(List<String> args)`	Blocking variant of `tsMget(List)`.
`RedisAPI`	`tsMgetAndForget(List<String> args)`	Variant of `tsMget(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsMrange(List<String> args)`	Redis command tsMrange.
`Response`	`tsMrangeAndAwait(List<String> args)`	Blocking variant of `tsMrange(List)`.
`RedisAPI`	`tsMrangeAndForget(List<String> args)`	Variant of `tsMrange(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsMrevrange(List<String> args)`	Redis command tsMrevrange.
`Response`	`tsMrevrangeAndAwait(List<String> args)`	Blocking variant of `tsMrevrange(List)`.
`RedisAPI`	`tsMrevrangeAndForget(List<String> args)`	Variant of `tsMrevrange(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsQueryindex(List<String> args)`	Redis command tsQueryindex.
`Response`	`tsQueryindexAndAwait(List<String> args)`	Blocking variant of `tsQueryindex(List)`.
`RedisAPI`	`tsQueryindexAndForget(List<String> args)`	Variant of `tsQueryindex(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsRange(List<String> args)`	Redis command tsRange.
`Response`	`tsRangeAndAwait(List<String> args)`	Blocking variant of `tsRange(List)`.
`RedisAPI`	`tsRangeAndForget(List<String> args)`	Variant of `tsRange(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tsRevrange(List<String> args)`	Redis command tsRevrange.
`Response`	`tsRevrangeAndAwait(List<String> args)`	Blocking variant of `tsRevrange(List)`.
`RedisAPI`	`tsRevrangeAndForget(List<String> args)`	Variant of `tsRevrange(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(List<String> args)`	Redis command xsetid.
`Response`	`xsetidAndAwait(List<String> args)`	Blocking variant of `xsetid(List)`.
`RedisAPI`	`xsetidAndForget(List<String> args)`	Variant of `xsetid(List)` 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>`	`zintercard(List<String> args)`	Redis command zintercard.
`Response`	`zintercardAndAwait(List<String> args)`	Blocking variant of `zintercard(List)`.
`RedisAPI`	`zintercardAndForget(List<String> args)`	Variant of `zintercard(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>`	`zmpop(List<String> args)`	Redis command zmpop.
`Response`	`zmpopAndAwait(List<String> args)`	Blocking variant of `zmpop(List)`.
`RedisAPI`	`zmpopAndForget(List<String> args)`	Variant of `zmpop(List)` 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()
```
  - ftAdd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftAdd(List<String> args)
```
    Redis command ftAdd.
    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.
  - ftAddAndAwait
```
public Response ftAddAndAwait(List<String> args)
```
    Blocking variant of ftAdd(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.
  - ftAddAndForget
```
public RedisAPI ftAddAndForget(List<String> args)
```
    Variant of ftAdd(List) that ignores the result of the operation.
    This method subscribes on the result of ftAdd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftAdd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftAggregate
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftAggregate(List<String> args)
```
    Redis command ftAggregate.
    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.
  - ftAggregateAndAwait
```
public Response ftAggregateAndAwait(List<String> args)
```
    Blocking variant of ftAggregate(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.
  - ftAggregateAndForget
```
public RedisAPI ftAggregateAndForget(List<String> args)
```
    Variant of ftAggregate(List) that ignores the result of the operation.
    This method subscribes on the result of ftAggregate(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftAggregate(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftAliasadd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftAliasadd(List<String> args)
```
    Redis command ftAliasadd.
    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.
  - ftAliasaddAndAwait
```
public Response ftAliasaddAndAwait(List<String> args)
```
    Blocking variant of ftAliasadd(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.
  - ftAliasaddAndForget
```
public RedisAPI ftAliasaddAndForget(List<String> args)
```
    Variant of ftAliasadd(List) that ignores the result of the operation.
    This method subscribes on the result of ftAliasadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftAliasadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftAliasdel
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftAliasdel(List<String> args)
```
    Redis command ftAliasdel.
    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.
  - ftAliasdelAndAwait
```
public Response ftAliasdelAndAwait(List<String> args)
```
    Blocking variant of ftAliasdel(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.
  - ftAliasdelAndForget
```
public RedisAPI ftAliasdelAndForget(List<String> args)
```
    Variant of ftAliasdel(List) that ignores the result of the operation.
    This method subscribes on the result of ftAliasdel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftAliasdel(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftAliasupdate
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftAliasupdate(List<String> args)
```
    Redis command ftAliasupdate.
    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.
  - ftAliasupdateAndAwait
```
public Response ftAliasupdateAndAwait(List<String> args)
```
    Blocking variant of ftAliasupdate(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.
  - ftAliasupdateAndForget
```
public RedisAPI ftAliasupdateAndForget(List<String> args)
```
    Variant of ftAliasupdate(List) that ignores the result of the operation.
    This method subscribes on the result of ftAliasupdate(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftAliasupdate(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftAlter
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftAlter(List<String> args)
```
    Redis command ftAlter.
    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.
  - ftAlterAndAwait
```
public Response ftAlterAndAwait(List<String> args)
```
    Blocking variant of ftAlter(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.
  - ftAlterAndForget
```
public RedisAPI ftAlterAndForget(List<String> args)
```
    Variant of ftAlter(List) that ignores the result of the operation.
    This method subscribes on the result of ftAlter(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftAlter(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftConfig
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftConfig(List<String> args)
```
    Redis command ftConfig.
    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.
  - ftConfigAndAwait
```
public Response ftConfigAndAwait(List<String> args)
```
    Blocking variant of ftConfig(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.
  - ftConfigAndForget
```
public RedisAPI ftConfigAndForget(List<String> args)
```
    Variant of ftConfig(List) that ignores the result of the operation.
    This method subscribes on the result of ftConfig(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftConfig(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftCreate
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftCreate(List<String> args)
```
    Redis command ftCreate.
    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.
  - ftCreateAndAwait
```
public Response ftCreateAndAwait(List<String> args)
```
    Blocking variant of ftCreate(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.
  - ftCreateAndForget
```
public RedisAPI ftCreateAndForget(List<String> args)
```
    Variant of ftCreate(List) that ignores the result of the operation.
    This method subscribes on the result of ftCreate(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftCreate(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftCursor
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftCursor(List<String> args)
```
    Redis command ftCursor.
    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.
  - ftCursorAndAwait
```
public Response ftCursorAndAwait(List<String> args)
```
    Blocking variant of ftCursor(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.
  - ftCursorAndForget
```
public RedisAPI ftCursorAndForget(List<String> args)
```
    Variant of ftCursor(List) that ignores the result of the operation.
    This method subscribes on the result of ftCursor(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftCursor(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftDebug
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftDebug(List<String> args)
```
    Redis command ftDebug.
    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.
  - ftDebugAndAwait
```
public Response ftDebugAndAwait(List<String> args)
```
    Blocking variant of ftDebug(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.
  - ftDebugAndForget
```
public RedisAPI ftDebugAndForget(List<String> args)
```
    Variant of ftDebug(List) that ignores the result of the operation.
    This method subscribes on the result of ftDebug(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftDebug(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftDel
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftDel(List<String> args)
```
    Redis command ftDel.
    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.
  - ftDelAndAwait
```
public Response ftDelAndAwait(List<String> args)
```
    Blocking variant of ftDel(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.
  - ftDelAndForget
```
public RedisAPI ftDelAndForget(List<String> args)
```
    Variant of ftDel(List) that ignores the result of the operation.
    This method subscribes on the result of ftDel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftDel(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftDictadd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftDictadd(List<String> args)
```
    Redis command ftDictadd.
    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.
  - ftDictaddAndAwait
```
public Response ftDictaddAndAwait(List<String> args)
```
    Blocking variant of ftDictadd(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.
  - ftDictaddAndForget
```
public RedisAPI ftDictaddAndForget(List<String> args)
```
    Variant of ftDictadd(List) that ignores the result of the operation.
    This method subscribes on the result of ftDictadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftDictadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftDictdel
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftDictdel(List<String> args)
```
    Redis command ftDictdel.
    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.
  - ftDictdelAndAwait
```
public Response ftDictdelAndAwait(List<String> args)
```
    Blocking variant of ftDictdel(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.
  - ftDictdelAndForget
```
public RedisAPI ftDictdelAndForget(List<String> args)
```
    Variant of ftDictdel(List) that ignores the result of the operation.
    This method subscribes on the result of ftDictdel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftDictdel(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftDictdump
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftDictdump(List<String> args)
```
    Redis command ftDictdump.
    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.
  - ftDictdumpAndAwait
```
public Response ftDictdumpAndAwait(List<String> args)
```
    Blocking variant of ftDictdump(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.
  - ftDictdumpAndForget
```
public RedisAPI ftDictdumpAndForget(List<String> args)
```
    Variant of ftDictdump(List) that ignores the result of the operation.
    This method subscribes on the result of ftDictdump(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftDictdump(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftDrop
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftDrop(List<String> args)
```
    Redis command ftDrop.
    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.
  - ftDropAndAwait
```
public Response ftDropAndAwait(List<String> args)
```
    Blocking variant of ftDrop(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.
  - ftDropAndForget
```
public RedisAPI ftDropAndForget(List<String> args)
```
    Variant of ftDrop(List) that ignores the result of the operation.
    This method subscribes on the result of ftDrop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftDrop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftDropindex
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftDropindex(List<String> args)
```
    Redis command ftDropindex.
    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.
  - ftDropindexAndAwait
```
public Response ftDropindexAndAwait(List<String> args)
```
    Blocking variant of ftDropindex(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.
  - ftDropindexAndForget
```
public RedisAPI ftDropindexAndForget(List<String> args)
```
    Variant of ftDropindex(List) that ignores the result of the operation.
    This method subscribes on the result of ftDropindex(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftDropindex(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftExplain
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftExplain(List<String> args)
```
    Redis command ftExplain.
    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.
  - ftExplainAndAwait
```
public Response ftExplainAndAwait(List<String> args)
```
    Blocking variant of ftExplain(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.
  - ftExplainAndForget
```
public RedisAPI ftExplainAndForget(List<String> args)
```
    Variant of ftExplain(List) that ignores the result of the operation.
    This method subscribes on the result of ftExplain(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftExplain(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftExplaincli
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftExplaincli(List<String> args)
```
    Redis command ftExplaincli.
    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.
  - ftExplaincliAndAwait
```
public Response ftExplaincliAndAwait(List<String> args)
```
    Blocking variant of ftExplaincli(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.
  - ftExplaincliAndForget
```
public RedisAPI ftExplaincliAndForget(List<String> args)
```
    Variant of ftExplaincli(List) that ignores the result of the operation.
    This method subscribes on the result of ftExplaincli(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftExplaincli(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftGet
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftGet(List<String> args)
```
    Redis command ftGet.
    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.
  - ftGetAndAwait
```
public Response ftGetAndAwait(List<String> args)
```
    Blocking variant of ftGet(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.
  - ftGetAndForget
```
public RedisAPI ftGetAndForget(List<String> args)
```
    Variant of ftGet(List) that ignores the result of the operation.
    This method subscribes on the result of ftGet(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftGet(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftInfo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftInfo(List<String> args)
```
    Redis command ftInfo.
    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.
  - ftInfoAndAwait
```
public Response ftInfoAndAwait(List<String> args)
```
    Blocking variant of ftInfo(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.
  - ftInfoAndForget
```
public RedisAPI ftInfoAndForget(List<String> args)
```
    Variant of ftInfo(List) that ignores the result of the operation.
    This method subscribes on the result of ftInfo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftInfo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftMget
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftMget(List<String> args)
```
    Redis command ftMget.
    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.
  - ftMgetAndAwait
```
public Response ftMgetAndAwait(List<String> args)
```
    Blocking variant of ftMget(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.
  - ftMgetAndForget
```
public RedisAPI ftMgetAndForget(List<String> args)
```
    Variant of ftMget(List) that ignores the result of the operation.
    This method subscribes on the result of ftMget(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftMget(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftProfile
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftProfile(List<String> args)
```
    Redis command ftProfile.
    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.
  - ftProfileAndAwait
```
public Response ftProfileAndAwait(List<String> args)
```
    Blocking variant of ftProfile(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.
  - ftProfileAndForget
```
public RedisAPI ftProfileAndForget(List<String> args)
```
    Variant of ftProfile(List) that ignores the result of the operation.
    This method subscribes on the result of ftProfile(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftProfile(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftSafeadd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftSafeadd(List<String> args)
```
    Redis command ftSafeadd.
    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.
  - ftSafeaddAndAwait
```
public Response ftSafeaddAndAwait(List<String> args)
```
    Blocking variant of ftSafeadd(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.
  - ftSafeaddAndForget
```
public RedisAPI ftSafeaddAndForget(List<String> args)
```
    Variant of ftSafeadd(List) that ignores the result of the operation.
    This method subscribes on the result of ftSafeadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftSafeadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftSearch
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftSearch(List<String> args)
```
    Redis command ftSearch.
    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.
  - ftSearchAndAwait
```
public Response ftSearchAndAwait(List<String> args)
```
    Blocking variant of ftSearch(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.
  - ftSearchAndForget
```
public RedisAPI ftSearchAndForget(List<String> args)
```
    Variant of ftSearch(List) that ignores the result of the operation.
    This method subscribes on the result of ftSearch(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftSearch(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftSpellcheck
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftSpellcheck(List<String> args)
```
    Redis command ftSpellcheck.
    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.
  - ftSpellcheckAndAwait
```
public Response ftSpellcheckAndAwait(List<String> args)
```
    Blocking variant of ftSpellcheck(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.
  - ftSpellcheckAndForget
```
public RedisAPI ftSpellcheckAndForget(List<String> args)
```
    Variant of ftSpellcheck(List) that ignores the result of the operation.
    This method subscribes on the result of ftSpellcheck(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftSpellcheck(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftSugadd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftSugadd(List<String> args)
```
    Redis command ftSugadd.
    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.
  - ftSugaddAndAwait
```
public Response ftSugaddAndAwait(List<String> args)
```
    Blocking variant of ftSugadd(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.
  - ftSugaddAndForget
```
public RedisAPI ftSugaddAndForget(List<String> args)
```
    Variant of ftSugadd(List) that ignores the result of the operation.
    This method subscribes on the result of ftSugadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftSugadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftSugdel
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftSugdel(List<String> args)
```
    Redis command ftSugdel.
    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.
  - ftSugdelAndAwait
```
public Response ftSugdelAndAwait(List<String> args)
```
    Blocking variant of ftSugdel(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.
  - ftSugdelAndForget
```
public RedisAPI ftSugdelAndForget(List<String> args)
```
    Variant of ftSugdel(List) that ignores the result of the operation.
    This method subscribes on the result of ftSugdel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftSugdel(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftSugget
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftSugget(List<String> args)
```
    Redis command ftSugget.
    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.
  - ftSuggetAndAwait
```
public Response ftSuggetAndAwait(List<String> args)
```
    Blocking variant of ftSugget(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.
  - ftSuggetAndForget
```
public RedisAPI ftSuggetAndForget(List<String> args)
```
    Variant of ftSugget(List) that ignores the result of the operation.
    This method subscribes on the result of ftSugget(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftSugget(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftSuglen
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftSuglen(List<String> args)
```
    Redis command ftSuglen.
    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.
  - ftSuglenAndAwait
```
public Response ftSuglenAndAwait(List<String> args)
```
    Blocking variant of ftSuglen(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.
  - ftSuglenAndForget
```
public RedisAPI ftSuglenAndForget(List<String> args)
```
    Variant of ftSuglen(List) that ignores the result of the operation.
    This method subscribes on the result of ftSuglen(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftSuglen(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftSynadd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftSynadd(List<String> args)
```
    Redis command ftSynadd.
    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.
  - ftSynaddAndAwait
```
public Response ftSynaddAndAwait(List<String> args)
```
    Blocking variant of ftSynadd(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.
  - ftSynaddAndForget
```
public RedisAPI ftSynaddAndForget(List<String> args)
```
    Variant of ftSynadd(List) that ignores the result of the operation.
    This method subscribes on the result of ftSynadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftSynadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftSyndump
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftSyndump(List<String> args)
```
    Redis command ftSyndump.
    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.
  - ftSyndumpAndAwait
```
public Response ftSyndumpAndAwait(List<String> args)
```
    Blocking variant of ftSyndump(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.
  - ftSyndumpAndForget
```
public RedisAPI ftSyndumpAndForget(List<String> args)
```
    Variant of ftSyndump(List) that ignores the result of the operation.
    This method subscribes on the result of ftSyndump(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftSyndump(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftSynupdate
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftSynupdate(List<String> args)
```
    Redis command ftSynupdate.
    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.
  - ftSynupdateAndAwait
```
public Response ftSynupdateAndAwait(List<String> args)
```
    Blocking variant of ftSynupdate(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.
  - ftSynupdateAndForget
```
public RedisAPI ftSynupdateAndForget(List<String> args)
```
    Variant of ftSynupdate(List) that ignores the result of the operation.
    This method subscribes on the result of ftSynupdate(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftSynupdate(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftTagvals
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftTagvals(List<String> args)
```
    Redis command ftTagvals.
    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.
  - ftTagvalsAndAwait
```
public Response ftTagvalsAndAwait(List<String> args)
```
    Blocking variant of ftTagvals(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.
  - ftTagvalsAndForget
```
public RedisAPI ftTagvalsAndForget(List<String> args)
```
    Variant of ftTagvals(List) that ignores the result of the operation.
    This method subscribes on the result of ftTagvals(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftTagvals(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftAliasaddifnx
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftAliasaddifnx(List<String> args)
```
    Redis command ftAliasaddifnx.
    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.
  - ftAliasaddifnxAndAwait
```
public Response ftAliasaddifnxAndAwait(List<String> args)
```
    Blocking variant of ftAliasaddifnx(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.
  - ftAliasaddifnxAndForget
```
public RedisAPI ftAliasaddifnxAndForget(List<String> args)
```
    Variant of ftAliasaddifnx(List) that ignores the result of the operation.
    This method subscribes on the result of ftAliasaddifnx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftAliasaddifnx(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftAliasdelifx
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftAliasdelifx(List<String> args)
```
    Redis command ftAliasdelifx.
    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.
  - ftAliasdelifxAndAwait
```
public Response ftAliasdelifxAndAwait(List<String> args)
```
    Blocking variant of ftAliasdelifx(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.
  - ftAliasdelifxAndForget
```
public RedisAPI ftAliasdelifxAndForget(List<String> args)
```
    Variant of ftAliasdelifx(List) that ignores the result of the operation.
    This method subscribes on the result of ftAliasdelifx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftAliasdelifx(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftAlterifnx
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftAlterifnx(List<String> args)
```
    Redis command ftAlterifnx.
    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.
  - ftAlterifnxAndAwait
```
public Response ftAlterifnxAndAwait(List<String> args)
```
    Blocking variant of ftAlterifnx(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.
  - ftAlterifnxAndForget
```
public RedisAPI ftAlterifnxAndForget(List<String> args)
```
    Variant of ftAlterifnx(List) that ignores the result of the operation.
    This method subscribes on the result of ftAlterifnx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftAlterifnx(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftCreateifnx
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftCreateifnx(List<String> args)
```
    Redis command ftCreateifnx.
    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.
  - ftCreateifnxAndAwait
```
public Response ftCreateifnxAndAwait(List<String> args)
```
    Blocking variant of ftCreateifnx(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.
  - ftCreateifnxAndForget
```
public RedisAPI ftCreateifnxAndForget(List<String> args)
```
    Variant of ftCreateifnx(List) that ignores the result of the operation.
    This method subscribes on the result of ftCreateifnx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftCreateifnx(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftDropifx
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftDropifx(List<String> args)
```
    Redis command ftDropifx.
    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.
  - ftDropifxAndAwait
```
public Response ftDropifxAndAwait(List<String> args)
```
    Blocking variant of ftDropifx(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.
  - ftDropifxAndForget
```
public RedisAPI ftDropifxAndForget(List<String> args)
```
    Variant of ftDropifx(List) that ignores the result of the operation.
    This method subscribes on the result of ftDropifx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftDropifx(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftDropindexifx
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftDropindexifx(List<String> args)
```
    Redis command ftDropindexifx.
    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.
  - ftDropindexifxAndAwait
```
public Response ftDropindexifxAndAwait(List<String> args)
```
    Blocking variant of ftDropindexifx(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.
  - ftDropindexifxAndForget
```
public RedisAPI ftDropindexifxAndForget(List<String> args)
```
    Variant of ftDropindexifx(List) that ignores the result of the operation.
    This method subscribes on the result of ftDropindexifx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftDropindexifx(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - ftList
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ftList(List<String> args)
```
    Redis command ftList.
    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.
  - ftListAndAwait
```
public Response ftListAndAwait(List<String> args)
```
    Blocking variant of ftList(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.
  - ftListAndForget
```
public RedisAPI ftListAndForget(List<String> args)
```
    Variant of ftList(List) that ignores the result of the operation.
    This method subscribes on the result of ftList(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ftList(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - 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.
  - bfAdd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bfAdd(List<String> args)
```
    Redis command bfAdd.
    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.
  - bfAddAndAwait
```
public Response bfAddAndAwait(List<String> args)
```
    Blocking variant of bfAdd(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.
  - bfAddAndForget
```
public RedisAPI bfAddAndForget(List<String> args)
```
    Variant of bfAdd(List) that ignores the result of the operation.
    This method subscribes on the result of bfAdd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bfAdd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bfDebug
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bfDebug(List<String> args)
```
    Redis command bfDebug.
    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.
  - bfDebugAndAwait
```
public Response bfDebugAndAwait(List<String> args)
```
    Blocking variant of bfDebug(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.
  - bfDebugAndForget
```
public RedisAPI bfDebugAndForget(List<String> args)
```
    Variant of bfDebug(List) that ignores the result of the operation.
    This method subscribes on the result of bfDebug(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bfDebug(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bfExists
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bfExists(List<String> args)
```
    Redis command bfExists.
    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.
  - bfExistsAndAwait
```
public Response bfExistsAndAwait(List<String> args)
```
    Blocking variant of bfExists(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.
  - bfExistsAndForget
```
public RedisAPI bfExistsAndForget(List<String> args)
```
    Variant of bfExists(List) that ignores the result of the operation.
    This method subscribes on the result of bfExists(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bfExists(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bfInfo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bfInfo(List<String> args)
```
    Redis command bfInfo.
    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.
  - bfInfoAndAwait
```
public Response bfInfoAndAwait(List<String> args)
```
    Blocking variant of bfInfo(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.
  - bfInfoAndForget
```
public RedisAPI bfInfoAndForget(List<String> args)
```
    Variant of bfInfo(List) that ignores the result of the operation.
    This method subscribes on the result of bfInfo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bfInfo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bfInsert
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bfInsert(List<String> args)
```
    Redis command bfInsert.
    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.
  - bfInsertAndAwait
```
public Response bfInsertAndAwait(List<String> args)
```
    Blocking variant of bfInsert(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.
  - bfInsertAndForget
```
public RedisAPI bfInsertAndForget(List<String> args)
```
    Variant of bfInsert(List) that ignores the result of the operation.
    This method subscribes on the result of bfInsert(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bfInsert(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bfLoadchunk
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bfLoadchunk(List<String> args)
```
    Redis command bfLoadchunk.
    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.
  - bfLoadchunkAndAwait
```
public Response bfLoadchunkAndAwait(List<String> args)
```
    Blocking variant of bfLoadchunk(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.
  - bfLoadchunkAndForget
```
public RedisAPI bfLoadchunkAndForget(List<String> args)
```
    Variant of bfLoadchunk(List) that ignores the result of the operation.
    This method subscribes on the result of bfLoadchunk(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bfLoadchunk(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bfMadd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bfMadd(List<String> args)
```
    Redis command bfMadd.
    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.
  - bfMaddAndAwait
```
public Response bfMaddAndAwait(List<String> args)
```
    Blocking variant of bfMadd(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.
  - bfMaddAndForget
```
public RedisAPI bfMaddAndForget(List<String> args)
```
    Variant of bfMadd(List) that ignores the result of the operation.
    This method subscribes on the result of bfMadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bfMadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bfMexists
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bfMexists(List<String> args)
```
    Redis command bfMexists.
    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.
  - bfMexistsAndAwait
```
public Response bfMexistsAndAwait(List<String> args)
```
    Blocking variant of bfMexists(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.
  - bfMexistsAndForget
```
public RedisAPI bfMexistsAndForget(List<String> args)
```
    Variant of bfMexists(List) that ignores the result of the operation.
    This method subscribes on the result of bfMexists(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bfMexists(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bfReserve
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bfReserve(List<String> args)
```
    Redis command bfReserve.
    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.
  - bfReserveAndAwait
```
public Response bfReserveAndAwait(List<String> args)
```
    Blocking variant of bfReserve(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.
  - bfReserveAndForget
```
public RedisAPI bfReserveAndForget(List<String> args)
```
    Variant of bfReserve(List) that ignores the result of the operation.
    This method subscribes on the result of bfReserve(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bfReserve(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - bfScandump
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bfScandump(List<String> args)
```
    Redis command bfScandump.
    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.
  - bfScandumpAndAwait
```
public Response bfScandumpAndAwait(List<String> args)
```
    Blocking variant of bfScandump(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.
  - bfScandumpAndForget
```
public RedisAPI bfScandumpAndForget(List<String> args)
```
    Variant of bfScandump(List) that ignores the result of the operation.
    This method subscribes on the result of bfScandump(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bfScandump(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.
  - blmpop
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> blmpop(List<String> args)
```
    Redis command blmpop.
    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.
  - blmpopAndAwait
```
public Response blmpopAndAwait(List<String> args)
```
    Blocking variant of blmpop(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.
  - blmpopAndForget
```
public RedisAPI blmpopAndForget(List<String> args)
```
    Variant of blmpop(List) that ignores the result of the operation.
    This method subscribes on the result of blmpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from blmpop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    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.
  - bzmpop
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bzmpop(List<String> args)
```
    Redis command bzmpop.
    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.
  - bzmpopAndAwait
```
public Response bzmpopAndAwait(List<String> args)
```
    Blocking variant of bzmpop(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.
  - bzmpopAndForget
```
public RedisAPI bzmpopAndForget(List<String> args)
```
    Variant of bzmpop(List) that ignores the result of the operation.
    This method subscribes on the result of bzmpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bzmpop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    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.
  - cfAdd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfAdd(List<String> args)
```
    Redis command cfAdd.
    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.
  - cfAddAndAwait
```
public Response cfAddAndAwait(List<String> args)
```
    Blocking variant of cfAdd(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.
  - cfAddAndForget
```
public RedisAPI cfAddAndForget(List<String> args)
```
    Variant of cfAdd(List) that ignores the result of the operation.
    This method subscribes on the result of cfAdd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfAdd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfAddnx
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfAddnx(List<String> args)
```
    Redis command cfAddnx.
    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.
  - cfAddnxAndAwait
```
public Response cfAddnxAndAwait(List<String> args)
```
    Blocking variant of cfAddnx(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.
  - cfAddnxAndForget
```
public RedisAPI cfAddnxAndForget(List<String> args)
```
    Variant of cfAddnx(List) that ignores the result of the operation.
    This method subscribes on the result of cfAddnx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfAddnx(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfCompact
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfCompact(List<String> args)
```
    Redis command cfCompact.
    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.
  - cfCompactAndAwait
```
public Response cfCompactAndAwait(List<String> args)
```
    Blocking variant of cfCompact(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.
  - cfCompactAndForget
```
public RedisAPI cfCompactAndForget(List<String> args)
```
    Variant of cfCompact(List) that ignores the result of the operation.
    This method subscribes on the result of cfCompact(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfCompact(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfCount
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfCount(List<String> args)
```
    Redis command cfCount.
    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.
  - cfCountAndAwait
```
public Response cfCountAndAwait(List<String> args)
```
    Blocking variant of cfCount(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.
  - cfCountAndForget
```
public RedisAPI cfCountAndForget(List<String> args)
```
    Variant of cfCount(List) that ignores the result of the operation.
    This method subscribes on the result of cfCount(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfCount(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfDebug
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfDebug(List<String> args)
```
    Redis command cfDebug.
    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.
  - cfDebugAndAwait
```
public Response cfDebugAndAwait(List<String> args)
```
    Blocking variant of cfDebug(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.
  - cfDebugAndForget
```
public RedisAPI cfDebugAndForget(List<String> args)
```
    Variant of cfDebug(List) that ignores the result of the operation.
    This method subscribes on the result of cfDebug(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfDebug(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfDel
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfDel(List<String> args)
```
    Redis command cfDel.
    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.
  - cfDelAndAwait
```
public Response cfDelAndAwait(List<String> args)
```
    Blocking variant of cfDel(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.
  - cfDelAndForget
```
public RedisAPI cfDelAndForget(List<String> args)
```
    Variant of cfDel(List) that ignores the result of the operation.
    This method subscribes on the result of cfDel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfDel(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfExists
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfExists(List<String> args)
```
    Redis command cfExists.
    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.
  - cfExistsAndAwait
```
public Response cfExistsAndAwait(List<String> args)
```
    Blocking variant of cfExists(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.
  - cfExistsAndForget
```
public RedisAPI cfExistsAndForget(List<String> args)
```
    Variant of cfExists(List) that ignores the result of the operation.
    This method subscribes on the result of cfExists(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfExists(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfInfo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfInfo(List<String> args)
```
    Redis command cfInfo.
    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.
  - cfInfoAndAwait
```
public Response cfInfoAndAwait(List<String> args)
```
    Blocking variant of cfInfo(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.
  - cfInfoAndForget
```
public RedisAPI cfInfoAndForget(List<String> args)
```
    Variant of cfInfo(List) that ignores the result of the operation.
    This method subscribes on the result of cfInfo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfInfo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfInsert
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfInsert(List<String> args)
```
    Redis command cfInsert.
    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.
  - cfInsertAndAwait
```
public Response cfInsertAndAwait(List<String> args)
```
    Blocking variant of cfInsert(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.
  - cfInsertAndForget
```
public RedisAPI cfInsertAndForget(List<String> args)
```
    Variant of cfInsert(List) that ignores the result of the operation.
    This method subscribes on the result of cfInsert(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfInsert(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfInsertnx
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfInsertnx(List<String> args)
```
    Redis command cfInsertnx.
    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.
  - cfInsertnxAndAwait
```
public Response cfInsertnxAndAwait(List<String> args)
```
    Blocking variant of cfInsertnx(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.
  - cfInsertnxAndForget
```
public RedisAPI cfInsertnxAndForget(List<String> args)
```
    Variant of cfInsertnx(List) that ignores the result of the operation.
    This method subscribes on the result of cfInsertnx(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfInsertnx(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfLoadchunk
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfLoadchunk(List<String> args)
```
    Redis command cfLoadchunk.
    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.
  - cfLoadchunkAndAwait
```
public Response cfLoadchunkAndAwait(List<String> args)
```
    Blocking variant of cfLoadchunk(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.
  - cfLoadchunkAndForget
```
public RedisAPI cfLoadchunkAndForget(List<String> args)
```
    Variant of cfLoadchunk(List) that ignores the result of the operation.
    This method subscribes on the result of cfLoadchunk(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfLoadchunk(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfMexists
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfMexists(List<String> args)
```
    Redis command cfMexists.
    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.
  - cfMexistsAndAwait
```
public Response cfMexistsAndAwait(List<String> args)
```
    Blocking variant of cfMexists(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.
  - cfMexistsAndForget
```
public RedisAPI cfMexistsAndForget(List<String> args)
```
    Variant of cfMexists(List) that ignores the result of the operation.
    This method subscribes on the result of cfMexists(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfMexists(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfReserve
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfReserve(List<String> args)
```
    Redis command cfReserve.
    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.
  - cfReserveAndAwait
```
public Response cfReserveAndAwait(List<String> args)
```
    Blocking variant of cfReserve(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.
  - cfReserveAndForget
```
public RedisAPI cfReserveAndForget(List<String> args)
```
    Variant of cfReserve(List) that ignores the result of the operation.
    This method subscribes on the result of cfReserve(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfReserve(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cfScandump
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cfScandump(List<String> args)
```
    Redis command cfScandump.
    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.
  - cfScandumpAndAwait
```
public Response cfScandumpAndAwait(List<String> args)
```
    Blocking variant of cfScandump(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.
  - cfScandumpAndForget
```
public RedisAPI cfScandumpAndForget(List<String> args)
```
    Variant of cfScandump(List) that ignores the result of the operation.
    This method subscribes on the result of cfScandump(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cfScandump(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.
  - cmsIncrby
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cmsIncrby(List<String> args)
```
    Redis command cmsIncrby.
    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.
  - cmsIncrbyAndAwait
```
public Response cmsIncrbyAndAwait(List<String> args)
```
    Blocking variant of cmsIncrby(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.
  - cmsIncrbyAndForget
```
public RedisAPI cmsIncrbyAndForget(List<String> args)
```
    Variant of cmsIncrby(List) that ignores the result of the operation.
    This method subscribes on the result of cmsIncrby(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cmsIncrby(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cmsInfo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cmsInfo(List<String> args)
```
    Redis command cmsInfo.
    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.
  - cmsInfoAndAwait
```
public Response cmsInfoAndAwait(List<String> args)
```
    Blocking variant of cmsInfo(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.
  - cmsInfoAndForget
```
public RedisAPI cmsInfoAndForget(List<String> args)
```
    Variant of cmsInfo(List) that ignores the result of the operation.
    This method subscribes on the result of cmsInfo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cmsInfo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cmsInitbydim
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cmsInitbydim(List<String> args)
```
    Redis command cmsInitbydim.
    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.
  - cmsInitbydimAndAwait
```
public Response cmsInitbydimAndAwait(List<String> args)
```
    Blocking variant of cmsInitbydim(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.
  - cmsInitbydimAndForget
```
public RedisAPI cmsInitbydimAndForget(List<String> args)
```
    Variant of cmsInitbydim(List) that ignores the result of the operation.
    This method subscribes on the result of cmsInitbydim(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cmsInitbydim(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cmsInitbyprob
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cmsInitbyprob(List<String> args)
```
    Redis command cmsInitbyprob.
    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.
  - cmsInitbyprobAndAwait
```
public Response cmsInitbyprobAndAwait(List<String> args)
```
    Blocking variant of cmsInitbyprob(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.
  - cmsInitbyprobAndForget
```
public RedisAPI cmsInitbyprobAndForget(List<String> args)
```
    Variant of cmsInitbyprob(List) that ignores the result of the operation.
    This method subscribes on the result of cmsInitbyprob(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cmsInitbyprob(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cmsMerge
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cmsMerge(List<String> args)
```
    Redis command cmsMerge.
    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.
  - cmsMergeAndAwait
```
public Response cmsMergeAndAwait(List<String> args)
```
    Blocking variant of cmsMerge(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.
  - cmsMergeAndForget
```
public RedisAPI cmsMergeAndForget(List<String> args)
```
    Variant of cmsMerge(List) that ignores the result of the operation.
    This method subscribes on the result of cmsMerge(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cmsMerge(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - cmsQuery
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> cmsQuery(List<String> args)
```
    Redis command cmsQuery.
    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.
  - cmsQueryAndAwait
```
public Response cmsQueryAndAwait(List<String> args)
```
    Blocking variant of cmsQuery(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.
  - cmsQueryAndForget
```
public RedisAPI cmsQueryAndForget(List<String> args)
```
    Variant of cmsQuery(List) that ignores the result of the operation.
    This method subscribes on the result of cmsQuery(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from cmsQuery(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.
  - evalRo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> evalRo(List<String> args)
```
    Redis command evalRo.
    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.
  - evalRoAndAwait
```
public Response evalRoAndAwait(List<String> args)
```
    Blocking variant of evalRo(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.
  - evalRoAndForget
```
public RedisAPI evalRoAndForget(List<String> args)
```
    Variant of evalRo(List) that ignores the result of the operation.
    This method subscribes on the result of evalRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from evalRo(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.
  - evalshaRo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> evalshaRo(List<String> args)
```
    Redis command evalshaRo.
    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.
  - evalshaRoAndAwait
```
public Response evalshaRoAndAwait(List<String> args)
```
    Blocking variant of evalshaRo(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.
  - evalshaRoAndForget
```
public RedisAPI evalshaRoAndForget(List<String> args)
```
    Variant of evalshaRo(List) that ignores the result of the operation.
    This method subscribes on the result of evalshaRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from evalshaRo(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(List<String> args)
```
    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:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - expireAndAwait
```
public Response expireAndAwait(List<String> args)
```
    Blocking variant of expire(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.
  - expireAndForget
```
public RedisAPI expireAndForget(List<String> args)
```
    Variant of expire(List) that ignores the result of the operation.
    This method subscribes on the result of expire(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from expire(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - expireat
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> expireat(List<String> args)
```
    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:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - expireatAndAwait
```
public Response expireatAndAwait(List<String> args)
```
    Blocking variant of expireat(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.
  - expireatAndForget
```
public RedisAPI expireatAndForget(List<String> args)
```
    Variant of expireat(List) that ignores the result of the operation.
    This method subscribes on the result of expireat(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from expireat(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - expiretime
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> expiretime(String arg0)
```
    Redis command expiretime.
    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.
  - expiretimeAndAwait
```
public Response expiretimeAndAwait(String arg0)
```
    Blocking variant of expiretime(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.
  - expiretimeAndForget
```
public RedisAPI expiretimeAndForget(String arg0)
```
    Variant of expiretime(String) that ignores the result of the operation.
    This method subscribes on the result of expiretime(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from expiretime(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    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.
  - fcall
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> fcall(List<String> args)
```
    Redis command fcall.
    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.
  - fcallAndAwait
```
public Response fcallAndAwait(List<String> args)
```
    Blocking variant of fcall(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.
  - fcallAndForget
```
public RedisAPI fcallAndForget(List<String> args)
```
    Variant of fcall(List) that ignores the result of the operation.
    This method subscribes on the result of fcall(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from fcall(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - fcallRo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> fcallRo(List<String> args)
```
    Redis command fcallRo.
    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.
  - fcallRoAndAwait
```
public Response fcallRoAndAwait(List<String> args)
```
    Blocking variant of fcallRo(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.
  - fcallRoAndForget
```
public RedisAPI fcallRoAndForget(List<String> args)
```
    Variant of fcallRo(List) that ignores the result of the operation.
    This method subscribes on the result of fcallRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from fcallRo(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.
  - function
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> function(List<String> args)
```
    Redis command function.
    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.
  - functionAndAwait
```
public Response functionAndAwait(List<String> args)
```
    Blocking variant of function(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.
  - functionAndForget
```
public RedisAPI functionAndForget(List<String> args)
```
    Variant of function(List) that ignores the result of the operation.
    This method subscribes on the result of function(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from function(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.
  - graphBulk
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> graphBulk(List<String> args)
```
    Redis command graphBulk.
    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.
  - graphBulkAndAwait
```
public Response graphBulkAndAwait(List<String> args)
```
    Blocking variant of graphBulk(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.
  - graphBulkAndForget
```
public RedisAPI graphBulkAndForget(List<String> args)
```
    Variant of graphBulk(List) that ignores the result of the operation.
    This method subscribes on the result of graphBulk(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from graphBulk(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - graphConfig
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> graphConfig(List<String> args)
```
    Redis command graphConfig.
    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.
  - graphConfigAndAwait
```
public Response graphConfigAndAwait(List<String> args)
```
    Blocking variant of graphConfig(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.
  - graphConfigAndForget
```
public RedisAPI graphConfigAndForget(List<String> args)
```
    Variant of graphConfig(List) that ignores the result of the operation.
    This method subscribes on the result of graphConfig(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from graphConfig(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - graphDebug
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> graphDebug(List<String> args)
```
    Redis command graphDebug.
    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.
  - graphDebugAndAwait
```
public Response graphDebugAndAwait(List<String> args)
```
    Blocking variant of graphDebug(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.
  - graphDebugAndForget
```
public RedisAPI graphDebugAndForget(List<String> args)
```
    Variant of graphDebug(List) that ignores the result of the operation.
    This method subscribes on the result of graphDebug(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from graphDebug(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - graphDelete
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> graphDelete(List<String> args)
```
    Redis command graphDelete.
    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.
  - graphDeleteAndAwait
```
public Response graphDeleteAndAwait(List<String> args)
```
    Blocking variant of graphDelete(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.
  - graphDeleteAndForget
```
public RedisAPI graphDeleteAndForget(List<String> args)
```
    Variant of graphDelete(List) that ignores the result of the operation.
    This method subscribes on the result of graphDelete(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from graphDelete(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - graphExplain
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> graphExplain(List<String> args)
```
    Redis command graphExplain.
    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.
  - graphExplainAndAwait
```
public Response graphExplainAndAwait(List<String> args)
```
    Blocking variant of graphExplain(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.
  - graphExplainAndForget
```
public RedisAPI graphExplainAndForget(List<String> args)
```
    Variant of graphExplain(List) that ignores the result of the operation.
    This method subscribes on the result of graphExplain(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from graphExplain(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - graphList
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> graphList(List<String> args)
```
    Redis command graphList.
    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.
  - graphListAndAwait
```
public Response graphListAndAwait(List<String> args)
```
    Blocking variant of graphList(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.
  - graphListAndForget
```
public RedisAPI graphListAndForget(List<String> args)
```
    Variant of graphList(List) that ignores the result of the operation.
    This method subscribes on the result of graphList(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from graphList(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - graphProfile
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> graphProfile(List<String> args)
```
    Redis command graphProfile.
    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.
  - graphProfileAndAwait
```
public Response graphProfileAndAwait(List<String> args)
```
    Blocking variant of graphProfile(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.
  - graphProfileAndForget
```
public RedisAPI graphProfileAndForget(List<String> args)
```
    Variant of graphProfile(List) that ignores the result of the operation.
    This method subscribes on the result of graphProfile(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from graphProfile(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - graphQuery
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> graphQuery(List<String> args)
```
    Redis command graphQuery.
    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.
  - graphQueryAndAwait
```
public Response graphQueryAndAwait(List<String> args)
```
    Blocking variant of graphQuery(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.
  - graphQueryAndForget
```
public RedisAPI graphQueryAndForget(List<String> args)
```
    Variant of graphQuery(List) that ignores the result of the operation.
    This method subscribes on the result of graphQuery(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from graphQuery(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - graphRoQuery
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> graphRoQuery(List<String> args)
```
    Redis command graphRoQuery.
    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.
  - graphRoQueryAndAwait
```
public Response graphRoQueryAndAwait(List<String> args)
```
    Blocking variant of graphRoQuery(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.
  - graphRoQueryAndForget
```
public RedisAPI graphRoQueryAndForget(List<String> args)
```
    Variant of graphRoQuery(List) that ignores the result of the operation.
    This method subscribes on the result of graphRoQuery(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from graphRoQuery(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - graphSlowlog
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> graphSlowlog(List<String> args)
```
    Redis command graphSlowlog.
    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.
  - graphSlowlogAndAwait
```
public Response graphSlowlogAndAwait(List<String> args)
```
    Blocking variant of graphSlowlog(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.
  - graphSlowlogAndForget
```
public RedisAPI graphSlowlogAndForget(List<String> args)
```
    Variant of graphSlowlog(List) that ignores the result of the operation.
    This method subscribes on the result of graphSlowlog(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from graphSlowlog(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    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.
  - 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.
  - jsonArrappend
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonArrappend(List<String> args)
```
    Redis command jsonArrappend.
    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.
  - jsonArrappendAndAwait
```
public Response jsonArrappendAndAwait(List<String> args)
```
    Blocking variant of jsonArrappend(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.
  - jsonArrappendAndForget
```
public RedisAPI jsonArrappendAndForget(List<String> args)
```
    Variant of jsonArrappend(List) that ignores the result of the operation.
    This method subscribes on the result of jsonArrappend(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonArrappend(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonArrindex
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonArrindex(List<String> args)
```
    Redis command jsonArrindex.
    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.
  - jsonArrindexAndAwait
```
public Response jsonArrindexAndAwait(List<String> args)
```
    Blocking variant of jsonArrindex(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.
  - jsonArrindexAndForget
```
public RedisAPI jsonArrindexAndForget(List<String> args)
```
    Variant of jsonArrindex(List) that ignores the result of the operation.
    This method subscribes on the result of jsonArrindex(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonArrindex(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonArrinsert
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonArrinsert(List<String> args)
```
    Redis command jsonArrinsert.
    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.
  - jsonArrinsertAndAwait
```
public Response jsonArrinsertAndAwait(List<String> args)
```
    Blocking variant of jsonArrinsert(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.
  - jsonArrinsertAndForget
```
public RedisAPI jsonArrinsertAndForget(List<String> args)
```
    Variant of jsonArrinsert(List) that ignores the result of the operation.
    This method subscribes on the result of jsonArrinsert(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonArrinsert(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonArrlen
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonArrlen(List<String> args)
```
    Redis command jsonArrlen.
    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.
  - jsonArrlenAndAwait
```
public Response jsonArrlenAndAwait(List<String> args)
```
    Blocking variant of jsonArrlen(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.
  - jsonArrlenAndForget
```
public RedisAPI jsonArrlenAndForget(List<String> args)
```
    Variant of jsonArrlen(List) that ignores the result of the operation.
    This method subscribes on the result of jsonArrlen(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonArrlen(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonArrpop
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonArrpop(List<String> args)
```
    Redis command jsonArrpop.
    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.
  - jsonArrpopAndAwait
```
public Response jsonArrpopAndAwait(List<String> args)
```
    Blocking variant of jsonArrpop(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.
  - jsonArrpopAndForget
```
public RedisAPI jsonArrpopAndForget(List<String> args)
```
    Variant of jsonArrpop(List) that ignores the result of the operation.
    This method subscribes on the result of jsonArrpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonArrpop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonArrtrim
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonArrtrim(List<String> args)
```
    Redis command jsonArrtrim.
    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.
  - jsonArrtrimAndAwait
```
public Response jsonArrtrimAndAwait(List<String> args)
```
    Blocking variant of jsonArrtrim(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.
  - jsonArrtrimAndForget
```
public RedisAPI jsonArrtrimAndForget(List<String> args)
```
    Variant of jsonArrtrim(List) that ignores the result of the operation.
    This method subscribes on the result of jsonArrtrim(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonArrtrim(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonClear
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonClear(List<String> args)
```
    Redis command jsonClear.
    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.
  - jsonClearAndAwait
```
public Response jsonClearAndAwait(List<String> args)
```
    Blocking variant of jsonClear(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.
  - jsonClearAndForget
```
public RedisAPI jsonClearAndForget(List<String> args)
```
    Variant of jsonClear(List) that ignores the result of the operation.
    This method subscribes on the result of jsonClear(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonClear(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonDebug
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonDebug(List<String> args)
```
    Redis command jsonDebug.
    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.
  - jsonDebugAndAwait
```
public Response jsonDebugAndAwait(List<String> args)
```
    Blocking variant of jsonDebug(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.
  - jsonDebugAndForget
```
public RedisAPI jsonDebugAndForget(List<String> args)
```
    Variant of jsonDebug(List) that ignores the result of the operation.
    This method subscribes on the result of jsonDebug(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonDebug(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonDel
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonDel(List<String> args)
```
    Redis command jsonDel.
    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.
  - jsonDelAndAwait
```
public Response jsonDelAndAwait(List<String> args)
```
    Blocking variant of jsonDel(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.
  - jsonDelAndForget
```
public RedisAPI jsonDelAndForget(List<String> args)
```
    Variant of jsonDel(List) that ignores the result of the operation.
    This method subscribes on the result of jsonDel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonDel(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonForget
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonForget(List<String> args)
```
    Redis command jsonForget.
    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.
  - jsonForgetAndAwait
```
public Response jsonForgetAndAwait(List<String> args)
```
    Blocking variant of jsonForget(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.
  - jsonForgetAndForget
```
public RedisAPI jsonForgetAndForget(List<String> args)
```
    Variant of jsonForget(List) that ignores the result of the operation.
    This method subscribes on the result of jsonForget(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonForget(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonGet
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonGet(List<String> args)
```
    Redis command jsonGet.
    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.
  - jsonGetAndAwait
```
public Response jsonGetAndAwait(List<String> args)
```
    Blocking variant of jsonGet(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.
  - jsonGetAndForget
```
public RedisAPI jsonGetAndForget(List<String> args)
```
    Variant of jsonGet(List) that ignores the result of the operation.
    This method subscribes on the result of jsonGet(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonGet(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonMget
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonMget(List<String> args)
```
    Redis command jsonMget.
    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.
  - jsonMgetAndAwait
```
public Response jsonMgetAndAwait(List<String> args)
```
    Blocking variant of jsonMget(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.
  - jsonMgetAndForget
```
public RedisAPI jsonMgetAndForget(List<String> args)
```
    Variant of jsonMget(List) that ignores the result of the operation.
    This method subscribes on the result of jsonMget(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonMget(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonNumincrby
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonNumincrby(List<String> args)
```
    Redis command jsonNumincrby.
    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.
  - jsonNumincrbyAndAwait
```
public Response jsonNumincrbyAndAwait(List<String> args)
```
    Blocking variant of jsonNumincrby(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.
  - jsonNumincrbyAndForget
```
public RedisAPI jsonNumincrbyAndForget(List<String> args)
```
    Variant of jsonNumincrby(List) that ignores the result of the operation.
    This method subscribes on the result of jsonNumincrby(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonNumincrby(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonNummultby
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonNummultby(List<String> args)
```
    Redis command jsonNummultby.
    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.
  - jsonNummultbyAndAwait
```
public Response jsonNummultbyAndAwait(List<String> args)
```
    Blocking variant of jsonNummultby(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.
  - jsonNummultbyAndForget
```
public RedisAPI jsonNummultbyAndForget(List<String> args)
```
    Variant of jsonNummultby(List) that ignores the result of the operation.
    This method subscribes on the result of jsonNummultby(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonNummultby(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonNumpowby
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonNumpowby(List<String> args)
```
    Redis command jsonNumpowby.
    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.
  - jsonNumpowbyAndAwait
```
public Response jsonNumpowbyAndAwait(List<String> args)
```
    Blocking variant of jsonNumpowby(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.
  - jsonNumpowbyAndForget
```
public RedisAPI jsonNumpowbyAndForget(List<String> args)
```
    Variant of jsonNumpowby(List) that ignores the result of the operation.
    This method subscribes on the result of jsonNumpowby(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonNumpowby(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonObjkeys
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonObjkeys(List<String> args)
```
    Redis command jsonObjkeys.
    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.
  - jsonObjkeysAndAwait
```
public Response jsonObjkeysAndAwait(List<String> args)
```
    Blocking variant of jsonObjkeys(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.
  - jsonObjkeysAndForget
```
public RedisAPI jsonObjkeysAndForget(List<String> args)
```
    Variant of jsonObjkeys(List) that ignores the result of the operation.
    This method subscribes on the result of jsonObjkeys(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonObjkeys(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonObjlen
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonObjlen(List<String> args)
```
    Redis command jsonObjlen.
    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.
  - jsonObjlenAndAwait
```
public Response jsonObjlenAndAwait(List<String> args)
```
    Blocking variant of jsonObjlen(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.
  - jsonObjlenAndForget
```
public RedisAPI jsonObjlenAndForget(List<String> args)
```
    Variant of jsonObjlen(List) that ignores the result of the operation.
    This method subscribes on the result of jsonObjlen(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonObjlen(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonResp
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonResp(List<String> args)
```
    Redis command jsonResp.
    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.
  - jsonRespAndAwait
```
public Response jsonRespAndAwait(List<String> args)
```
    Blocking variant of jsonResp(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.
  - jsonRespAndForget
```
public RedisAPI jsonRespAndForget(List<String> args)
```
    Variant of jsonResp(List) that ignores the result of the operation.
    This method subscribes on the result of jsonResp(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonResp(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonSet
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonSet(List<String> args)
```
    Redis command jsonSet.
    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.
  - jsonSetAndAwait
```
public Response jsonSetAndAwait(List<String> args)
```
    Blocking variant of jsonSet(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.
  - jsonSetAndForget
```
public RedisAPI jsonSetAndForget(List<String> args)
```
    Variant of jsonSet(List) that ignores the result of the operation.
    This method subscribes on the result of jsonSet(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonSet(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonStrappend
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonStrappend(List<String> args)
```
    Redis command jsonStrappend.
    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.
  - jsonStrappendAndAwait
```
public Response jsonStrappendAndAwait(List<String> args)
```
    Blocking variant of jsonStrappend(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.
  - jsonStrappendAndForget
```
public RedisAPI jsonStrappendAndForget(List<String> args)
```
    Variant of jsonStrappend(List) that ignores the result of the operation.
    This method subscribes on the result of jsonStrappend(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonStrappend(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonStrlen
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonStrlen(List<String> args)
```
    Redis command jsonStrlen.
    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.
  - jsonStrlenAndAwait
```
public Response jsonStrlenAndAwait(List<String> args)
```
    Blocking variant of jsonStrlen(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.
  - jsonStrlenAndForget
```
public RedisAPI jsonStrlenAndForget(List<String> args)
```
    Variant of jsonStrlen(List) that ignores the result of the operation.
    This method subscribes on the result of jsonStrlen(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonStrlen(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonToggle
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonToggle(List<String> args)
```
    Redis command jsonToggle.
    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.
  - jsonToggleAndAwait
```
public Response jsonToggleAndAwait(List<String> args)
```
    Blocking variant of jsonToggle(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.
  - jsonToggleAndForget
```
public RedisAPI jsonToggleAndForget(List<String> args)
```
    Variant of jsonToggle(List) that ignores the result of the operation.
    This method subscribes on the result of jsonToggle(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonToggle(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - jsonType
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> jsonType(List<String> args)
```
    Redis command jsonType.
    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.
  - jsonTypeAndAwait
```
public Response jsonTypeAndAwait(List<String> args)
```
    Blocking variant of jsonType(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.
  - jsonTypeAndForget
```
public RedisAPI jsonTypeAndForget(List<String> args)
```
    Variant of jsonType(List) that ignores the result of the operation.
    This method subscribes on the result of jsonType(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from jsonType(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.
  - lcs
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> lcs(List<String> args)
```
    Redis command lcs.
    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.
  - lcsAndAwait
```
public Response lcsAndAwait(List<String> args)
```
    Blocking variant of lcs(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.
  - lcsAndForget
```
public RedisAPI lcsAndForget(List<String> args)
```
    Variant of lcs(List) that ignores the result of the operation.
    This method subscribes on the result of lcs(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lcs(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.
  - lmpop
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> lmpop(List<String> args)
```
    Redis command lmpop.
    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.
  - lmpopAndAwait
```
public Response lmpopAndAwait(List<String> args)
```
    Blocking variant of lmpop(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.
  - lmpopAndForget
```
public RedisAPI lmpopAndForget(List<String> args)
```
    Variant of lmpop(List) that ignores the result of the operation.
    This method subscribes on the result of lmpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from lmpop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    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(List<String> args)
```
    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:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pexpireAndAwait
```
public Response pexpireAndAwait(List<String> args)
```
    Blocking variant of pexpire(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.
  - pexpireAndForget
```
public RedisAPI pexpireAndForget(List<String> args)
```
    Variant of pexpire(List) that ignores the result of the operation.
    This method subscribes on the result of pexpire(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pexpire(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pexpireat
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> pexpireat(List<String> args)
```
    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:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pexpireatAndAwait
```
public Response pexpireatAndAwait(List<String> args)
```
    Blocking variant of pexpireat(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.
  - pexpireatAndForget
```
public RedisAPI pexpireatAndForget(List<String> args)
```
    Variant of pexpireat(List) that ignores the result of the operation.
    This method subscribes on the result of pexpireat(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pexpireat(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - pexpiretime
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> pexpiretime(String arg0)
```
    Redis command pexpiretime.
    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.
  - pexpiretimeAndAwait
```
public Response pexpiretimeAndAwait(String arg0)
```
    Blocking variant of pexpiretime(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.
  - pexpiretimeAndForget
```
public RedisAPI pexpiretimeAndForget(String arg0)
```
    Variant of pexpiretime(String) that ignores the result of the operation.
    This method subscribes on the result of pexpiretime(String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pexpiretime(String) but you don't need to compose it with other operations.
    
    Parameters:
    
    arg0 -
    
    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.
  - 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.
  - quit
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> quit(List<String> args)
```
    Redis command quit.
    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.
  - quitAndAwait
```
public Response quitAndAwait(List<String> args)
```
    Blocking variant of quit(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.
  - quitAndForget
```
public RedisAPI quitAndForget(List<String> args)
```
    Variant of quit(List) that ignores the result of the operation.
    This method subscribes on the result of quit(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from quit(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.
  - sintercard
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> sintercard(List<String> args)
```
    Redis command sintercard.
    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.
  - sintercardAndAwait
```
public Response sintercardAndAwait(List<String> args)
```
    Blocking variant of sintercard(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.
  - sintercardAndForget
```
public RedisAPI sintercardAndForget(List<String> args)
```
    Variant of sintercard(List) that ignores the result of the operation.
    This method subscribes on the result of sintercard(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from sintercard(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.
  - sortRo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> sortRo(List<String> args)
```
    Redis command sortRo.
    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.
  - sortRoAndAwait
```
public Response sortRoAndAwait(List<String> args)
```
    Blocking variant of sortRo(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.
  - sortRoAndForget
```
public RedisAPI sortRoAndForget(List<String> args)
```
    Variant of sortRo(List) that ignores the result of the operation.
    This method subscribes on the result of sortRo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from sortRo(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.
  - spublish
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> spublish(String arg0,
                                                 String arg1)
```
    Redis command spublish.
    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.
  - spublishAndAwait
```
public Response spublishAndAwait(String arg0,
                                 String arg1)
```
    Blocking variant of spublish(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.
  - spublishAndForget
```
public RedisAPI spublishAndForget(String arg0,
                                  String arg1)
```
    Variant of spublish(String,String) that ignores the result of the operation.
    This method subscribes on the result of spublish(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from spublish(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.
  - 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.
  - ssubscribe
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> ssubscribe(List<String> args)
```
    Redis command ssubscribe.
    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.
  - ssubscribeAndAwait
```
public Response ssubscribeAndAwait(List<String> args)
```
    Blocking variant of ssubscribe(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.
  - ssubscribeAndForget
```
public RedisAPI ssubscribeAndForget(List<String> args)
```
    Variant of ssubscribe(List) that ignores the result of the operation.
    This method subscribes on the result of ssubscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ssubscribe(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.
  - sunsubscribe
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> sunsubscribe(List<String> args)
```
    Redis command sunsubscribe.
    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.
  - sunsubscribeAndAwait
```
public Response sunsubscribeAndAwait(List<String> args)
```
    Blocking variant of sunsubscribe(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.
  - sunsubscribeAndForget
```
public RedisAPI sunsubscribeAndForget(List<String> args)
```
    Variant of sunsubscribe(List) that ignores the result of the operation.
    This method subscribes on the result of sunsubscribe(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from sunsubscribe(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.
  - timeseriesClusterset
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> timeseriesClusterset(List<String> args)
```
    Redis command timeseriesClusterset.
    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.
  - timeseriesClustersetAndAwait
```
public Response timeseriesClustersetAndAwait(List<String> args)
```
    Blocking variant of timeseriesClusterset(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.
  - timeseriesClustersetAndForget
```
public RedisAPI timeseriesClustersetAndForget(List<String> args)
```
    Variant of timeseriesClusterset(List) that ignores the result of the operation.
    This method subscribes on the result of timeseriesClusterset(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from timeseriesClusterset(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - timeseriesClustersetfromshard
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> timeseriesClustersetfromshard(List<String> args)
```
    Redis command timeseriesClustersetfromshard.
    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.
  - timeseriesClustersetfromshardAndAwait
```
public Response timeseriesClustersetfromshardAndAwait(List<String> args)
```
    Blocking variant of timeseriesClustersetfromshard(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.
  - timeseriesClustersetfromshardAndForget
```
public RedisAPI timeseriesClustersetfromshardAndForget(List<String> args)
```
    Variant of timeseriesClustersetfromshard(List) that ignores the result of the operation.
    This method subscribes on the result of timeseriesClustersetfromshard(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from timeseriesClustersetfromshard(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - timeseriesHello
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> timeseriesHello(List<String> args)
```
    Redis command timeseriesHello.
    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.
  - timeseriesHelloAndAwait
```
public Response timeseriesHelloAndAwait(List<String> args)
```
    Blocking variant of timeseriesHello(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.
  - timeseriesHelloAndForget
```
public RedisAPI timeseriesHelloAndForget(List<String> args)
```
    Variant of timeseriesHello(List) that ignores the result of the operation.
    This method subscribes on the result of timeseriesHello(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from timeseriesHello(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - timeseriesInfocluster
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> timeseriesInfocluster(List<String> args)
```
    Redis command timeseriesInfocluster.
    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.
  - timeseriesInfoclusterAndAwait
```
public Response timeseriesInfoclusterAndAwait(List<String> args)
```
    Blocking variant of timeseriesInfocluster(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.
  - timeseriesInfoclusterAndForget
```
public RedisAPI timeseriesInfoclusterAndForget(List<String> args)
```
    Variant of timeseriesInfocluster(List) that ignores the result of the operation.
    This method subscribes on the result of timeseriesInfocluster(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from timeseriesInfocluster(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - timeseriesInnercommunication
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> timeseriesInnercommunication(List<String> args)
```
    Redis command timeseriesInnercommunication.
    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.
  - timeseriesInnercommunicationAndAwait
```
public Response timeseriesInnercommunicationAndAwait(List<String> args)
```
    Blocking variant of timeseriesInnercommunication(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.
  - timeseriesInnercommunicationAndForget
```
public RedisAPI timeseriesInnercommunicationAndForget(List<String> args)
```
    Variant of timeseriesInnercommunication(List) that ignores the result of the operation.
    This method subscribes on the result of timeseriesInnercommunication(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from timeseriesInnercommunication(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - timeseriesNetworktest
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> timeseriesNetworktest(List<String> args)
```
    Redis command timeseriesNetworktest.
    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.
  - timeseriesNetworktestAndAwait
```
public Response timeseriesNetworktestAndAwait(List<String> args)
```
    Blocking variant of timeseriesNetworktest(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.
  - timeseriesNetworktestAndForget
```
public RedisAPI timeseriesNetworktestAndForget(List<String> args)
```
    Variant of timeseriesNetworktest(List) that ignores the result of the operation.
    This method subscribes on the result of timeseriesNetworktest(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from timeseriesNetworktest(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - timeseriesRefreshcluster
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> timeseriesRefreshcluster(List<String> args)
```
    Redis command timeseriesRefreshcluster.
    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.
  - timeseriesRefreshclusterAndAwait
```
public Response timeseriesRefreshclusterAndAwait(List<String> args)
```
    Blocking variant of timeseriesRefreshcluster(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.
  - timeseriesRefreshclusterAndForget
```
public RedisAPI timeseriesRefreshclusterAndForget(List<String> args)
```
    Variant of timeseriesRefreshcluster(List) that ignores the result of the operation.
    This method subscribes on the result of timeseriesRefreshcluster(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from timeseriesRefreshcluster(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - topkAdd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> topkAdd(List<String> args)
```
    Redis command topkAdd.
    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.
  - topkAddAndAwait
```
public Response topkAddAndAwait(List<String> args)
```
    Blocking variant of topkAdd(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.
  - topkAddAndForget
```
public RedisAPI topkAddAndForget(List<String> args)
```
    Variant of topkAdd(List) that ignores the result of the operation.
    This method subscribes on the result of topkAdd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from topkAdd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - topkCount
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> topkCount(List<String> args)
```
    Redis command topkCount.
    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.
  - topkCountAndAwait
```
public Response topkCountAndAwait(List<String> args)
```
    Blocking variant of topkCount(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.
  - topkCountAndForget
```
public RedisAPI topkCountAndForget(List<String> args)
```
    Variant of topkCount(List) that ignores the result of the operation.
    This method subscribes on the result of topkCount(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from topkCount(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - topkIncrby
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> topkIncrby(List<String> args)
```
    Redis command topkIncrby.
    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.
  - topkIncrbyAndAwait
```
public Response topkIncrbyAndAwait(List<String> args)
```
    Blocking variant of topkIncrby(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.
  - topkIncrbyAndForget
```
public RedisAPI topkIncrbyAndForget(List<String> args)
```
    Variant of topkIncrby(List) that ignores the result of the operation.
    This method subscribes on the result of topkIncrby(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from topkIncrby(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - topkInfo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> topkInfo(List<String> args)
```
    Redis command topkInfo.
    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.
  - topkInfoAndAwait
```
public Response topkInfoAndAwait(List<String> args)
```
    Blocking variant of topkInfo(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.
  - topkInfoAndForget
```
public RedisAPI topkInfoAndForget(List<String> args)
```
    Variant of topkInfo(List) that ignores the result of the operation.
    This method subscribes on the result of topkInfo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from topkInfo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - topkList
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> topkList(List<String> args)
```
    Redis command topkList.
    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.
  - topkListAndAwait
```
public Response topkListAndAwait(List<String> args)
```
    Blocking variant of topkList(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.
  - topkListAndForget
```
public RedisAPI topkListAndForget(List<String> args)
```
    Variant of topkList(List) that ignores the result of the operation.
    This method subscribes on the result of topkList(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from topkList(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - topkQuery
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> topkQuery(List<String> args)
```
    Redis command topkQuery.
    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.
  - topkQueryAndAwait
```
public Response topkQueryAndAwait(List<String> args)
```
    Blocking variant of topkQuery(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.
  - topkQueryAndForget
```
public RedisAPI topkQueryAndForget(List<String> args)
```
    Variant of topkQuery(List) that ignores the result of the operation.
    This method subscribes on the result of topkQuery(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from topkQuery(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - topkReserve
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> topkReserve(List<String> args)
```
    Redis command topkReserve.
    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.
  - topkReserveAndAwait
```
public Response topkReserveAndAwait(List<String> args)
```
    Blocking variant of topkReserve(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.
  - topkReserveAndForget
```
public RedisAPI topkReserveAndForget(List<String> args)
```
    Variant of topkReserve(List) that ignores the result of the operation.
    This method subscribes on the result of topkReserve(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from topkReserve(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    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.
  - tsAdd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsAdd(List<String> args)
```
    Redis command tsAdd.
    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.
  - tsAddAndAwait
```
public Response tsAddAndAwait(List<String> args)
```
    Blocking variant of tsAdd(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.
  - tsAddAndForget
```
public RedisAPI tsAddAndForget(List<String> args)
```
    Variant of tsAdd(List) that ignores the result of the operation.
    This method subscribes on the result of tsAdd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsAdd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsAlter
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsAlter(List<String> args)
```
    Redis command tsAlter.
    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.
  - tsAlterAndAwait
```
public Response tsAlterAndAwait(List<String> args)
```
    Blocking variant of tsAlter(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.
  - tsAlterAndForget
```
public RedisAPI tsAlterAndForget(List<String> args)
```
    Variant of tsAlter(List) that ignores the result of the operation.
    This method subscribes on the result of tsAlter(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsAlter(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsCreate
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsCreate(List<String> args)
```
    Redis command tsCreate.
    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.
  - tsCreateAndAwait
```
public Response tsCreateAndAwait(List<String> args)
```
    Blocking variant of tsCreate(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.
  - tsCreateAndForget
```
public RedisAPI tsCreateAndForget(List<String> args)
```
    Variant of tsCreate(List) that ignores the result of the operation.
    This method subscribes on the result of tsCreate(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsCreate(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsCreaterule
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsCreaterule(List<String> args)
```
    Redis command tsCreaterule.
    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.
  - tsCreateruleAndAwait
```
public Response tsCreateruleAndAwait(List<String> args)
```
    Blocking variant of tsCreaterule(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.
  - tsCreateruleAndForget
```
public RedisAPI tsCreateruleAndForget(List<String> args)
```
    Variant of tsCreaterule(List) that ignores the result of the operation.
    This method subscribes on the result of tsCreaterule(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsCreaterule(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsDecrby
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsDecrby(List<String> args)
```
    Redis command tsDecrby.
    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.
  - tsDecrbyAndAwait
```
public Response tsDecrbyAndAwait(List<String> args)
```
    Blocking variant of tsDecrby(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.
  - tsDecrbyAndForget
```
public RedisAPI tsDecrbyAndForget(List<String> args)
```
    Variant of tsDecrby(List) that ignores the result of the operation.
    This method subscribes on the result of tsDecrby(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsDecrby(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsDel
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsDel(List<String> args)
```
    Redis command tsDel.
    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.
  - tsDelAndAwait
```
public Response tsDelAndAwait(List<String> args)
```
    Blocking variant of tsDel(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.
  - tsDelAndForget
```
public RedisAPI tsDelAndForget(List<String> args)
```
    Variant of tsDel(List) that ignores the result of the operation.
    This method subscribes on the result of tsDel(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsDel(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsDeleterule
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsDeleterule(List<String> args)
```
    Redis command tsDeleterule.
    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.
  - tsDeleteruleAndAwait
```
public Response tsDeleteruleAndAwait(List<String> args)
```
    Blocking variant of tsDeleterule(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.
  - tsDeleteruleAndForget
```
public RedisAPI tsDeleteruleAndForget(List<String> args)
```
    Variant of tsDeleterule(List) that ignores the result of the operation.
    This method subscribes on the result of tsDeleterule(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsDeleterule(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsGet
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsGet(List<String> args)
```
    Redis command tsGet.
    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.
  - tsGetAndAwait
```
public Response tsGetAndAwait(List<String> args)
```
    Blocking variant of tsGet(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.
  - tsGetAndForget
```
public RedisAPI tsGetAndForget(List<String> args)
```
    Variant of tsGet(List) that ignores the result of the operation.
    This method subscribes on the result of tsGet(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsGet(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsIncrby
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsIncrby(List<String> args)
```
    Redis command tsIncrby.
    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.
  - tsIncrbyAndAwait
```
public Response tsIncrbyAndAwait(List<String> args)
```
    Blocking variant of tsIncrby(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.
  - tsIncrbyAndForget
```
public RedisAPI tsIncrbyAndForget(List<String> args)
```
    Variant of tsIncrby(List) that ignores the result of the operation.
    This method subscribes on the result of tsIncrby(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsIncrby(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsInfo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsInfo(List<String> args)
```
    Redis command tsInfo.
    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.
  - tsInfoAndAwait
```
public Response tsInfoAndAwait(List<String> args)
```
    Blocking variant of tsInfo(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.
  - tsInfoAndForget
```
public RedisAPI tsInfoAndForget(List<String> args)
```
    Variant of tsInfo(List) that ignores the result of the operation.
    This method subscribes on the result of tsInfo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsInfo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsMadd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsMadd(List<String> args)
```
    Redis command tsMadd.
    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.
  - tsMaddAndAwait
```
public Response tsMaddAndAwait(List<String> args)
```
    Blocking variant of tsMadd(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.
  - tsMaddAndForget
```
public RedisAPI tsMaddAndForget(List<String> args)
```
    Variant of tsMadd(List) that ignores the result of the operation.
    This method subscribes on the result of tsMadd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsMadd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsMget
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsMget(List<String> args)
```
    Redis command tsMget.
    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.
  - tsMgetAndAwait
```
public Response tsMgetAndAwait(List<String> args)
```
    Blocking variant of tsMget(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.
  - tsMgetAndForget
```
public RedisAPI tsMgetAndForget(List<String> args)
```
    Variant of tsMget(List) that ignores the result of the operation.
    This method subscribes on the result of tsMget(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsMget(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsMrange
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsMrange(List<String> args)
```
    Redis command tsMrange.
    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.
  - tsMrangeAndAwait
```
public Response tsMrangeAndAwait(List<String> args)
```
    Blocking variant of tsMrange(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.
  - tsMrangeAndForget
```
public RedisAPI tsMrangeAndForget(List<String> args)
```
    Variant of tsMrange(List) that ignores the result of the operation.
    This method subscribes on the result of tsMrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsMrange(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsMrevrange
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsMrevrange(List<String> args)
```
    Redis command tsMrevrange.
    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.
  - tsMrevrangeAndAwait
```
public Response tsMrevrangeAndAwait(List<String> args)
```
    Blocking variant of tsMrevrange(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.
  - tsMrevrangeAndForget
```
public RedisAPI tsMrevrangeAndForget(List<String> args)
```
    Variant of tsMrevrange(List) that ignores the result of the operation.
    This method subscribes on the result of tsMrevrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsMrevrange(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsQueryindex
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsQueryindex(List<String> args)
```
    Redis command tsQueryindex.
    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.
  - tsQueryindexAndAwait
```
public Response tsQueryindexAndAwait(List<String> args)
```
    Blocking variant of tsQueryindex(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.
  - tsQueryindexAndForget
```
public RedisAPI tsQueryindexAndForget(List<String> args)
```
    Variant of tsQueryindex(List) that ignores the result of the operation.
    This method subscribes on the result of tsQueryindex(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsQueryindex(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsRange
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsRange(List<String> args)
```
    Redis command tsRange.
    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.
  - tsRangeAndAwait
```
public Response tsRangeAndAwait(List<String> args)
```
    Blocking variant of tsRange(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.
  - tsRangeAndForget
```
public RedisAPI tsRangeAndForget(List<String> args)
```
    Variant of tsRange(List) that ignores the result of the operation.
    This method subscribes on the result of tsRange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsRange(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tsRevrange
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tsRevrange(List<String> args)
```
    Redis command tsRevrange.
    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.
  - tsRevrangeAndAwait
```
public Response tsRevrangeAndAwait(List<String> args)
```
    Blocking variant of tsRevrange(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.
  - tsRevrangeAndForget
```
public RedisAPI tsRevrangeAndForget(List<String> args)
```
    Variant of tsRevrange(List) that ignores the result of the operation.
    This method subscribes on the result of tsRevrange(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tsRevrange(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(List<String> args)
```
    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:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - xsetidAndAwait
```
public Response xsetidAndAwait(List<String> args)
```
    Blocking variant of xsetid(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.
  - xsetidAndForget
```
public RedisAPI xsetidAndForget(List<String> args)
```
    Variant of xsetid(List) that ignores the result of the operation.
    This method subscribes on the result of xsetid(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from xsetid(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    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.
  - zintercard
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> zintercard(List<String> args)
```
    Redis command zintercard.
    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.
  - zintercardAndAwait
```
public Response zintercardAndAwait(List<String> args)
```
    Blocking variant of zintercard(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.
  - zintercardAndForget
```
public RedisAPI zintercardAndForget(List<String> args)
```
    Variant of zintercard(List) that ignores the result of the operation.
    This method subscribes on the result of zintercard(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zintercard(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.
  - zmpop
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> zmpop(List<String> args)
```
    Redis command zmpop.
    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.
  - zmpopAndAwait
```
public Response zmpopAndAwait(List<String> args)
```
    Blocking variant of zmpop(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.
  - zmpopAndForget
```
public RedisAPI zmpopAndForget(List<String> args)
```
    Variant of zmpop(List) that ignores the result of the operation.
    This method subscribes on the result of zmpop(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from zmpop(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    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

ftAdd

ftAddAndAwait

ftAddAndForget

ftAggregate

ftAggregateAndAwait

ftAggregateAndForget

ftAliasadd

ftAliasaddAndAwait

ftAliasaddAndForget

ftAliasdel

ftAliasdelAndAwait

ftAliasdelAndForget

ftAliasupdate

ftAliasupdateAndAwait

ftAliasupdateAndForget

ftAlter

ftAlterAndAwait

ftAlterAndForget

ftConfig

ftConfigAndAwait

ftConfigAndForget

ftCreate

ftCreateAndAwait

ftCreateAndForget

ftCursor

ftCursorAndAwait

ftCursorAndForget

ftDebug

ftDebugAndAwait

ftDebugAndForget

ftDel

ftDelAndAwait

ftDelAndForget

ftDictadd

ftDictaddAndAwait

ftDictaddAndForget

ftDictdel

ftDictdelAndAwait

ftDictdelAndForget

ftDictdump

ftDictdumpAndAwait

ftDictdumpAndForget

ftDrop

ftDropAndAwait

ftDropAndForget

ftDropindex

ftDropindexAndAwait

ftDropindexAndForget

ftExplain

ftExplainAndAwait

ftExplainAndForget

ftExplaincli

ftExplaincliAndAwait

ftExplaincliAndForget

ftGet

ftGetAndAwait

ftGetAndForget

ftInfo

ftInfoAndAwait

ftInfoAndForget

ftMget

ftMgetAndAwait

ftMgetAndForget

ftProfile