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)`	A container for Access List Control commands.
`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)`	Append a value to a key.
`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()`	Sent by cluster clients after an -ASK redirect.
`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)`	Authenticate to the server.
`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 BF.ADD.
`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>`	`bfCard(List<String> args)`	Redis command BF.CARD.
`Response`	`bfCardAndAwait(List<String> args)`	Blocking variant of `bfCard(List)`.
`RedisAPI`	`bfCardAndForget(List<String> args)`	Variant of `bfCard(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`bfDebug(List<String> args)`	Redis command BF.DEBUG.
`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 BF.EXISTS.
`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 BF.INFO.
`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 BF.INSERT.
`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 BF.LOADCHUNK.
`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 BF.MADD.
`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 BF.MEXISTS.
`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 BF.RESERVE.
`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 BF.SCANDUMP.
`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()`	Asynchronously rewrite the append-only file.
`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)`	Asynchronously save the dataset to disk.
`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)`	Count set bits in a string.
`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)`	Perform arbitrary bitfield integer operations on strings.
`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)`	Perform arbitrary bitfield integer operations on strings.
`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)`	Perform bitwise operations between strings.
`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)`	Find first bit set or clear in a string.
`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)`	Pop an element from a list, push it to another list and return it; or block until one is available.
`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)`	Pop elements from a list, or block until one is available.
`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)`	Remove and get the first element in a list, or block until one is available.
`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)`	Remove and get the last element in a list, or block until one is available.
`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)`	Pop an element from a list, push it to another list and return it; or block until one is available.
`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)`	Remove and return members with scores in a sorted set or block until one is available.
`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)`	Remove and return the member with the highest score from one or more sorted sets, or block until one is available.
`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)`	Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.
`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 CF.ADD.
`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 CF.ADDNX.
`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 CF.COMPACT.
`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 CF.COUNT.
`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 CF.DEBUG.
`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 CF.DEL.
`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 CF.EXISTS.
`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 CF.INFO.
`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 CF.INSERT.
`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 CF.INSERTNX.
`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 CF.LOADCHUNK.
`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 CF.MEXISTS.
`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 CF.RESERVE.
`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 CF.SCANDUMP.
`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)`	A container for client connection commands.
`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)`	A container for cluster commands.
`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 CMS.INCRBY.
`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 CMS.INFO.
`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 CMS.INITBYDIM.
`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 CMS.INITBYPROB.
`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 CMS.MERGE.
`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 CMS.QUERY.
`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)`	Get array of Redis command details.
`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)`	A container for server configuration commands.
`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)`	Copy a key.
`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()`	Return the number of keys in the selected database.
`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)`	A container for debugging commands.
`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)`	Decrement the integer value of a key by one.
`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)`	Decrement the integer value of a key by the given number.
`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)`	Delete a key.
`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()`	Discard all commands issued after MULTI.
`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)`	Return a serialized version of the value stored at the specified key.
`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)`	Echo the given string.
`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)`	Execute a Lua script server side.
`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)`	Execute a read-only Lua script server side.
`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)`	Execute a Lua script server side.
`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)`	Execute a read-only Lua script server side.
`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()`	Execute all commands issued after MULTI.
`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)`	Determine if a key 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)`	Set a key's time to live in seconds.
`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)`	Set the expiration for a key as a UNIX timestamp.
`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)`	Get the expiration Unix timestamp for a key.
`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)`	Start a coordinated failover between this server and one of its replicas.
`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)`	Invoke a function.
`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)`	Invoke a read-only function.
`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)`	Remove all keys from all databases.
`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)`	Remove all keys from the current database.
`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 FT.ADD.
`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 FT.AGGREGATE.
`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 FT.ALIASADD.
`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 FT.
`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 FT.ALIASDEL.
`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 FT.
`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 FT.ALIASUPDATE.
`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 FT.ALTER.
`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 FT.
`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 FT.CONFIG.
`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 FT.CREATE.
`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 FT.
`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 FT.CURSOR.
`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 FT.DEBUG.
`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 FT.DEL.
`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 FT.DICTADD.
`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 FT.DICTDEL.
`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 FT.DICTDUMP.
`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 FT.DROP.
`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 FT.
`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 FT.DROPINDEX.
`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 FT.
`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 FT.EXPLAIN.
`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 FT.EXPLAINCLI.
`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 FT.GET.
`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 FT.INFO.
`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 FT.
`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 FT.MGET.
`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 FT.PROFILE.
`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 FT.SAFEADD.
`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 FT.SEARCH.
`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 FT.SPELLCHECK.
`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 FT.SUGADD.
`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 FT.SUGDEL.
`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 FT.SUGGET.
`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 FT.SUGLEN.
`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 FT.SYNADD.
`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 FT.SYNDUMP.
`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 FT.SYNUPDATE.
`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 FT.TAGVALS.
`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)`	A container for function commands.
`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)`	Add one or more geospatial items in the geospatial index represented using a sorted set.
`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)`	Returns the distance between two members of a geospatial index.
`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)`	Returns members of a geospatial index as standard geohash strings.
`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)`	Returns longitude and latitude of members of a geospatial index.
`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)`	Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
`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)`	Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
`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)`	A read-only variant for GEORADIUSBYMEMBER.
`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)`	A read-only variant for GEORADIUS.
`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)`	Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
`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)`	Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.
`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)`	Get the value of a key.
`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)`	Returns the bit value at offset in the string value stored at key.
`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)`	Get the value of a key and delete the key.
`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)`	Get the value of a key and optionally set its expiration.
`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)`	Get a substring of the string stored at a key.
`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)`	Set the string value of a key and return its old value.
`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 GRAPH.BULK.
`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 GRAPH.CONFIG.
`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 GRAPH.DEBUG.
`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 GRAPH.DELETE.
`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 GRAPH.EXPLAIN.
`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 GRAPH.LIST.
`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 GRAPH.PROFILE.
`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 GRAPH.QUERY.
`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 GRAPH.RO_QUERY.
`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 GRAPH.SLOWLOG.
`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)`	Delete one or more hash fields.
`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)`	Handshake with Redis.
`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)`	Determine if a hash field exists.
`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)`	Get the value of a hash field.
`io.smallrye.mutiny.Uni<Response>`	`hgetall(String arg0)`	Get all the fields and values in a hash.
`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)`	Increment the integer value of a hash field by the given number.
`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)`	Increment the float value of a hash field by the given amount.
`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)`	Get all the fields in a hash.
`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)`	Get the number of fields in a hash.
`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)`	Get the values of all the given hash fields.
`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)`	Set multiple hash fields to multiple values.
`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)`	Get one or multiple random fields from a hash.
`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)`	Incrementally iterate hash fields and associated values.
`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)`	Set the string value of a hash field.
`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)`	Set the value of a hash field, only if the field does not exist.
`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)`	Get the length of the value of a hash field.
`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)`	Get all the values in a hash.
`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)`	Increment the integer value of a key by one.
`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)`	Increment the integer value of a key by the given amount.
`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)`	Increment the float value of a key by the given amount.
`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)`	Get information and statistics about the server.
`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 JSON.ARRAPPEND.
`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 JSON.ARRINDEX.
`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 JSON.ARRINSERT.
`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 JSON.ARRLEN.
`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 JSON.ARRPOP.
`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 JSON.ARRTRIM.
`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 JSON.CLEAR.
`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 JSON.DEBUG.
`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 JSON.DEL.
`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 JSON.FORGET.
`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 JSON.GET.
`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 JSON.MGET.
`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 JSON.NUMINCRBY.
`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 JSON.NUMMULTBY.
`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 JSON.NUMPOWBY.
`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 JSON.OBJKEYS.
`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 JSON.OBJLEN.
`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 JSON.RESP.
`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 JSON.SET.
`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 JSON.STRAPPEND.
`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 JSON.STRLEN.
`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 JSON.TOGGLE.
`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 JSON.TYPE.
`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)`	Find all keys matching the given pattern.
`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()`	Get the UNIX time stamp of the last successful save to disk.
`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)`	A container for latency diagnostics commands.
`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)`	Find longest common substring.
`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)`	Get an element from a list by its index.
`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)`	Insert an element before or after another element in a list.
`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)`	Get the length of a list.
`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)`	Pop an element from a list, push it to another list and return it.
`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)`	Pop elements from a list.
`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)`	Display some computer art and the Redis version.
`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)`	Remove and get the first elements in a list.
`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)`	Return the index of matching elements on a list.
`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)`	Prepend one or multiple elements to a list.
`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)`	Prepend an element to a list, only if the list exists.
`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)`	Get a range of elements from a list.
`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)`	Remove elements from a list.
`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)`	Set the value of an element in a list by its index.
`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)`	Trim a list to the specified range.
`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)`	A container for memory diagnostics commands.
`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)`	Get the values of all the given keys.
`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)`	Atomically transfer a key from a Redis instance to another one.
`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)`	A container for module commands.
`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()`	Listen for all requests received by the server in real time.
`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)`	Move a key to another database.
`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)`	Set multiple keys to multiple values.
`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)`	Set multiple keys to multiple values, only if none of the keys exist.
`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()`	Mark the start of a transaction block.
`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)`	A container for object introspection commands.
`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)`	Remove the expiration from a key.
`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)`	Set a key's time to live in milliseconds.
`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)`	Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`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)`	Get the expiration Unix timestamp for a key in milliseconds.
`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)`	Adds the specified elements to the specified HyperLogLog.
`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)`	Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
`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(String arg0, String arg1)`	Internal commands for debugging HyperLogLog values.
`Response`	`pfdebugAndAwait(String arg0, String arg1)`	Blocking variant of `pfdebug(String,String)`.
`RedisAPI`	`pfdebugAndForget(String arg0, String arg1)`	Variant of `pfdebug(String,String)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`pfmerge(List<String> args)`	Merge N different HyperLogLogs into a single one.
`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()`	An internal command for testing HyperLogLog values.
`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)`	Ping the server.
`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)`	Set the value and expiration in milliseconds of a key.
`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)`	Listen for messages published to channels matching the given patterns.
`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)`	Internal command used for replication.
`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)`	Get the time to live for a key in milliseconds.
`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)`	Post a message to a channel.
`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)`	A container for Pub/Sub commands.
`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)`	Stop listening for messages posted to channels matching the given patterns.
`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)`	Close the connection.
`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()`	Return a random key from the keyspace.
`Response`	`randomkeyAndAwait()`	Blocking variant of `randomkey()`.
`RedisAPI`	`randomkeyAndForget()`	Variant of `randomkey()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`readonly()`	Enables read queries for a connection to a cluster replica node.
`Response`	`readonlyAndAwait()`	Blocking variant of `readonly()`.
`RedisAPI`	`readonlyAndForget()`	Variant of `readonly()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`readwrite()`	Disables read queries for a connection to a cluster replica node.
`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)`	Rename a key.
`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)`	Rename a key, only if the new key does not exist.
`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)`	An internal command for configuring the replication stream.
`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)`	Make the server a replica of another instance, or promote it as master.
`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()`	Reset the connection.
`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)`	Create a key using the provided serialized value, previously obtained using DUMP.
`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)`	An internal command for migrating keys in a cluster.
`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()`	Return the role of the instance in the context of replication.
`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)`	Remove and get the last elements in a list.
`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)`	Remove the last element in a list, prepend it to another list and return it.
`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)`	Append one or multiple elements to a list.
`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)`	Append an element to a list, only if the list exists.
`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)`	Add one or more members to a set.
`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()`	Synchronously save the dataset to disk.
`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)`	Incrementally iterate the keys space.
`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)`	Get the number of members in a set.
`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)`	A container for Lua scripts management commands.
`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)`	Subtract multiple sets.
`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)`	Subtract multiple sets and store the resulting set in a key.
`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)`	Change the selected database for the current connection.
`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)`	Set the string value of a key.
`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)`	Sets or clears the bit at offset in the string value stored at key.
`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)`	Set the value and expiration of a key.
`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)`	Set the value of a key, only if the key does not exist.
`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)`	Overwrite part of a string at key starting at the specified offset.
`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)`	Synchronously save the dataset to disk and then shut down the server.
`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)`	Intersect multiple sets.
`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)`	Intersect multiple sets and return the cardinality of the result.
`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)`	Intersect multiple sets and store the resulting set in a key.
`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)`	Determine if a given value is a member of a set.
`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)`	Make the server a replica of another instance, or promote it as master.
`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)`	A container for slow log commands.
`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)`	Get all the members in a set.
`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)`	Returns the membership associated with the given elements for a set.
`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)`	Move a member from one set to another.
`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)`	Sort the elements in a list, set or sorted set.
`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)`	Sort the elements in a list, set or sorted set.
`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)`	Remove and return one or multiple random members from a set.
`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)`	Post a message to a shard channel.
`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)`	Get one or multiple random members from a set.
`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)`	Remove one or more members from a set.
`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)`	Incrementally iterate Set elements.
`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)`	Listen for messages published to the given shard channels.
`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)`	Get the length of the value stored in a key.
`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)`	Listen for messages published to the given channels.
`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)`	Get a substring of the string stored at a key.
`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)`	Add multiple sets.
`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)`	Add multiple sets and store the resulting set in a key.
`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)`	Stop listening for messages posted to the given shard channels.
`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)`	Swaps two Redis databases.
`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()`	Internal command used for replication.
`Response`	`syncAndAwait()`	Blocking variant of `sync()`.
`RedisAPI`	`syncAndForget()`	Variant of `sync()` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestAdd(List<String> args)`	Redis command TDIGEST.ADD.
`Response`	`tdigestAddAndAwait(List<String> args)`	Blocking variant of `tdigestAdd(List)`.
`RedisAPI`	`tdigestAddAndForget(List<String> args)`	Variant of `tdigestAdd(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestByrank(List<String> args)`	Redis command TDIGEST.BYRANK.
`Response`	`tdigestByrankAndAwait(List<String> args)`	Blocking variant of `tdigestByrank(List)`.
`RedisAPI`	`tdigestByrankAndForget(List<String> args)`	Variant of `tdigestByrank(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestByrevrank(List<String> args)`	Redis command TDIGEST.BYREVRANK.
`Response`	`tdigestByrevrankAndAwait(List<String> args)`	Blocking variant of `tdigestByrevrank(List)`.
`RedisAPI`	`tdigestByrevrankAndForget(List<String> args)`	Variant of `tdigestByrevrank(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestCdf(List<String> args)`	Redis command TDIGEST.CDF.
`Response`	`tdigestCdfAndAwait(List<String> args)`	Blocking variant of `tdigestCdf(List)`.
`RedisAPI`	`tdigestCdfAndForget(List<String> args)`	Variant of `tdigestCdf(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestCreate(List<String> args)`	Redis command TDIGEST.CREATE.
`Response`	`tdigestCreateAndAwait(List<String> args)`	Blocking variant of `tdigestCreate(List)`.
`RedisAPI`	`tdigestCreateAndForget(List<String> args)`	Variant of `tdigestCreate(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestInfo(List<String> args)`	Redis command TDIGEST.INFO.
`Response`	`tdigestInfoAndAwait(List<String> args)`	Blocking variant of `tdigestInfo(List)`.
`RedisAPI`	`tdigestInfoAndForget(List<String> args)`	Variant of `tdigestInfo(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestMax(List<String> args)`	Redis command TDIGEST.MAX.
`Response`	`tdigestMaxAndAwait(List<String> args)`	Blocking variant of `tdigestMax(List)`.
`RedisAPI`	`tdigestMaxAndForget(List<String> args)`	Variant of `tdigestMax(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestMerge(List<String> args)`	Redis command TDIGEST.MERGE.
`Response`	`tdigestMergeAndAwait(List<String> args)`	Blocking variant of `tdigestMerge(List)`.
`RedisAPI`	`tdigestMergeAndForget(List<String> args)`	Variant of `tdigestMerge(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestMin(List<String> args)`	Redis command TDIGEST.MIN.
`Response`	`tdigestMinAndAwait(List<String> args)`	Blocking variant of `tdigestMin(List)`.
`RedisAPI`	`tdigestMinAndForget(List<String> args)`	Variant of `tdigestMin(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestQuantile(List<String> args)`	Redis command TDIGEST.QUANTILE.
`Response`	`tdigestQuantileAndAwait(List<String> args)`	Blocking variant of `tdigestQuantile(List)`.
`RedisAPI`	`tdigestQuantileAndForget(List<String> args)`	Variant of `tdigestQuantile(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestRank(List<String> args)`	Redis command TDIGEST.RANK.
`Response`	`tdigestRankAndAwait(List<String> args)`	Blocking variant of `tdigestRank(List)`.
`RedisAPI`	`tdigestRankAndForget(List<String> args)`	Variant of `tdigestRank(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestReset(List<String> args)`	Redis command TDIGEST.RESET.
`Response`	`tdigestResetAndAwait(List<String> args)`	Blocking variant of `tdigestReset(List)`.
`RedisAPI`	`tdigestResetAndForget(List<String> args)`	Variant of `tdigestReset(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestRevrank(List<String> args)`	Redis command TDIGEST.REVRANK.
`Response`	`tdigestRevrankAndAwait(List<String> args)`	Blocking variant of `tdigestRevrank(List)`.
`RedisAPI`	`tdigestRevrankAndForget(List<String> args)`	Variant of `tdigestRevrank(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`tdigestTrimmedMean(List<String> args)`	Redis command TDIGEST.TRIMMED_MEAN.
`Response`	`tdigestTrimmedMeanAndAwait(List<String> args)`	Blocking variant of `tdigestTrimmedMean(List)`.
`RedisAPI`	`tdigestTrimmedMeanAndForget(List<String> args)`	Variant of `tdigestTrimmedMean(List)` that ignores the result of the operation.
`io.smallrye.mutiny.Uni<Response>`	`time()`	Return the current server 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 TIMESERIES.CLUSTERSET.
`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 TIMESERIES.CLUSTERSETFROMSHARD.
`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 TIMESERIES.HELLO.
`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 TIMESERIES.INFOCLUSTER.
`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 TIMESERIES.INNERCOMMUNICATION.
`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 TIMESERIES.NETWORKTEST.
`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 TIMESERIES.REFRESHCLUSTER.
`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 TOPK.ADD.
`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 TOPK.COUNT.
`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 TOPK.INCRBY.
`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 TOPK.INFO.
`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 TOPK.LIST.
`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 TOPK.QUERY.
`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 TOPK.RESERVE.
`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)`	Alters the last access time of a key(s).
`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 TS.ADD.
`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 TS.ALTER.
`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 TS.CREATE.
`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 TS.CREATERULE.
`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 TS.DECRBY.
`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 TS.DEL.
`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 TS.DELETERULE.
`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 TS.GET.
`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 TS.INCRBY.
`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 TS.INFO.
`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 TS.MADD.
`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 TS.MGET.
`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 TS.MRANGE.
`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 TS.MREVRANGE.
`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 TS.QUERYINDEX.
`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 TS.RANGE.
`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 TS.REVRANGE.
`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)`	Get the time to live for a key in seconds.
`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)`	Determine the type stored at key.
`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)`	Delete a key asynchronously in another thread.
`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)`	Stop listening for messages posted to the given channels.
`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()`	Forget about all watched keys.
`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)`	Wait for the synchronous replication of all the write commands sent in the context of the current connection.
`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)`	Watch the given keys to determine execution of the MULTI/EXEC block.
`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)`	Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group.
`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)`	Appends a new entry to a stream.
`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)`	Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
`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)`	Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
`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)`	Removes the specified entries from the stream.
`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)`	A container for consumer groups commands.
`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)`	A container for stream introspection commands.
`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)`	Return the number of entries in a stream.
`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)`	Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
`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)`	Return a range of elements in a stream, with IDs matching the specified IDs interval.
`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)`	Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream.
`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)`	Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer.
`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)`	Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.
`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)`	An internal command for replicating stream values.
`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)`	Trims the stream to (approximately if '~' is passed) a certain size.
`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)`	Add one or more members to a sorted set, or update its score if it already exists.
`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)`	Get the number of members in a sorted set.
`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)`	Count the members in a sorted set with scores within the given values.
`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)`	Subtract multiple sorted sets.
`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)`	Subtract multiple sorted sets and store the resulting sorted set in a new key.
`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)`	Increment the score of a member in a sorted set.
`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)`	Intersect multiple sorted sets.
`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)`	Intersect multiple sorted sets and return the cardinality of the result.
`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)`	Intersect multiple sorted sets and store the resulting sorted set in a new key.
`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)`	Count the number of members in a sorted set between a given lexicographical range.
`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)`	Remove and return members with scores in a sorted set.
`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)`	Get the score associated with the given members in a sorted set.
`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)`	Remove and return members with the highest scores in a sorted set.
`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)`	Remove and return members with the lowest scores in a sorted set.
`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)`	Get one or multiple random elements from a sorted set.
`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)`	Return a range of members in a sorted set.
`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)`	Return a range of members in a sorted set, by lexicographical range.
`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)`	Return a range of members in a sorted set, by score.
`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)`	Store a range of members from sorted set into another key.
`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)`	Determine the index of a member in a sorted set.
`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)`	Remove one or more members from a sorted set.
`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)`	Remove all members in a sorted set between the given lexicographical range.
`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)`	Remove all members in a sorted set within the given indexes.
`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)`	Remove all members in a sorted set within the given scores.
`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)`	Return a range of members in a sorted set, by index, with scores ordered from high to low.
`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)`	Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
`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)`	Return a range of members in a sorted set, by score, with scores ordered from high to low.
`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)`	Determine the index of a member in a sorted set, with scores ordered from high to low.
`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)`	Incrementally iterate sorted sets elements and associated scores.
`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)`	Get the score associated with the given member in a sorted set.
`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)`	Add multiple sorted sets.
`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)`	Add multiple sorted sets and store the resulting sorted set in a new key.
`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 FT.ADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.AGGREGATE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.ALIASADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.ALIASDEL.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.ALIASUPDATE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.ALTER.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.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.
  - 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 FT.CREATE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.CURSOR.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.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.
  - 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 FT.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.
  - 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 FT.DICTADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.DICTDEL.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.DICTDUMP.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.DROP.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.DROPINDEX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.EXPLAIN.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.EXPLAINCLI.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.GET.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.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.
  - 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 FT.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.
  - 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 FT.PROFILE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.SAFEADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.SEARCH.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.SPELLCHECK.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.SUGADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.SUGDEL.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.SUGGET.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.SUGLEN.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.SYNADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.SYNDUMP.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.SYNUPDATE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT.TAGVALS.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT._ALIASADDIFNX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT._ALIASDELIFX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT._ALTERIFNX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT._CREATEIFNX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT._DROPIFX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT._DROPINDEXIFX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 FT._LIST.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    A container for Access List Control commands.
    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)
```
    Append a value to a key.
    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()
```
    Sent by cluster clients after an -ASK redirect.
    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)
```
    Authenticate to the server.
    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 BF.ADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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.
  - bfCard
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> bfCard(List<String> args)
```
    Redis command BF.CARD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - bfCardAndAwait
```
public Response bfCardAndAwait(List<String> args)
```
    Blocking variant of bfCard(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - bfCardAndForget
```
public RedisAPI bfCardAndForget(List<String> args)
```
    Variant of bfCard(List) that ignores the result of the operation.
    This method subscribes on the result of bfCard(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from bfCard(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 BF.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.
  - 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 BF.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.
  - 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 BF.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.
  - 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 BF.INSERT.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 BF.LOADCHUNK.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 BF.MADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 BF.MEXISTS.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 BF.RESERVE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 BF.SCANDUMP.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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()
```
    Asynchronously rewrite the append-only file.
    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)
```
    Asynchronously save the dataset to disk.
    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)
```
    Count set bits in a string.
    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)
```
    Perform arbitrary bitfield integer operations on strings.
    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)
```
    Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD.
    Redis command BITFIELD_RO.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    Perform bitwise operations between strings.
    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)
```
    Find first bit set or clear in a string.
    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)
```
    Pop an element from a list, push it to another list and return it; or block until one is available.
    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)
```
    Pop elements from a list, or block until one is available.
    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)
```
    Remove and get the first element in a list, or block until one is available.
    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)
```
    Remove and get the last element in a list, or block until one is available.
    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)
```
    Pop an element from a list, push it to another list and return it; or block until one is available.
    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)
```
    Remove and return members with scores in a sorted set or block until one is available.
    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)
```
    Remove and return the member with the highest score from one or more sorted sets, or block until one is available.
    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)
```
    Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.
    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 CF.ADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CF.ADDNX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CF.COMPACT.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CF.COUNT.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CF.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.
  - 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 CF.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.
  - 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 CF.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.
  - 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 CF.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.
  - 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 CF.INSERT.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CF.INSERTNX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CF.LOADCHUNK.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CF.MEXISTS.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CF.RESERVE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CF.SCANDUMP.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    A container for client connection commands.
    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)
```
    A container for cluster commands.
    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 CMS.INCRBY.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CMS.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.
  - 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 CMS.INITBYDIM.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CMS.INITBYPROB.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CMS.MERGE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 CMS.QUERY.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    Get array of Redis command details.
    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)
```
    A container for server configuration commands.
    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)
```
    Copy a key.
    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()
```
    Return the number of keys in the selected database.
    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)
```
    A container for debugging commands.
    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)
```
    Decrement the integer value of a key by one.
    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)
```
    Decrement the integer value of a key by the given number.
    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)
```
    Delete a key.
    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()
```
    Discard all commands issued after MULTI.
    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)
```
    Return a serialized version of the value stored at the specified key.
    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)
```
    Echo the given string.
    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)
```
    Execute a Lua script server side.
    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)
```
    Execute a read-only Lua script server side.
    Redis command EVAL_RO.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    Execute a Lua script server side.
    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)
```
    Execute a read-only Lua script server side.
    Redis command EVALSHA_RO.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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()
```
    Execute all commands issued after MULTI.
    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)
```
    Determine if a key exists.
    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)
```
    Set a key's time to live in seconds.
    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)
```
    Set the expiration for a key as a UNIX timestamp.
    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)
```
    Get the expiration Unix timestamp for a key.
    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)
```
    Start a coordinated failover between this server and one of its replicas.
    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)
```
    Invoke a function.
    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)
```
    Invoke a read-only function.
    Redis command FCALL_RO.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    Remove all keys from all databases.
    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)
```
    Remove all keys from the current database.
    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)
```
    A container for function commands.
    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)
```
    Add one or more geospatial items in the geospatial index represented using a sorted set.
    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)
```
    Returns the distance between two members of a geospatial index.
    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)
```
    Returns members of a geospatial index as standard geohash strings.
    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)
```
    Returns longitude and latitude of members of a geospatial index.
    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)
```
    Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
    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)
```
    A read-only variant for GEORADIUS.
    Redis command GEORADIUS_RO.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
    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)
```
    A read-only variant for GEORADIUSBYMEMBER.
    Redis command GEORADIUSBYMEMBER_RO.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
    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)
```
    Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.
    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)
```
    Get the value of a key.
    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)
```
    Returns the bit value at offset in the string value stored at key.
    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)
```
    Get the value of a key and delete the key.
    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)
```
    Get the value of a key and optionally set its expiration.
    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)
```
    Get a substring of the string stored at a key.
    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)
```
    Set the string value of a key and return its old value.
    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 GRAPH.BULK.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 GRAPH.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.
  - 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 GRAPH.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.
  - 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 GRAPH.DELETE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 GRAPH.EXPLAIN.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 GRAPH.LIST.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 GRAPH.PROFILE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 GRAPH.QUERY.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 GRAPH.RO_QUERY.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 GRAPH.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.
  - 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)
```
    Delete one or more hash fields.
    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)
```
    Handshake with Redis.
    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)
```
    Determine if a hash field exists.
    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)
```
    Get the value of a hash field.
    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)
```
    Get all the fields and values in a hash.
    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)
```
    Increment the integer value of a hash field by the given number.
    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)
```
    Increment the float value of a hash field by the given amount.
    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)
```
    Get all the fields in a hash.
    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)
```
    Get the number of fields in a hash.
    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)
```
    Get the values of all the given hash fields.
    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)
```
    Set multiple hash fields to multiple values.
    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)
```
    Get one or multiple random fields from a hash.
    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)
```
    Incrementally iterate hash fields and associated values.
    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)
```
    Set the string value of a hash field.
    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)
```
    Set the value of a hash field, only if the field does not exist.
    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)
```
    Get the length of the value of a hash field.
    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)
```
    Get all the values in a hash.
    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)
```
    Increment the integer value of a key by one.
    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)
```
    Increment the integer value of a key by the given amount.
    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)
```
    Increment the float value of a key by the given amount.
    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)
```
    Get information and statistics about the server.
    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 JSON.ARRAPPEND.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.ARRINDEX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.ARRINSERT.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.ARRLEN.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.ARRPOP.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.ARRTRIM.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.CLEAR.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.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.
  - 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 JSON.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.
  - 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 JSON.FORGET.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.GET.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.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.
  - 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 JSON.NUMINCRBY.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.NUMMULTBY.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.NUMPOWBY.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.OBJKEYS.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.OBJLEN.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.RESP.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.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.
  - 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 JSON.STRAPPEND.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.STRLEN.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.TOGGLE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 JSON.TYPE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    Find all keys matching the given pattern.
    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()
```
    Get the UNIX time stamp of the last successful save to disk.
    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)
```
    A container for latency diagnostics commands.
    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)
```
    Find longest common substring.
    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)
```
    Get an element from a list by its index.
    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)
```
    Insert an element before or after another element in a list.
    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)
```
    Get the length of a list.
    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)
```
    Pop an element from a list, push it to another list and return it.
    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)
```
    Pop elements from a list.
    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)
```
    Display some computer art and the Redis version.
    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)
```
    Remove and get the first elements in a list.
    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)
```
    Return the index of matching elements on a list.
    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)
```
    Prepend one or multiple elements to a list.
    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)
```
    Prepend an element to a list, only if the list exists.
    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)
```
    Get a range of elements from a list.
    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)
```
    Remove elements from a list.
    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)
```
    Set the value of an element in a list by its index.
    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)
```
    Trim a list to the specified range.
    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)
```
    A container for memory diagnostics commands.
    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)
```
    Get the values of all the given keys.
    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)
```
    Atomically transfer a key from a Redis instance to another one.
    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)
```
    A container for module commands.
    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()
```
    Listen for all requests received by the server in real time.
    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)
```
    Move a key to another database.
    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)
```
    Set multiple keys to multiple values.
    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)
```
    Set multiple keys to multiple values, only if none of the keys exist.
    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()
```
    Mark the start of a transaction block.
    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)
```
    A container for object introspection commands.
    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)
```
    Remove the expiration from a key.
    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)
```
    Set a key's time to live in milliseconds.
    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)
```
    Set the expiration for a key as a UNIX timestamp specified in milliseconds.
    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)
```
    Get the expiration Unix timestamp for a key in milliseconds.
    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)
```
    Adds the specified elements to the specified HyperLogLog.
    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)
```
    Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    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(String arg0,
                                                String arg1)
```
    Internal commands for debugging HyperLogLog values.
    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:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - pfdebugAndAwait
```
public Response pfdebugAndAwait(String arg0,
                                String arg1)
```
    Blocking variant of pfdebug(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.
  - pfdebugAndForget
```
public RedisAPI pfdebugAndForget(String arg0,
                                 String arg1)
```
    Variant of pfdebug(String,String) that ignores the result of the operation.
    This method subscribes on the result of pfdebug(String,String), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from pfdebug(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.
  - pfmerge
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> pfmerge(List<String> args)
```
    Merge N different HyperLogLogs into a single one.
    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()
```
    An internal command for testing HyperLogLog values.
    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)
```
    Ping the server.
    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)
```
    Set the value and expiration in milliseconds of a key.
    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)
```
    Listen for messages published to channels matching the given patterns.
    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)
```
    Internal command used for replication.
    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)
```
    Get the time to live for a key in milliseconds.
    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)
```
    Post a message to a channel.
    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)
```
    A container for Pub/Sub commands.
    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)
```
    Stop listening for messages posted to channels matching the given patterns.
    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)
```
    Close the connection.
    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()
```
    Return a random key from the keyspace.
    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()
```
    Enables read queries for a connection to a cluster replica node.
    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()
```
    Disables read queries for a connection to a cluster replica node.
    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)
```
    Rename a key.
    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)
```
    Rename a key, only if the new key does not exist.
    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)
```
    An internal command for configuring the replication stream.
    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)
```
    Make the server a replica of another instance, or promote it as master.
    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()
```
    Reset the connection.
    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)
```
    Create a key using the provided serialized value, previously obtained using DUMP.
    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)
```
    An internal command for migrating keys in a cluster.
    Redis command RESTORE-ASKING.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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()
```
    Return the role of the instance in the context of replication.
    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)
```
    Remove and get the last elements in a list.
    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)
```
    Remove the last element in a list, prepend it to another list and return it.
    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)
```
    Append one or multiple elements to a list.
    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)
```
    Append an element to a list, only if the list exists.
    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)
```
    Add one or more members to a set.
    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()
```
    Synchronously save the dataset to disk.
    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)
```
    Incrementally iterate the keys space.
    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)
```
    Get the number of members in a set.
    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)
```
    A container for Lua scripts management commands.
    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)
```
    Subtract multiple sets.
    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)
```
    Subtract multiple sets and store the resulting set in a key.
    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)
```
    Change the selected database for the current connection.
    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)
```
    Set the string value of a key.
    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)
```
    Sets or clears the bit at offset in the string value stored at key.
    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)
```
    Set the value and expiration of a key.
    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)
```
    Set the value of a key, only if the key does not exist.
    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)
```
    Overwrite part of a string at key starting at the specified offset.
    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)
```
    Synchronously save the dataset to disk and then shut down the server.
    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)
```
    Intersect multiple sets.
    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)
```
    Intersect multiple sets and return the cardinality of the result.
    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)
```
    Intersect multiple sets and store the resulting set in a key.
    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)
```
    Determine if a given value is a member of a set.
    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)
```
    Make the server a replica of another instance, or promote it as master.
    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)
```
    A container for slow log commands.
    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)
```
    Get all the members in a set.
    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)
```
    Returns the membership associated with the given elements for a set.
    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)
```
    Move a member from one set to another.
    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)
```
    Sort the elements in a list, set or sorted set.
    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)
```
    Sort the elements in a list, set or sorted set. Read-only variant of SORT.
    Redis command SORT_RO.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    Remove and return one or multiple random members from a set.
    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)
```
    Post a message to a shard channel.
    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)
```
    Get one or multiple random members from a set.
    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)
```
    Remove one or more members from a set.
    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)
```
    Incrementally iterate Set elements.
    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)
```
    Listen for messages published to the given shard channels.
    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)
```
    Get the length of the value stored in a key.
    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)
```
    Listen for messages published to the given channels.
    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)
```
    Get a substring of the string stored at a key.
    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)
```
    Add multiple sets.
    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)
```
    Add multiple sets and store the resulting set in a key.
    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)
```
    Stop listening for messages posted to the given shard channels.
    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)
```
    Swaps two Redis databases.
    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()
```
    Internal command used for replication.
    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.
  - tdigestAdd
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestAdd(List<String> args)
```
    Redis command TDIGEST.ADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestAddAndAwait
```
public Response tdigestAddAndAwait(List<String> args)
```
    Blocking variant of tdigestAdd(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestAddAndForget
```
public RedisAPI tdigestAddAndForget(List<String> args)
```
    Variant of tdigestAdd(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestAdd(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestAdd(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestByrank
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestByrank(List<String> args)
```
    Redis command TDIGEST.BYRANK.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestByrankAndAwait
```
public Response tdigestByrankAndAwait(List<String> args)
```
    Blocking variant of tdigestByrank(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestByrankAndForget
```
public RedisAPI tdigestByrankAndForget(List<String> args)
```
    Variant of tdigestByrank(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestByrank(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestByrank(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestByrevrank
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestByrevrank(List<String> args)
```
    Redis command TDIGEST.BYREVRANK.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestByrevrankAndAwait
```
public Response tdigestByrevrankAndAwait(List<String> args)
```
    Blocking variant of tdigestByrevrank(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestByrevrankAndForget
```
public RedisAPI tdigestByrevrankAndForget(List<String> args)
```
    Variant of tdigestByrevrank(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestByrevrank(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestByrevrank(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestCdf
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestCdf(List<String> args)
```
    Redis command TDIGEST.CDF.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestCdfAndAwait
```
public Response tdigestCdfAndAwait(List<String> args)
```
    Blocking variant of tdigestCdf(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestCdfAndForget
```
public RedisAPI tdigestCdfAndForget(List<String> args)
```
    Variant of tdigestCdf(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestCdf(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestCdf(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestCreate
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestCreate(List<String> args)
```
    Redis command TDIGEST.CREATE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestCreateAndAwait
```
public Response tdigestCreateAndAwait(List<String> args)
```
    Blocking variant of tdigestCreate(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestCreateAndForget
```
public RedisAPI tdigestCreateAndForget(List<String> args)
```
    Variant of tdigestCreate(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestCreate(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestCreate(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestInfo
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestInfo(List<String> args)
```
    Redis command TDIGEST.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.
  - tdigestInfoAndAwait
```
public Response tdigestInfoAndAwait(List<String> args)
```
    Blocking variant of tdigestInfo(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestInfoAndForget
```
public RedisAPI tdigestInfoAndForget(List<String> args)
```
    Variant of tdigestInfo(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestInfo(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestInfo(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestMax
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestMax(List<String> args)
```
    Redis command TDIGEST.MAX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestMaxAndAwait
```
public Response tdigestMaxAndAwait(List<String> args)
```
    Blocking variant of tdigestMax(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestMaxAndForget
```
public RedisAPI tdigestMaxAndForget(List<String> args)
```
    Variant of tdigestMax(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestMax(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestMax(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestMerge
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestMerge(List<String> args)
```
    Redis command TDIGEST.MERGE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestMergeAndAwait
```
public Response tdigestMergeAndAwait(List<String> args)
```
    Blocking variant of tdigestMerge(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestMergeAndForget
```
public RedisAPI tdigestMergeAndForget(List<String> args)
```
    Variant of tdigestMerge(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestMerge(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestMerge(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestMin
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestMin(List<String> args)
```
    Redis command TDIGEST.MIN.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestMinAndAwait
```
public Response tdigestMinAndAwait(List<String> args)
```
    Blocking variant of tdigestMin(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestMinAndForget
```
public RedisAPI tdigestMinAndForget(List<String> args)
```
    Variant of tdigestMin(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestMin(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestMin(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestQuantile
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestQuantile(List<String> args)
```
    Redis command TDIGEST.QUANTILE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestQuantileAndAwait
```
public Response tdigestQuantileAndAwait(List<String> args)
```
    Blocking variant of tdigestQuantile(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestQuantileAndForget
```
public RedisAPI tdigestQuantileAndForget(List<String> args)
```
    Variant of tdigestQuantile(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestQuantile(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestQuantile(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestRank
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestRank(List<String> args)
```
    Redis command TDIGEST.RANK.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestRankAndAwait
```
public Response tdigestRankAndAwait(List<String> args)
```
    Blocking variant of tdigestRank(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestRankAndForget
```
public RedisAPI tdigestRankAndForget(List<String> args)
```
    Variant of tdigestRank(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestRank(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestRank(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestReset
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestReset(List<String> args)
```
    Redis command TDIGEST.RESET.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestResetAndAwait
```
public Response tdigestResetAndAwait(List<String> args)
```
    Blocking variant of tdigestReset(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestResetAndForget
```
public RedisAPI tdigestResetAndForget(List<String> args)
```
    Variant of tdigestReset(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestReset(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestReset(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestRevrank
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestRevrank(List<String> args)
```
    Redis command TDIGEST.REVRANK.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestRevrankAndAwait
```
public Response tdigestRevrankAndAwait(List<String> args)
```
    Blocking variant of tdigestRevrank(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestRevrankAndForget
```
public RedisAPI tdigestRevrankAndForget(List<String> args)
```
    Variant of tdigestRevrank(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestRevrank(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestRevrank(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - tdigestTrimmedMean
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> tdigestTrimmedMean(List<String> args)
```
    Redis command TDIGEST.TRIMMED_MEAN.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.
    
    Parameters:
    
    args -
    
    Returns:
    
    the uni firing the result of the operation when completed, or a failure if the operation failed.
  - tdigestTrimmedMeanAndAwait
```
public Response tdigestTrimmedMeanAndAwait(List<String> args)
```
    Blocking variant of tdigestTrimmedMean(List).
    This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).
    
    Parameters:
    
    args -
    
    Returns:
    
    the Response instance produced by the operation.
  - tdigestTrimmedMeanAndForget
```
public RedisAPI tdigestTrimmedMeanAndForget(List<String> args)
```
    Variant of tdigestTrimmedMean(List) that ignores the result of the operation.
    This method subscribes on the result of tdigestTrimmedMean(List), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from tdigestTrimmedMean(List) but you don't need to compose it with other operations.
    
    Parameters:
    
    args -
    
    Returns:
    
    the instance of RedisAPI to chain method calls.
  - time
```
@CheckReturnValue
public io.smallrye.mutiny.Uni<Response> time()
```
    Return the current server 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 TIMESERIES.CLUSTERSET.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TIMESERIES.CLUSTERSETFROMSHARD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TIMESERIES.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.
  - 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 TIMESERIES.INFOCLUSTER.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TIMESERIES.INNERCOMMUNICATION.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TIMESERIES.NETWORKTEST.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TIMESERIES.REFRESHCLUSTER.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TOPK.ADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TOPK.COUNT.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TOPK.INCRBY.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TOPK.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.
  - 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 TOPK.LIST.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TOPK.QUERY.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TOPK.RESERVE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    Alters the last access time of a key(s). Returns the number of existing keys specified.
    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 TS.ADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.ALTER.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.CREATE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.CREATERULE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.DECRBY.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.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.
  - 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 TS.DELETERULE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.GET.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.INCRBY.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.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.
  - 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 TS.MADD.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.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.
  - 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 TS.MRANGE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.MREVRANGE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.QUERYINDEX.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.RANGE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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 TS.REVRANGE.
    Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it 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)
```
    Get the time to live for a key in seconds.
    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)
```
    Determine the type stored at key.
    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)
```
    Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
    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)
```
    Stop listening for messages posted to the given channels.
    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()
```
    Forget about all watched keys.
    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)
```
    Wait for the synchronous replication of all the write commands sent in the context of the current connection.
    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)
```
    Watch the given keys to determine execution of the MULTI/EXEC block.
    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)
```
    Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.
    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)
```
    Appends a new entry to a stream.
    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)
```
    Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
    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)
```
    Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
    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)
```
    Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.
    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)
```
    A container for consumer groups commands.
    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)
```
    A container for stream introspection commands.
    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)
```
    Return the number of entries in a stream.
    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)
```
    Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
    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)
```
    Return a range of elements in a stream, with IDs matching the specified IDs interval.
    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)
```
    Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.
    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)
```
    Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.
    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)
```
    Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.
    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)
```
    An internal command for replicating stream values.
    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)
```
    Trims the stream to (approximately if '~' is passed) a certain size.
    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)
```
    Add one or more members to a sorted set, or update its score if it already exists.
    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)
```
    Get the number of members in a sorted set.
    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)
```
    Count the members in a sorted set with scores within the given values.
    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)
```
    Subtract multiple sorted sets.
    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)
```
    Subtract multiple sorted sets and store the resulting sorted set in a new key.
    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)
```
    Increment the score of a member in a sorted set.
    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)
```
    Intersect multiple sorted sets.
    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)
```
    Intersect multiple sorted sets and return the cardinality of the result.
    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)
```
    Intersect multiple sorted sets and store the resulting sorted set in a new key.
    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)
```
    Count the number of members in a sorted set between a given lexicographical range.
    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)
```
    Remove and return members with scores in a sorted set.
    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)
```
    Get the score associated with the given members in a sorted set.
    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)
```
    Remove and return members with the highest scores in a sorted set.
    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)
```
    Remove and return members with the lowest scores in a sorted set.
    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)
```
    Get one or multiple random elements from a sorted set.
    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)
```
    Return a range of members in a sorted set.
    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)
```
    Return a range of members in a sorted set, by lexicographical range.
    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)
```
    Return a range of members in a sorted set, by score.
    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)
```
    Store a range of members from sorted set into another key.
    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)
```
    Determine the index of a member in a sorted set.
    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)
```
    Remove one or more members from a sorted set.
    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)
```
    Remove all members in a sorted set between the given lexicographical range.
    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)
```
    Remove all members in a sorted set within the given indexes.
    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)
```
    Remove all members in a sorted set within the given scores.
    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)
```
    Return a range of members in a sorted set, by index, with scores ordered from high to low.
    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)
```
    Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
    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)
```
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    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)
```
    Determine the index of a member in a sorted set, with scores ordered from high to low.
    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)
```
    Incrementally iterate sorted sets elements and associated scores.
    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)
```
    Get the score associated with the given member in a sorted set.
    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)
```
    Add multiple sorted sets.
    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)
```
    Add multiple sorted sets and store the resulting sorted set in a new key.
    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