RedisAPI (Vert.x Stack - Docs 4.5.11 API)

java.lang.Object
- io.vertx.rxjava3.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 RX-ified interface using Vert.x codegen.

Field Summary

Fields
Modifier and Type Field and Description

static io.vertx.lang.rx.TypeArg<RedisAPI> __TYPE_ARG

Fields
Modifier and Type	Field and Description
`static io.vertx.lang.rx.TypeArg<RedisAPI>`	`__TYPE_ARG`

Constructor Summary

Constructors
Constructor and Description

RedisAPI(Object delegate)

RedisAPI(RedisAPI delegate)

Constructors
Constructor and Description
`RedisAPI(Object delegate)`
`RedisAPI(RedisAPI delegate)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Maybe<Response>`	`acl(List<String> args)` A container for Access List Control commands.
`static RedisAPI`	`api(Redis client)`
`static RedisAPI`	`api(RedisConnection connection)`
`Maybe<Response>`	`append(String arg0, String arg1)` Append a value to a key.
`Maybe<Response>`	`asking()` Sent by cluster clients after an -ASK redirect.
`Maybe<Response>`	`auth(List<String> args)` Authenticate to the server.
`Maybe<Response>`	`bfAdd(List<String> args)` Redis command BF.ADD.
`Maybe<Response>`	`bfCard(List<String> args)` Redis command BF.CARD.
`Maybe<Response>`	`bfDebug(List<String> args)` Redis command BF.DEBUG.
`Maybe<Response>`	`bfExists(List<String> args)` Redis command BF.EXISTS.
`Maybe<Response>`	`bfInfo(List<String> args)` Redis command BF.INFO.
`Maybe<Response>`	`bfInsert(List<String> args)` Redis command BF.INSERT.
`Maybe<Response>`	`bfLoadchunk(List<String> args)` Redis command BF.LOADCHUNK.
`Maybe<Response>`	`bfMadd(List<String> args)` Redis command BF.MADD.
`Maybe<Response>`	`bfMexists(List<String> args)` Redis command BF.MEXISTS.
`Maybe<Response>`	`bfReserve(List<String> args)` Redis command BF.RESERVE.
`Maybe<Response>`	`bfScandump(List<String> args)` Redis command BF.SCANDUMP.
`Maybe<Response>`	`bgrewriteaof()` Asynchronously rewrite the append-only file.
`Maybe<Response>`	`bgsave(List<String> args)` Asynchronously save the dataset to disk.
`Maybe<Response>`	`bitcount(List<String> args)` Count set bits in a string.
`Maybe<Response>`	`bitfield(List<String> args)` Perform arbitrary bitfield integer operations on strings.
`Maybe<Response>`	`bitfieldRo(List<String> args)` Perform arbitrary bitfield integer operations on strings.
`Maybe<Response>`	`bitop(List<String> args)` Perform bitwise operations between strings.
`Maybe<Response>`	`bitpos(List<String> args)` Find first bit set or clear in a string.
`Maybe<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.
`Maybe<Response>`	`blmpop(List<String> args)` Pop elements from a list, or block until one is available.
`Maybe<Response>`	`blpop(List<String> args)` Remove and get the first element in a list, or block until one is available.
`Maybe<Response>`	`brpop(List<String> args)` Remove and get the last element in a list, or block until one is available.
`Maybe<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.
`Maybe<Response>`	`bzmpop(List<String> args)` Remove and return members with scores in a sorted set or block until one is available.
`Maybe<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.
`Maybe<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.
`Maybe<Response>`	`cfAdd(List<String> args)` Redis command CF.ADD.
`Maybe<Response>`	`cfAddnx(List<String> args)` Redis command CF.ADDNX.
`Maybe<Response>`	`cfCompact(List<String> args)` Redis command CF.COMPACT.
`Maybe<Response>`	`cfCount(List<String> args)` Redis command CF.COUNT.
`Maybe<Response>`	`cfDebug(List<String> args)` Redis command CF.DEBUG.
`Maybe<Response>`	`cfDel(List<String> args)` Redis command CF.DEL.
`Maybe<Response>`	`cfExists(List<String> args)` Redis command CF.EXISTS.
`Maybe<Response>`	`cfInfo(List<String> args)` Redis command CF.INFO.
`Maybe<Response>`	`cfInsert(List<String> args)` Redis command CF.INSERT.
`Maybe<Response>`	`cfInsertnx(List<String> args)` Redis command CF.INSERTNX.
`Maybe<Response>`	`cfLoadchunk(List<String> args)` Redis command CF.LOADCHUNK.
`Maybe<Response>`	`cfMexists(List<String> args)` Redis command CF.MEXISTS.
`Maybe<Response>`	`cfReserve(List<String> args)` Redis command CF.RESERVE.
`Maybe<Response>`	`cfScandump(List<String> args)` Redis command CF.SCANDUMP.
`Maybe<Response>`	`client(List<String> args)` A container for client connection commands.
`void`	`close()`
`Maybe<Response>`	`cluster(List<String> args)` A container for cluster commands.
`Maybe<Response>`	`cmsIncrby(List<String> args)` Redis command CMS.INCRBY.
`Maybe<Response>`	`cmsInfo(List<String> args)` Redis command CMS.INFO.
`Maybe<Response>`	`cmsInitbydim(List<String> args)` Redis command CMS.INITBYDIM.
`Maybe<Response>`	`cmsInitbyprob(List<String> args)` Redis command CMS.INITBYPROB.
`Maybe<Response>`	`cmsMerge(List<String> args)` Redis command CMS.MERGE.
`Maybe<Response>`	`cmsQuery(List<String> args)` Redis command CMS.QUERY.
`Maybe<Response>`	`command(List<String> args)` Get array of Redis command details.
`Maybe<Response>`	`config(List<String> args)` A container for server configuration commands.
`Maybe<Response>`	`copy(List<String> args)` Copy a key.
`Maybe<Response>`	`dbsize()` Return the number of keys in the selected database.
`Maybe<Response>`	`debug(List<String> args)` A container for debugging commands.
`Maybe<Response>`	`decr(String arg0)` Decrement the integer value of a key by one.
`Maybe<Response>`	`decrby(String arg0, String arg1)` Decrement the integer value of a key by the given number.
`Maybe<Response>`	`del(List<String> args)` Delete a key.
`Maybe<Response>`	`discard()` Discard all commands issued after MULTI.
`Maybe<Response>`	`dump(String arg0)` Return a serialized version of the value stored at the specified key.
`Maybe<Response>`	`echo(String arg0)` Echo the given string.
`boolean`	`equals(Object o)`
`Maybe<Response>`	`eval(List<String> args)` Execute a Lua script server side.
`Maybe<Response>`	`evalRo(List<String> args)` Execute a read-only Lua script server side.
`Maybe<Response>`	`evalsha(List<String> args)` Execute a Lua script server side.
`Maybe<Response>`	`evalshaRo(List<String> args)` Execute a read-only Lua script server side.
`Maybe<Response>`	`exec()` Execute all commands issued after MULTI.
`Maybe<Response>`	`exists(List<String> args)` Determine if a key exists.
`Maybe<Response>`	`expire(List<String> args)` Set a key's time to live in seconds.
`Maybe<Response>`	`expireat(List<String> args)` Set the expiration for a key as a UNIX timestamp.
`Maybe<Response>`	`expiretime(String arg0)` Get the expiration Unix timestamp for a key.
`Maybe<Response>`	`failover(List<String> args)` Start a coordinated failover between this server and one of its replicas.
`Maybe<Response>`	`fcall(List<String> args)` Invoke a function.
`Maybe<Response>`	`fcallRo(List<String> args)` Invoke a read-only function.
`Maybe<Response>`	`flushall(List<String> args)` Remove all keys from all databases.
`Maybe<Response>`	`flushdb(List<String> args)` Remove all keys from the current database.
`Maybe<Response>`	`ftAdd(List<String> args)` Redis command FT.ADD.
`Maybe<Response>`	`ftAggregate(List<String> args)` Redis command FT.AGGREGATE.
`Maybe<Response>`	`ftAliasadd(List<String> args)` Redis command FT.ALIASADD.
`Maybe<Response>`	`ftAliasaddifnx(List<String> args)` Redis command FT._ALIASADDIFNX.
`Maybe<Response>`	`ftAliasdel(List<String> args)` Redis command FT.ALIASDEL.
`Maybe<Response>`	`ftAliasdelifx(List<String> args)` Redis command FT._ALIASDELIFX.
`Maybe<Response>`	`ftAliasupdate(List<String> args)` Redis command FT.ALIASUPDATE.
`Maybe<Response>`	`ftAlter(List<String> args)` Redis command FT.ALTER.
`Maybe<Response>`	`ftAlterifnx(List<String> args)` Redis command FT._ALTERIFNX.
`Maybe<Response>`	`ftConfig(List<String> args)` Redis command FT.CONFIG.
`Maybe<Response>`	`ftCreate(List<String> args)` Redis command FT.CREATE.
`Maybe<Response>`	`ftCreateifnx(List<String> args)` Redis command FT._CREATEIFNX.
`Maybe<Response>`	`ftCursor(List<String> args)` Redis command FT.CURSOR.
`Maybe<Response>`	`ftDebug(List<String> args)` Redis command FT.DEBUG.
`Maybe<Response>`	`ftDel(List<String> args)` Redis command FT.DEL.
`Maybe<Response>`	`ftDictadd(List<String> args)` Redis command FT.DICTADD.
`Maybe<Response>`	`ftDictdel(List<String> args)` Redis command FT.DICTDEL.
`Maybe<Response>`	`ftDictdump(List<String> args)` Redis command FT.DICTDUMP.
`Maybe<Response>`	`ftDrop(List<String> args)` Redis command FT.DROP.
`Maybe<Response>`	`ftDropifx(List<String> args)` Redis command FT._DROPIFX.
`Maybe<Response>`	`ftDropindex(List<String> args)` Redis command FT.DROPINDEX.
`Maybe<Response>`	`ftDropindexifx(List<String> args)` Redis command FT._DROPINDEXIFX.
`Maybe<Response>`	`ftExplain(List<String> args)` Redis command FT.EXPLAIN.
`Maybe<Response>`	`ftExplaincli(List<String> args)` Redis command FT.EXPLAINCLI.
`Maybe<Response>`	`ftGet(List<String> args)` Redis command FT.GET.
`Maybe<Response>`	`ftInfo(List<String> args)` Redis command FT.INFO.
`Maybe<Response>`	`ftList(List<String> args)` Redis command FT._LIST.
`Maybe<Response>`	`ftMget(List<String> args)` Redis command FT.MGET.
`Maybe<Response>`	`ftProfile(List<String> args)` Redis command FT.PROFILE.
`Maybe<Response>`	`ftSafeadd(List<String> args)` Redis command FT.SAFEADD.
`Maybe<Response>`	`ftSearch(List<String> args)` Redis command FT.SEARCH.
`Maybe<Response>`	`ftSpellcheck(List<String> args)` Redis command FT.SPELLCHECK.
`Maybe<Response>`	`ftSugadd(List<String> args)` Redis command FT.SUGADD.
`Maybe<Response>`	`ftSugdel(List<String> args)` Redis command FT.SUGDEL.
`Maybe<Response>`	`ftSugget(List<String> args)` Redis command FT.SUGGET.
`Maybe<Response>`	`ftSuglen(List<String> args)` Redis command FT.SUGLEN.
`Maybe<Response>`	`ftSynadd(List<String> args)` Redis command FT.SYNADD.
`Maybe<Response>`	`ftSyndump(List<String> args)` Redis command FT.SYNDUMP.
`Maybe<Response>`	`ftSynupdate(List<String> args)` Redis command FT.SYNUPDATE.
`Maybe<Response>`	`ftTagvals(List<String> args)` Redis command FT.TAGVALS.
`Maybe<Response>`	`function(List<String> args)` A container for function commands.
`Maybe<Response>`	`geoadd(List<String> args)` Add one or more geospatial items in the geospatial index represented using a sorted set.
`Maybe<Response>`	`geodist(List<String> args)` Returns the distance between two members of a geospatial index.
`Maybe<Response>`	`geohash(List<String> args)` Returns members of a geospatial index as standard geohash strings.
`Maybe<Response>`	`geopos(List<String> args)` Returns longitude and latitude of members of a geospatial index.
`Maybe<Response>`	`georadius(List<String> args)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
`Maybe<Response>`	`georadiusbymember(List<String> args)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
`Maybe<Response>`	`georadiusbymemberRo(List<String> args)` A read-only variant for GEORADIUSBYMEMBER.
`Maybe<Response>`	`georadiusRo(List<String> args)` A read-only variant for GEORADIUS.
`Maybe<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.
`Maybe<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.
`Maybe<Response>`	`get(String arg0)` Get the value of a key.
`Maybe<Response>`	`getbit(String arg0, String arg1)` Returns the bit value at offset in the string value stored at key.
`Maybe<Response>`	`getdel(String arg0)` Get the value of a key and delete the key.
`RedisAPI`	`getDelegate()`
`Maybe<Response>`	`getex(List<String> args)` Get the value of a key and optionally set its expiration.
`Maybe<Response>`	`getrange(String arg0, String arg1, String arg2)` Get a substring of the string stored at a key.
`Maybe<Response>`	`getset(String arg0, String arg1)` Set the string value of a key and return its old value.
`Maybe<Response>`	`graphBulk(List<String> args)` Redis command GRAPH.BULK.
`Maybe<Response>`	`graphConfig(List<String> args)` Redis command GRAPH.CONFIG.
`Maybe<Response>`	`graphDebug(List<String> args)` Redis command GRAPH.DEBUG.
`Maybe<Response>`	`graphDelete(List<String> args)` Redis command GRAPH.DELETE.
`Maybe<Response>`	`graphExplain(List<String> args)` Redis command GRAPH.EXPLAIN.
`Maybe<Response>`	`graphList(List<String> args)` Redis command GRAPH.LIST.
`Maybe<Response>`	`graphProfile(List<String> args)` Redis command GRAPH.PROFILE.
`Maybe<Response>`	`graphQuery(List<String> args)` Redis command GRAPH.QUERY.
`Maybe<Response>`	`graphRoQuery(List<String> args)` Redis command GRAPH.RO_QUERY.
`Maybe<Response>`	`graphSlowlog(List<String> args)` Redis command GRAPH.SLOWLOG.
`int`	`hashCode()`
`Maybe<Response>`	`hdel(List<String> args)` Delete one or more hash fields.
`Maybe<Response>`	`hello(List<String> args)` Handshake with Redis.
`Maybe<Response>`	`hexists(String arg0, String arg1)` Determine if a hash field exists.
`Maybe<Response>`	`hget(String arg0, String arg1)` Get the value of a hash field.
`Maybe<Response>`	`hgetall(String arg0)` Get all the fields and values in a hash.
`Maybe<Response>`	`hincrby(String arg0, String arg1, String arg2)` Increment the integer value of a hash field by the given number.
`Maybe<Response>`	`hincrbyfloat(String arg0, String arg1, String arg2)` Increment the float value of a hash field by the given amount.
`Maybe<Response>`	`hkeys(String arg0)` Get all the fields in a hash.
`Maybe<Response>`	`hlen(String arg0)` Get the number of fields in a hash.
`Maybe<Response>`	`hmget(List<String> args)` Get the values of all the given hash fields.
`Maybe<Response>`	`hmset(List<String> args)` Set multiple hash fields to multiple values.
`Maybe<Response>`	`hrandfield(List<String> args)` Get one or multiple random fields from a hash.
`Maybe<Response>`	`hscan(List<String> args)` Incrementally iterate hash fields and associated values.
`Maybe<Response>`	`hset(List<String> args)` Set the string value of a hash field.
`Maybe<Response>`	`hsetnx(String arg0, String arg1, String arg2)` Set the value of a hash field, only if the field does not exist.
`Maybe<Response>`	`hstrlen(String arg0, String arg1)` Get the length of the value of a hash field.
`Maybe<Response>`	`hvals(String arg0)` Get all the values in a hash.
`Maybe<Response>`	`incr(String arg0)` Increment the integer value of a key by one.
`Maybe<Response>`	`incrby(String arg0, String arg1)` Increment the integer value of a key by the given amount.
`Maybe<Response>`	`incrbyfloat(String arg0, String arg1)` Increment the float value of a key by the given amount.
`Maybe<Response>`	`info(List<String> args)` Get information and statistics about the server.
`Maybe<Response>`	`jsonArrappend(List<String> args)` Redis command JSON.ARRAPPEND.
`Maybe<Response>`	`jsonArrindex(List<String> args)` Redis command JSON.ARRINDEX.
`Maybe<Response>`	`jsonArrinsert(List<String> args)` Redis command JSON.ARRINSERT.
`Maybe<Response>`	`jsonArrlen(List<String> args)` Redis command JSON.ARRLEN.
`Maybe<Response>`	`jsonArrpop(List<String> args)` Redis command JSON.ARRPOP.
`Maybe<Response>`	`jsonArrtrim(List<String> args)` Redis command JSON.ARRTRIM.
`Maybe<Response>`	`jsonClear(List<String> args)` Redis command JSON.CLEAR.
`Maybe<Response>`	`jsonDebug(List<String> args)` Redis command JSON.DEBUG.
`Maybe<Response>`	`jsonDel(List<String> args)` Redis command JSON.DEL.
`Maybe<Response>`	`jsonForget(List<String> args)` Redis command JSON.FORGET.
`Maybe<Response>`	`jsonGet(List<String> args)` Redis command JSON.GET.
`Maybe<Response>`	`jsonMget(List<String> args)` Redis command JSON.MGET.
`Maybe<Response>`	`jsonNumincrby(List<String> args)` Redis command JSON.NUMINCRBY.
`Maybe<Response>`	`jsonNummultby(List<String> args)` Redis command JSON.NUMMULTBY.
`Maybe<Response>`	`jsonNumpowby(List<String> args)` Redis command JSON.NUMPOWBY.
`Maybe<Response>`	`jsonObjkeys(List<String> args)` Redis command JSON.OBJKEYS.
`Maybe<Response>`	`jsonObjlen(List<String> args)` Redis command JSON.OBJLEN.
`Maybe<Response>`	`jsonResp(List<String> args)` Redis command JSON.RESP.
`Maybe<Response>`	`jsonSet(List<String> args)` Redis command JSON.SET.
`Maybe<Response>`	`jsonStrappend(List<String> args)` Redis command JSON.STRAPPEND.
`Maybe<Response>`	`jsonStrlen(List<String> args)` Redis command JSON.STRLEN.
`Maybe<Response>`	`jsonToggle(List<String> args)` Redis command JSON.TOGGLE.
`Maybe<Response>`	`jsonType(List<String> args)` Redis command JSON.TYPE.
`Maybe<Response>`	`keys(String arg0)` Find all keys matching the given pattern.
`Maybe<Response>`	`lastsave()` Get the UNIX time stamp of the last successful save to disk.
`Maybe<Response>`	`latency(List<String> args)` A container for latency diagnostics commands.
`Maybe<Response>`	`lcs(List<String> args)` Find longest common substring.
`Maybe<Response>`	`lindex(String arg0, String arg1)` Get an element from a list by its index.
`Maybe<Response>`	`linsert(String arg0, String arg1, String arg2, String arg3)` Insert an element before or after another element in a list.
`Maybe<Response>`	`llen(String arg0)` Get the length of a list.
`Maybe<Response>`	`lmove(String arg0, String arg1, String arg2, String arg3)` Pop an element from a list, push it to another list and return it.
`Maybe<Response>`	`lmpop(List<String> args)` Pop elements from a list.
`Maybe<Response>`	`lolwut(List<String> args)` Display some computer art and the Redis version.
`Maybe<Response>`	`lpop(List<String> args)` Remove and get the first elements in a list.
`Maybe<Response>`	`lpos(List<String> args)` Return the index of matching elements on a list.
`Maybe<Response>`	`lpush(List<String> args)` Prepend one or multiple elements to a list.
`Maybe<Response>`	`lpushx(List<String> args)` Prepend an element to a list, only if the list exists.
`Maybe<Response>`	`lrange(String arg0, String arg1, String arg2)` Get a range of elements from a list.
`Maybe<Response>`	`lrem(String arg0, String arg1, String arg2)` Remove elements from a list.
`Maybe<Response>`	`lset(String arg0, String arg1, String arg2)` Set the value of an element in a list by its index.
`Maybe<Response>`	`ltrim(String arg0, String arg1, String arg2)` Trim a list to the specified range.
`Maybe<Response>`	`memory(List<String> args)` A container for memory diagnostics commands.
`Maybe<Response>`	`mget(List<String> args)` Get the values of all the given keys.
`Maybe<Response>`	`migrate(List<String> args)` Atomically transfer a key from a Redis instance to another one.
`Maybe<Response>`	`module(List<String> args)` A container for module commands.
`Maybe<Response>`	`monitor()` Listen for all requests received by the server in real time.
`Maybe<Response>`	`move(String arg0, String arg1)` Move a key to another database.
`Maybe<Response>`	`mset(List<String> args)` Set multiple keys to multiple values.
`Maybe<Response>`	`msetnx(List<String> args)` Set multiple keys to multiple values, only if none of the keys exist.
`Maybe<Response>`	`multi()` Mark the start of a transaction block.
`static RedisAPI`	`newInstance(RedisAPI arg)`
`Maybe<Response>`	`object(List<String> args)` A container for object introspection commands.
`Maybe<Response>`	`persist(String arg0)` Remove the expiration from a key.
`Maybe<Response>`	`pexpire(List<String> args)` Set a key's time to live in milliseconds.
`Maybe<Response>`	`pexpireat(List<String> args)` Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`Maybe<Response>`	`pexpiretime(String arg0)` Get the expiration Unix timestamp for a key in milliseconds.
`Maybe<Response>`	`pfadd(List<String> args)` Adds the specified elements to the specified HyperLogLog.
`Maybe<Response>`	`pfcount(List<String> args)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
`Maybe<Response>`	`pfdebug(String arg0, String arg1)` Internal commands for debugging HyperLogLog values.
`Maybe<Response>`	`pfmerge(List<String> args)` Merge N different HyperLogLogs into a single one.
`Maybe<Response>`	`pfselftest()` An internal command for testing HyperLogLog values.
`Maybe<Response>`	`ping(List<String> args)` Ping the server.
`Maybe<Response>`	`psetex(String arg0, String arg1, String arg2)` Set the value and expiration in milliseconds of a key.
`Maybe<Response>`	`psubscribe(List<String> args)` Listen for messages published to channels matching the given patterns.
`Maybe<Response>`	`psync(List<String> args)` Internal command used for replication.
`Maybe<Response>`	`pttl(String arg0)` Get the time to live for a key in milliseconds.
`Maybe<Response>`	`publish(String arg0, String arg1)` Post a message to a channel.
`Maybe<Response>`	`pubsub(List<String> args)` A container for Pub/Sub commands.
`Maybe<Response>`	`punsubscribe(List<String> args)` Stop listening for messages posted to channels matching the given patterns.
`Maybe<Response>`	`quit(List<String> args)` Close the connection.
`Maybe<Response>`	`randomkey()` Return a random key from the keyspace.
`Maybe<Response>`	`readonly()` Enables read queries for a connection to a cluster replica node.
`Maybe<Response>`	`readwrite()` Disables read queries for a connection to a cluster replica node.
`Maybe<Response>`	`rename(String arg0, String arg1)` Rename a key.
`Maybe<Response>`	`renamenx(String arg0, String arg1)` Rename a key, only if the new key does not exist.
`Maybe<Response>`	`replconf(List<String> args)` An internal command for configuring the replication stream.
`Maybe<Response>`	`replicaof(String arg0, String arg1)` Make the server a replica of another instance, or promote it as master.
`Maybe<Response>`	`reset()` Reset the connection.
`Maybe<Response>`	`restore(List<String> args)` Create a key using the provided serialized value, previously obtained using DUMP.
`Maybe<Response>`	`restoreAsking(List<String> args)` An internal command for migrating keys in a cluster.
`Maybe<Response>`	`role()` Return the role of the instance in the context of replication.
`Maybe<Response>`	`rpop(List<String> args)` Remove and get the last elements in a list.
`Maybe<Response>`	`rpoplpush(String arg0, String arg1)` Remove the last element in a list, prepend it to another list and return it.
`Maybe<Response>`	`rpush(List<String> args)` Append one or multiple elements to a list.
`Maybe<Response>`	`rpushx(List<String> args)` Append an element to a list, only if the list exists.
`Maybe<Response>`	`rxAcl(List<String> args)` A container for Access List Control commands.
`Maybe<Response>`	`rxAppend(String arg0, String arg1)` Append a value to a key.
`Maybe<Response>`	`rxAsking()` Sent by cluster clients after an -ASK redirect.
`Maybe<Response>`	`rxAuth(List<String> args)` Authenticate to the server.
`Maybe<Response>`	`rxBfAdd(List<String> args)` Redis command BF.ADD.
`Maybe<Response>`	`rxBfCard(List<String> args)` Redis command BF.CARD.
`Maybe<Response>`	`rxBfDebug(List<String> args)` Redis command BF.DEBUG.
`Maybe<Response>`	`rxBfExists(List<String> args)` Redis command BF.EXISTS.
`Maybe<Response>`	`rxBfInfo(List<String> args)` Redis command BF.INFO.
`Maybe<Response>`	`rxBfInsert(List<String> args)` Redis command BF.INSERT.
`Maybe<Response>`	`rxBfLoadchunk(List<String> args)` Redis command BF.LOADCHUNK.
`Maybe<Response>`	`rxBfMadd(List<String> args)` Redis command BF.MADD.
`Maybe<Response>`	`rxBfMexists(List<String> args)` Redis command BF.MEXISTS.
`Maybe<Response>`	`rxBfReserve(List<String> args)` Redis command BF.RESERVE.
`Maybe<Response>`	`rxBfScandump(List<String> args)` Redis command BF.SCANDUMP.
`Maybe<Response>`	`rxBgrewriteaof()` Asynchronously rewrite the append-only file.
`Maybe<Response>`	`rxBgsave(List<String> args)` Asynchronously save the dataset to disk.
`Maybe<Response>`	`rxBitcount(List<String> args)` Count set bits in a string.
`Maybe<Response>`	`rxBitfield(List<String> args)` Perform arbitrary bitfield integer operations on strings.
`Maybe<Response>`	`rxBitfieldRo(List<String> args)` Perform arbitrary bitfield integer operations on strings.
`Maybe<Response>`	`rxBitop(List<String> args)` Perform bitwise operations between strings.
`Maybe<Response>`	`rxBitpos(List<String> args)` Find first bit set or clear in a string.
`Maybe<Response>`	`rxBlmove(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.
`Maybe<Response>`	`rxBlmpop(List<String> args)` Pop elements from a list, or block until one is available.
`Maybe<Response>`	`rxBlpop(List<String> args)` Remove and get the first element in a list, or block until one is available.
`Maybe<Response>`	`rxBrpop(List<String> args)` Remove and get the last element in a list, or block until one is available.
`Maybe<Response>`	`rxBrpoplpush(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.
`Maybe<Response>`	`rxBzmpop(List<String> args)` Remove and return members with scores in a sorted set or block until one is available.
`Maybe<Response>`	`rxBzpopmax(List<String> args)` Remove and return the member with the highest score from one or more sorted sets, or block until one is available.
`Maybe<Response>`	`rxBzpopmin(List<String> args)` Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.
`Maybe<Response>`	`rxCfAdd(List<String> args)` Redis command CF.ADD.
`Maybe<Response>`	`rxCfAddnx(List<String> args)` Redis command CF.ADDNX.
`Maybe<Response>`	`rxCfCompact(List<String> args)` Redis command CF.COMPACT.
`Maybe<Response>`	`rxCfCount(List<String> args)` Redis command CF.COUNT.
`Maybe<Response>`	`rxCfDebug(List<String> args)` Redis command CF.DEBUG.
`Maybe<Response>`	`rxCfDel(List<String> args)` Redis command CF.DEL.
`Maybe<Response>`	`rxCfExists(List<String> args)` Redis command CF.EXISTS.
`Maybe<Response>`	`rxCfInfo(List<String> args)` Redis command CF.INFO.
`Maybe<Response>`	`rxCfInsert(List<String> args)` Redis command CF.INSERT.
`Maybe<Response>`	`rxCfInsertnx(List<String> args)` Redis command CF.INSERTNX.
`Maybe<Response>`	`rxCfLoadchunk(List<String> args)` Redis command CF.LOADCHUNK.
`Maybe<Response>`	`rxCfMexists(List<String> args)` Redis command CF.MEXISTS.
`Maybe<Response>`	`rxCfReserve(List<String> args)` Redis command CF.RESERVE.
`Maybe<Response>`	`rxCfScandump(List<String> args)` Redis command CF.SCANDUMP.
`Maybe<Response>`	`rxClient(List<String> args)` A container for client connection commands.
`Maybe<Response>`	`rxCluster(List<String> args)` A container for cluster commands.
`Maybe<Response>`	`rxCmsIncrby(List<String> args)` Redis command CMS.INCRBY.
`Maybe<Response>`	`rxCmsInfo(List<String> args)` Redis command CMS.INFO.
`Maybe<Response>`	`rxCmsInitbydim(List<String> args)` Redis command CMS.INITBYDIM.
`Maybe<Response>`	`rxCmsInitbyprob(List<String> args)` Redis command CMS.INITBYPROB.
`Maybe<Response>`	`rxCmsMerge(List<String> args)` Redis command CMS.MERGE.
`Maybe<Response>`	`rxCmsQuery(List<String> args)` Redis command CMS.QUERY.
`Maybe<Response>`	`rxCommand(List<String> args)` Get array of Redis command details.
`Maybe<Response>`	`rxConfig(List<String> args)` A container for server configuration commands.
`Maybe<Response>`	`rxCopy(List<String> args)` Copy a key.
`Maybe<Response>`	`rxDbsize()` Return the number of keys in the selected database.
`Maybe<Response>`	`rxDebug(List<String> args)` A container for debugging commands.
`Maybe<Response>`	`rxDecr(String arg0)` Decrement the integer value of a key by one.
`Maybe<Response>`	`rxDecrby(String arg0, String arg1)` Decrement the integer value of a key by the given number.
`Maybe<Response>`	`rxDel(List<String> args)` Delete a key.
`Maybe<Response>`	`rxDiscard()` Discard all commands issued after MULTI.
`Maybe<Response>`	`rxDump(String arg0)` Return a serialized version of the value stored at the specified key.
`Maybe<Response>`	`rxEcho(String arg0)` Echo the given string.
`Maybe<Response>`	`rxEval(List<String> args)` Execute a Lua script server side.
`Maybe<Response>`	`rxEvalRo(List<String> args)` Execute a read-only Lua script server side.
`Maybe<Response>`	`rxEvalsha(List<String> args)` Execute a Lua script server side.
`Maybe<Response>`	`rxEvalshaRo(List<String> args)` Execute a read-only Lua script server side.
`Maybe<Response>`	`rxExec()` Execute all commands issued after MULTI.
`Maybe<Response>`	`rxExists(List<String> args)` Determine if a key exists.
`Maybe<Response>`	`rxExpire(List<String> args)` Set a key's time to live in seconds.
`Maybe<Response>`	`rxExpireat(List<String> args)` Set the expiration for a key as a UNIX timestamp.
`Maybe<Response>`	`rxExpiretime(String arg0)` Get the expiration Unix timestamp for a key.
`Maybe<Response>`	`rxFailover(List<String> args)` Start a coordinated failover between this server and one of its replicas.
`Maybe<Response>`	`rxFcall(List<String> args)` Invoke a function.
`Maybe<Response>`	`rxFcallRo(List<String> args)` Invoke a read-only function.
`Maybe<Response>`	`rxFlushall(List<String> args)` Remove all keys from all databases.
`Maybe<Response>`	`rxFlushdb(List<String> args)` Remove all keys from the current database.
`Maybe<Response>`	`rxFtAdd(List<String> args)` Redis command FT.ADD.
`Maybe<Response>`	`rxFtAggregate(List<String> args)` Redis command FT.AGGREGATE.
`Maybe<Response>`	`rxFtAliasadd(List<String> args)` Redis command FT.ALIASADD.
`Maybe<Response>`	`rxFtAliasaddifnx(List<String> args)` Redis command FT._ALIASADDIFNX.
`Maybe<Response>`	`rxFtAliasdel(List<String> args)` Redis command FT.ALIASDEL.
`Maybe<Response>`	`rxFtAliasdelifx(List<String> args)` Redis command FT._ALIASDELIFX.
`Maybe<Response>`	`rxFtAliasupdate(List<String> args)` Redis command FT.ALIASUPDATE.
`Maybe<Response>`	`rxFtAlter(List<String> args)` Redis command FT.ALTER.
`Maybe<Response>`	`rxFtAlterifnx(List<String> args)` Redis command FT._ALTERIFNX.
`Maybe<Response>`	`rxFtConfig(List<String> args)` Redis command FT.CONFIG.
`Maybe<Response>`	`rxFtCreate(List<String> args)` Redis command FT.CREATE.
`Maybe<Response>`	`rxFtCreateifnx(List<String> args)` Redis command FT._CREATEIFNX.
`Maybe<Response>`	`rxFtCursor(List<String> args)` Redis command FT.CURSOR.
`Maybe<Response>`	`rxFtDebug(List<String> args)` Redis command FT.DEBUG.
`Maybe<Response>`	`rxFtDel(List<String> args)` Redis command FT.DEL.
`Maybe<Response>`	`rxFtDictadd(List<String> args)` Redis command FT.DICTADD.
`Maybe<Response>`	`rxFtDictdel(List<String> args)` Redis command FT.DICTDEL.
`Maybe<Response>`	`rxFtDictdump(List<String> args)` Redis command FT.DICTDUMP.
`Maybe<Response>`	`rxFtDrop(List<String> args)` Redis command FT.DROP.
`Maybe<Response>`	`rxFtDropifx(List<String> args)` Redis command FT._DROPIFX.
`Maybe<Response>`	`rxFtDropindex(List<String> args)` Redis command FT.DROPINDEX.
`Maybe<Response>`	`rxFtDropindexifx(List<String> args)` Redis command FT._DROPINDEXIFX.
`Maybe<Response>`	`rxFtExplain(List<String> args)` Redis command FT.EXPLAIN.
`Maybe<Response>`	`rxFtExplaincli(List<String> args)` Redis command FT.EXPLAINCLI.
`Maybe<Response>`	`rxFtGet(List<String> args)` Redis command FT.GET.
`Maybe<Response>`	`rxFtInfo(List<String> args)` Redis command FT.INFO.
`Maybe<Response>`	`rxFtList(List<String> args)` Redis command FT._LIST.
`Maybe<Response>`	`rxFtMget(List<String> args)` Redis command FT.MGET.
`Maybe<Response>`	`rxFtProfile(List<String> args)` Redis command FT.PROFILE.
`Maybe<Response>`	`rxFtSafeadd(List<String> args)` Redis command FT.SAFEADD.
`Maybe<Response>`	`rxFtSearch(List<String> args)` Redis command FT.SEARCH.
`Maybe<Response>`	`rxFtSpellcheck(List<String> args)` Redis command FT.SPELLCHECK.
`Maybe<Response>`	`rxFtSugadd(List<String> args)` Redis command FT.SUGADD.
`Maybe<Response>`	`rxFtSugdel(List<String> args)` Redis command FT.SUGDEL.
`Maybe<Response>`	`rxFtSugget(List<String> args)` Redis command FT.SUGGET.
`Maybe<Response>`	`rxFtSuglen(List<String> args)` Redis command FT.SUGLEN.
`Maybe<Response>`	`rxFtSynadd(List<String> args)` Redis command FT.SYNADD.
`Maybe<Response>`	`rxFtSyndump(List<String> args)` Redis command FT.SYNDUMP.
`Maybe<Response>`	`rxFtSynupdate(List<String> args)` Redis command FT.SYNUPDATE.
`Maybe<Response>`	`rxFtTagvals(List<String> args)` Redis command FT.TAGVALS.
`Maybe<Response>`	`rxFunction(List<String> args)` A container for function commands.
`Maybe<Response>`	`rxGeoadd(List<String> args)` Add one or more geospatial items in the geospatial index represented using a sorted set.
`Maybe<Response>`	`rxGeodist(List<String> args)` Returns the distance between two members of a geospatial index.
`Maybe<Response>`	`rxGeohash(List<String> args)` Returns members of a geospatial index as standard geohash strings.
`Maybe<Response>`	`rxGeopos(List<String> args)` Returns longitude and latitude of members of a geospatial index.
`Maybe<Response>`	`rxGeoradius(List<String> args)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
`Maybe<Response>`	`rxGeoradiusbymember(List<String> args)` Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
`Maybe<Response>`	`rxGeoradiusbymemberRo(List<String> args)` A read-only variant for GEORADIUSBYMEMBER.
`Maybe<Response>`	`rxGeoradiusRo(List<String> args)` A read-only variant for GEORADIUS.
`Maybe<Response>`	`rxGeosearch(List<String> args)` Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
`Maybe<Response>`	`rxGeosearchstore(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.
`Maybe<Response>`	`rxGet(String arg0)` Get the value of a key.
`Maybe<Response>`	`rxGetbit(String arg0, String arg1)` Returns the bit value at offset in the string value stored at key.
`Maybe<Response>`	`rxGetdel(String arg0)` Get the value of a key and delete the key.
`Maybe<Response>`	`rxGetex(List<String> args)` Get the value of a key and optionally set its expiration.
`Maybe<Response>`	`rxGetrange(String arg0, String arg1, String arg2)` Get a substring of the string stored at a key.
`Maybe<Response>`	`rxGetset(String arg0, String arg1)` Set the string value of a key and return its old value.
`Maybe<Response>`	`rxGraphBulk(List<String> args)` Redis command GRAPH.BULK.
`Maybe<Response>`	`rxGraphConfig(List<String> args)` Redis command GRAPH.CONFIG.
`Maybe<Response>`	`rxGraphDebug(List<String> args)` Redis command GRAPH.DEBUG.
`Maybe<Response>`	`rxGraphDelete(List<String> args)` Redis command GRAPH.DELETE.
`Maybe<Response>`	`rxGraphExplain(List<String> args)` Redis command GRAPH.EXPLAIN.
`Maybe<Response>`	`rxGraphList(List<String> args)` Redis command GRAPH.LIST.
`Maybe<Response>`	`rxGraphProfile(List<String> args)` Redis command GRAPH.PROFILE.
`Maybe<Response>`	`rxGraphQuery(List<String> args)` Redis command GRAPH.QUERY.
`Maybe<Response>`	`rxGraphRoQuery(List<String> args)` Redis command GRAPH.RO_QUERY.
`Maybe<Response>`	`rxGraphSlowlog(List<String> args)` Redis command GRAPH.SLOWLOG.
`Maybe<Response>`	`rxHdel(List<String> args)` Delete one or more hash fields.
`Maybe<Response>`	`rxHello(List<String> args)` Handshake with Redis.
`Maybe<Response>`	`rxHexists(String arg0, String arg1)` Determine if a hash field exists.
`Maybe<Response>`	`rxHget(String arg0, String arg1)` Get the value of a hash field.
`Maybe<Response>`	`rxHgetall(String arg0)` Get all the fields and values in a hash.
`Maybe<Response>`	`rxHincrby(String arg0, String arg1, String arg2)` Increment the integer value of a hash field by the given number.
`Maybe<Response>`	`rxHincrbyfloat(String arg0, String arg1, String arg2)` Increment the float value of a hash field by the given amount.
`Maybe<Response>`	`rxHkeys(String arg0)` Get all the fields in a hash.
`Maybe<Response>`	`rxHlen(String arg0)` Get the number of fields in a hash.
`Maybe<Response>`	`rxHmget(List<String> args)` Get the values of all the given hash fields.
`Maybe<Response>`	`rxHmset(List<String> args)` Set multiple hash fields to multiple values.
`Maybe<Response>`	`rxHrandfield(List<String> args)` Get one or multiple random fields from a hash.
`Maybe<Response>`	`rxHscan(List<String> args)` Incrementally iterate hash fields and associated values.
`Maybe<Response>`	`rxHset(List<String> args)` Set the string value of a hash field.
`Maybe<Response>`	`rxHsetnx(String arg0, String arg1, String arg2)` Set the value of a hash field, only if the field does not exist.
`Maybe<Response>`	`rxHstrlen(String arg0, String arg1)` Get the length of the value of a hash field.
`Maybe<Response>`	`rxHvals(String arg0)` Get all the values in a hash.
`Maybe<Response>`	`rxIncr(String arg0)` Increment the integer value of a key by one.
`Maybe<Response>`	`rxIncrby(String arg0, String arg1)` Increment the integer value of a key by the given amount.
`Maybe<Response>`	`rxIncrbyfloat(String arg0, String arg1)` Increment the float value of a key by the given amount.
`Maybe<Response>`	`rxInfo(List<String> args)` Get information and statistics about the server.
`Maybe<Response>`	`rxJsonArrappend(List<String> args)` Redis command JSON.ARRAPPEND.
`Maybe<Response>`	`rxJsonArrindex(List<String> args)` Redis command JSON.ARRINDEX.
`Maybe<Response>`	`rxJsonArrinsert(List<String> args)` Redis command JSON.ARRINSERT.
`Maybe<Response>`	`rxJsonArrlen(List<String> args)` Redis command JSON.ARRLEN.
`Maybe<Response>`	`rxJsonArrpop(List<String> args)` Redis command JSON.ARRPOP.
`Maybe<Response>`	`rxJsonArrtrim(List<String> args)` Redis command JSON.ARRTRIM.
`Maybe<Response>`	`rxJsonClear(List<String> args)` Redis command JSON.CLEAR.
`Maybe<Response>`	`rxJsonDebug(List<String> args)` Redis command JSON.DEBUG.
`Maybe<Response>`	`rxJsonDel(List<String> args)` Redis command JSON.DEL.
`Maybe<Response>`	`rxJsonForget(List<String> args)` Redis command JSON.FORGET.
`Maybe<Response>`	`rxJsonGet(List<String> args)` Redis command JSON.GET.
`Maybe<Response>`	`rxJsonMget(List<String> args)` Redis command JSON.MGET.
`Maybe<Response>`	`rxJsonNumincrby(List<String> args)` Redis command JSON.NUMINCRBY.
`Maybe<Response>`	`rxJsonNummultby(List<String> args)` Redis command JSON.NUMMULTBY.
`Maybe<Response>`	`rxJsonNumpowby(List<String> args)` Redis command JSON.NUMPOWBY.
`Maybe<Response>`	`rxJsonObjkeys(List<String> args)` Redis command JSON.OBJKEYS.
`Maybe<Response>`	`rxJsonObjlen(List<String> args)` Redis command JSON.OBJLEN.
`Maybe<Response>`	`rxJsonResp(List<String> args)` Redis command JSON.RESP.
`Maybe<Response>`	`rxJsonSet(List<String> args)` Redis command JSON.SET.
`Maybe<Response>`	`rxJsonStrappend(List<String> args)` Redis command JSON.STRAPPEND.
`Maybe<Response>`	`rxJsonStrlen(List<String> args)` Redis command JSON.STRLEN.
`Maybe<Response>`	`rxJsonToggle(List<String> args)` Redis command JSON.TOGGLE.
`Maybe<Response>`	`rxJsonType(List<String> args)` Redis command JSON.TYPE.
`Maybe<Response>`	`rxKeys(String arg0)` Find all keys matching the given pattern.
`Maybe<Response>`	`rxLastsave()` Get the UNIX time stamp of the last successful save to disk.
`Maybe<Response>`	`rxLatency(List<String> args)` A container for latency diagnostics commands.
`Maybe<Response>`	`rxLcs(List<String> args)` Find longest common substring.
`Maybe<Response>`	`rxLindex(String arg0, String arg1)` Get an element from a list by its index.
`Maybe<Response>`	`rxLinsert(String arg0, String arg1, String arg2, String arg3)` Insert an element before or after another element in a list.
`Maybe<Response>`	`rxLlen(String arg0)` Get the length of a list.
`Maybe<Response>`	`rxLmove(String arg0, String arg1, String arg2, String arg3)` Pop an element from a list, push it to another list and return it.
`Maybe<Response>`	`rxLmpop(List<String> args)` Pop elements from a list.
`Maybe<Response>`	`rxLolwut(List<String> args)` Display some computer art and the Redis version.
`Maybe<Response>`	`rxLpop(List<String> args)` Remove and get the first elements in a list.
`Maybe<Response>`	`rxLpos(List<String> args)` Return the index of matching elements on a list.
`Maybe<Response>`	`rxLpush(List<String> args)` Prepend one or multiple elements to a list.
`Maybe<Response>`	`rxLpushx(List<String> args)` Prepend an element to a list, only if the list exists.
`Maybe<Response>`	`rxLrange(String arg0, String arg1, String arg2)` Get a range of elements from a list.
`Maybe<Response>`	`rxLrem(String arg0, String arg1, String arg2)` Remove elements from a list.
`Maybe<Response>`	`rxLset(String arg0, String arg1, String arg2)` Set the value of an element in a list by its index.
`Maybe<Response>`	`rxLtrim(String arg0, String arg1, String arg2)` Trim a list to the specified range.
`Maybe<Response>`	`rxMemory(List<String> args)` A container for memory diagnostics commands.
`Maybe<Response>`	`rxMget(List<String> args)` Get the values of all the given keys.
`Maybe<Response>`	`rxMigrate(List<String> args)` Atomically transfer a key from a Redis instance to another one.
`Maybe<Response>`	`rxModule(List<String> args)` A container for module commands.
`Maybe<Response>`	`rxMonitor()` Listen for all requests received by the server in real time.
`Maybe<Response>`	`rxMove(String arg0, String arg1)` Move a key to another database.
`Maybe<Response>`	`rxMset(List<String> args)` Set multiple keys to multiple values.
`Maybe<Response>`	`rxMsetnx(List<String> args)` Set multiple keys to multiple values, only if none of the keys exist.
`Maybe<Response>`	`rxMulti()` Mark the start of a transaction block.
`Maybe<Response>`	`rxObject(List<String> args)` A container for object introspection commands.
`Maybe<Response>`	`rxPersist(String arg0)` Remove the expiration from a key.
`Maybe<Response>`	`rxPexpire(List<String> args)` Set a key's time to live in milliseconds.
`Maybe<Response>`	`rxPexpireat(List<String> args)` Set the expiration for a key as a UNIX timestamp specified in milliseconds.
`Maybe<Response>`	`rxPexpiretime(String arg0)` Get the expiration Unix timestamp for a key in milliseconds.
`Maybe<Response>`	`rxPfadd(List<String> args)` Adds the specified elements to the specified HyperLogLog.
`Maybe<Response>`	`rxPfcount(List<String> args)` Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
`Maybe<Response>`	`rxPfdebug(String arg0, String arg1)` Internal commands for debugging HyperLogLog values.
`Maybe<Response>`	`rxPfmerge(List<String> args)` Merge N different HyperLogLogs into a single one.
`Maybe<Response>`	`rxPfselftest()` An internal command for testing HyperLogLog values.
`Maybe<Response>`	`rxPing(List<String> args)` Ping the server.
`Maybe<Response>`	`rxPsetex(String arg0, String arg1, String arg2)` Set the value and expiration in milliseconds of a key.
`Maybe<Response>`	`rxPsubscribe(List<String> args)` Listen for messages published to channels matching the given patterns.
`Maybe<Response>`	`rxPsync(List<String> args)` Internal command used for replication.
`Maybe<Response>`	`rxPttl(String arg0)` Get the time to live for a key in milliseconds.
`Maybe<Response>`	`rxPublish(String arg0, String arg1)` Post a message to a channel.
`Maybe<Response>`	`rxPubsub(List<String> args)` A container for Pub/Sub commands.
`Maybe<Response>`	`rxPunsubscribe(List<String> args)` Stop listening for messages posted to channels matching the given patterns.
`Maybe<Response>`	`rxQuit(List<String> args)` Close the connection.
`Maybe<Response>`	`rxRandomkey()` Return a random key from the keyspace.
`Maybe<Response>`	`rxReadonly()` Enables read queries for a connection to a cluster replica node.
`Maybe<Response>`	`rxReadwrite()` Disables read queries for a connection to a cluster replica node.
`Maybe<Response>`	`rxRename(String arg0, String arg1)` Rename a key.
`Maybe<Response>`	`rxRenamenx(String arg0, String arg1)` Rename a key, only if the new key does not exist.
`Maybe<Response>`	`rxReplconf(List<String> args)` An internal command for configuring the replication stream.
`Maybe<Response>`	`rxReplicaof(String arg0, String arg1)` Make the server a replica of another instance, or promote it as master.
`Maybe<Response>`	`rxReset()` Reset the connection.
`Maybe<Response>`	`rxRestore(List<String> args)` Create a key using the provided serialized value, previously obtained using DUMP.
`Maybe<Response>`	`rxRestoreAsking(List<String> args)` An internal command for migrating keys in a cluster.
`Maybe<Response>`	`rxRole()` Return the role of the instance in the context of replication.
`Maybe<Response>`	`rxRpop(List<String> args)` Remove and get the last elements in a list.
`Maybe<Response>`	`rxRpoplpush(String arg0, String arg1)` Remove the last element in a list, prepend it to another list and return it.
`Maybe<Response>`	`rxRpush(List<String> args)` Append one or multiple elements to a list.
`Maybe<Response>`	`rxRpushx(List<String> args)` Append an element to a list, only if the list exists.
`Maybe<Response>`	`rxSadd(List<String> args)` Add one or more members to a set.
`Maybe<Response>`	`rxSave()` Synchronously save the dataset to disk.
`Maybe<Response>`	`rxScan(List<String> args)` Incrementally iterate the keys space.
`Maybe<Response>`	`rxScard(String arg0)` Get the number of members in a set.
`Maybe<Response>`	`rxScript(List<String> args)` A container for Lua scripts management commands.
`Maybe<Response>`	`rxSdiff(List<String> args)` Subtract multiple sets.
`Maybe<Response>`	`rxSdiffstore(List<String> args)` Subtract multiple sets and store the resulting set in a key.
`Maybe<Response>`	`rxSelect(String arg0)` Change the selected database for the current connection.
`Maybe<Response>`	`rxSet(List<String> args)` Set the string value of a key.
`Maybe<Response>`	`rxSetbit(String arg0, String arg1, String arg2)` Sets or clears the bit at offset in the string value stored at key.
`Maybe<Response>`	`rxSetex(String arg0, String arg1, String arg2)` Set the value and expiration of a key.
`Maybe<Response>`	`rxSetnx(String arg0, String arg1)` Set the value of a key, only if the key does not exist.
`Maybe<Response>`	`rxSetrange(String arg0, String arg1, String arg2)` Overwrite part of a string at key starting at the specified offset.
`Maybe<Response>`	`rxShutdown(List<String> args)` Synchronously save the dataset to disk and then shut down the server.
`Maybe<Response>`	`rxSinter(List<String> args)` Intersect multiple sets.
`Maybe<Response>`	`rxSintercard(List<String> args)` Intersect multiple sets and return the cardinality of the result.
`Maybe<Response>`	`rxSinterstore(List<String> args)` Intersect multiple sets and store the resulting set in a key.
`Maybe<Response>`	`rxSismember(String arg0, String arg1)` Determine if a given value is a member of a set.
`Maybe<Response>`	`rxSlaveof(String arg0, String arg1)` Make the server a replica of another instance, or promote it as master.
`Maybe<Response>`	`rxSlowlog(List<String> args)` A container for slow log commands.
`Maybe<Response>`	`rxSmembers(String arg0)` Get all the members in a set.
`Maybe<Response>`	`rxSmismember(List<String> args)` Returns the membership associated with the given elements for a set.
`Maybe<Response>`	`rxSmove(String arg0, String arg1, String arg2)` Move a member from one set to another.
`Maybe<Response>`	`rxSort(List<String> args)` Sort the elements in a list, set or sorted set.
`Maybe<Response>`	`rxSortRo(List<String> args)` Sort the elements in a list, set or sorted set.
`Maybe<Response>`	`rxSpop(List<String> args)` Remove and return one or multiple random members from a set.
`Maybe<Response>`	`rxSpublish(String arg0, String arg1)` Post a message to a shard channel.
`Maybe<Response>`	`rxSrandmember(List<String> args)` Get one or multiple random members from a set.
`Maybe<Response>`	`rxSrem(List<String> args)` Remove one or more members from a set.
`Maybe<Response>`	`rxSscan(List<String> args)` Incrementally iterate Set elements.
`Maybe<Response>`	`rxSsubscribe(List<String> args)` Listen for messages published to the given shard channels.
`Maybe<Response>`	`rxStrlen(String arg0)` Get the length of the value stored in a key.
`Maybe<Response>`	`rxSubscribe(List<String> args)` Listen for messages published to the given channels.
`Maybe<Response>`	`rxSubstr(String arg0, String arg1, String arg2)` Get a substring of the string stored at a key.
`Maybe<Response>`	`rxSunion(List<String> args)` Add multiple sets.
`Maybe<Response>`	`rxSunionstore(List<String> args)` Add multiple sets and store the resulting set in a key.
`Maybe<Response>`	`rxSunsubscribe(List<String> args)` Stop listening for messages posted to the given shard channels.
`Maybe<Response>`	`rxSwapdb(String arg0, String arg1)` Swaps two Redis databases.
`Maybe<Response>`	`rxSync()` Internal command used for replication.
`Maybe<Response>`	`rxTdigestAdd(List<String> args)` Redis command TDIGEST.ADD.
`Maybe<Response>`	`rxTdigestByrank(List<String> args)` Redis command TDIGEST.BYRANK.
`Maybe<Response>`	`rxTdigestByrevrank(List<String> args)` Redis command TDIGEST.BYREVRANK.
`Maybe<Response>`	`rxTdigestCdf(List<String> args)` Redis command TDIGEST.CDF.
`Maybe<Response>`	`rxTdigestCreate(List<String> args)` Redis command TDIGEST.CREATE.
`Maybe<Response>`	`rxTdigestInfo(List<String> args)` Redis command TDIGEST.INFO.
`Maybe<Response>`	`rxTdigestMax(List<String> args)` Redis command TDIGEST.MAX.
`Maybe<Response>`	`rxTdigestMerge(List<String> args)` Redis command TDIGEST.MERGE.
`Maybe<Response>`	`rxTdigestMin(List<String> args)` Redis command TDIGEST.MIN.
`Maybe<Response>`	`rxTdigestQuantile(List<String> args)` Redis command TDIGEST.QUANTILE.
`Maybe<Response>`	`rxTdigestRank(List<String> args)` Redis command TDIGEST.RANK.
`Maybe<Response>`	`rxTdigestReset(List<String> args)` Redis command TDIGEST.RESET.
`Maybe<Response>`	`rxTdigestRevrank(List<String> args)` Redis command TDIGEST.REVRANK.
`Maybe<Response>`	`rxTdigestTrimmedMean(List<String> args)` Redis command TDIGEST.TRIMMED_MEAN.
`Maybe<Response>`	`rxTime()` Return the current server time.
`Maybe<Response>`	`rxTimeseriesClusterset(List<String> args)` Redis command TIMESERIES.CLUSTERSET.
`Maybe<Response>`	`rxTimeseriesClustersetfromshard(List<String> args)` Redis command TIMESERIES.CLUSTERSETFROMSHARD.
`Maybe<Response>`	`rxTimeseriesHello(List<String> args)` Redis command TIMESERIES.HELLO.
`Maybe<Response>`	`rxTimeseriesInfocluster(List<String> args)` Redis command TIMESERIES.INFOCLUSTER.
`Maybe<Response>`	`rxTimeseriesInnercommunication(List<String> args)` Redis command TIMESERIES.INNERCOMMUNICATION.
`Maybe<Response>`	`rxTimeseriesNetworktest(List<String> args)` Redis command TIMESERIES.NETWORKTEST.
`Maybe<Response>`	`rxTimeseriesRefreshcluster(List<String> args)` Redis command TIMESERIES.REFRESHCLUSTER.
`Maybe<Response>`	`rxTopkAdd(List<String> args)` Redis command TOPK.ADD.
`Maybe<Response>`	`rxTopkCount(List<String> args)` Redis command TOPK.COUNT.
`Maybe<Response>`	`rxTopkIncrby(List<String> args)` Redis command TOPK.INCRBY.
`Maybe<Response>`	`rxTopkInfo(List<String> args)` Redis command TOPK.INFO.
`Maybe<Response>`	`rxTopkList(List<String> args)` Redis command TOPK.LIST.
`Maybe<Response>`	`rxTopkQuery(List<String> args)` Redis command TOPK.QUERY.
`Maybe<Response>`	`rxTopkReserve(List<String> args)` Redis command TOPK.RESERVE.
`Maybe<Response>`	`rxTouch(List<String> args)` Alters the last access time of a key(s).
`Maybe<Response>`	`rxTsAdd(List<String> args)` Redis command TS.ADD.
`Maybe<Response>`	`rxTsAlter(List<String> args)` Redis command TS.ALTER.
`Maybe<Response>`	`rxTsCreate(List<String> args)` Redis command TS.CREATE.
`Maybe<Response>`	`rxTsCreaterule(List<String> args)` Redis command TS.CREATERULE.
`Maybe<Response>`	`rxTsDecrby(List<String> args)` Redis command TS.DECRBY.
`Maybe<Response>`	`rxTsDel(List<String> args)` Redis command TS.DEL.
`Maybe<Response>`	`rxTsDeleterule(List<String> args)` Redis command TS.DELETERULE.
`Maybe<Response>`	`rxTsGet(List<String> args)` Redis command TS.GET.
`Maybe<Response>`	`rxTsIncrby(List<String> args)` Redis command TS.INCRBY.
`Maybe<Response>`	`rxTsInfo(List<String> args)` Redis command TS.INFO.
`Maybe<Response>`	`rxTsMadd(List<String> args)` Redis command TS.MADD.
`Maybe<Response>`	`rxTsMget(List<String> args)` Redis command TS.MGET.
`Maybe<Response>`	`rxTsMrange(List<String> args)` Redis command TS.MRANGE.
`Maybe<Response>`	`rxTsMrevrange(List<String> args)` Redis command TS.MREVRANGE.
`Maybe<Response>`	`rxTsQueryindex(List<String> args)` Redis command TS.QUERYINDEX.
`Maybe<Response>`	`rxTsRange(List<String> args)` Redis command TS.RANGE.
`Maybe<Response>`	`rxTsRevrange(List<String> args)` Redis command TS.REVRANGE.
`Maybe<Response>`	`rxTtl(String arg0)` Get the time to live for a key in seconds.
`Maybe<Response>`	`rxType(String arg0)` Determine the type stored at key.
`Maybe<Response>`	`rxUnlink(List<String> args)` Delete a key asynchronously in another thread.
`Maybe<Response>`	`rxUnsubscribe(List<String> args)` Stop listening for messages posted to the given channels.
`Maybe<Response>`	`rxUnwatch()` Forget about all watched keys.
`Maybe<Response>`	`rxWait(String arg0, String arg1)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
`Maybe<Response>`	`rxWatch(List<String> args)` Watch the given keys to determine execution of the MULTI/EXEC block.
`Maybe<Response>`	`rxXack(List<String> args)` Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group.
`Maybe<Response>`	`rxXadd(List<String> args)` Appends a new entry to a stream.
`Maybe<Response>`	`rxXautoclaim(List<String> args)` Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
`Maybe<Response>`	`rxXclaim(List<String> args)` Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
`Maybe<Response>`	`rxXdel(List<String> args)` Removes the specified entries from the stream.
`Maybe<Response>`	`rxXgroup(List<String> args)` A container for consumer groups commands.
`Maybe<Response>`	`rxXinfo(List<String> args)` A container for stream introspection commands.
`Maybe<Response>`	`rxXlen(String arg0)` Return the number of entries in a stream.
`Maybe<Response>`	`rxXpending(List<String> args)` Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
`Maybe<Response>`	`rxXrange(List<String> args)` Return a range of elements in a stream, with IDs matching the specified IDs interval.
`Maybe<Response>`	`rxXread(List<String> args)` Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream.
`Maybe<Response>`	`rxXreadgroup(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.
`Maybe<Response>`	`rxXrevrange(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.
`Maybe<Response>`	`rxXsetid(List<String> args)` An internal command for replicating stream values.
`Maybe<Response>`	`rxXtrim(List<String> args)` Trims the stream to (approximately if '~' is passed) a certain size.
`Maybe<Response>`	`rxZadd(List<String> args)` Add one or more members to a sorted set, or update its score if it already exists.
`Maybe<Response>`	`rxZcard(String arg0)` Get the number of members in a sorted set.
`Maybe<Response>`	`rxZcount(String arg0, String arg1, String arg2)` Count the members in a sorted set with scores within the given values.
`Maybe<Response>`	`rxZdiff(List<String> args)` Subtract multiple sorted sets.
`Maybe<Response>`	`rxZdiffstore(List<String> args)` Subtract multiple sorted sets and store the resulting sorted set in a new key.
`Maybe<Response>`	`rxZincrby(String arg0, String arg1, String arg2)` Increment the score of a member in a sorted set.
`Maybe<Response>`	`rxZinter(List<String> args)` Intersect multiple sorted sets.
`Maybe<Response>`	`rxZintercard(List<String> args)` Intersect multiple sorted sets and return the cardinality of the result.
`Maybe<Response>`	`rxZinterstore(List<String> args)` Intersect multiple sorted sets and store the resulting sorted set in a new key.
`Maybe<Response>`	`rxZlexcount(String arg0, String arg1, String arg2)` Count the number of members in a sorted set between a given lexicographical range.
`Maybe<Response>`	`rxZmpop(List<String> args)` Remove and return members with scores in a sorted set.
`Maybe<Response>`	`rxZmscore(List<String> args)` Get the score associated with the given members in a sorted set.
`Maybe<Response>`	`rxZpopmax(List<String> args)` Remove and return members with the highest scores in a sorted set.
`Maybe<Response>`	`rxZpopmin(List<String> args)` Remove and return members with the lowest scores in a sorted set.
`Maybe<Response>`	`rxZrandmember(List<String> args)` Get one or multiple random elements from a sorted set.
`Maybe<Response>`	`rxZrange(List<String> args)` Return a range of members in a sorted set.
`Maybe<Response>`	`rxZrangebylex(List<String> args)` Return a range of members in a sorted set, by lexicographical range.
`Maybe<Response>`	`rxZrangebyscore(List<String> args)` Return a range of members in a sorted set, by score.
`Maybe<Response>`	`rxZrangestore(List<String> args)` Store a range of members from sorted set into another key.
`Maybe<Response>`	`rxZrank(String arg0, String arg1)` Determine the index of a member in a sorted set.
`Maybe<Response>`	`rxZrem(List<String> args)` Remove one or more members from a sorted set.
`Maybe<Response>`	`rxZremrangebylex(String arg0, String arg1, String arg2)` Remove all members in a sorted set between the given lexicographical range.
`Maybe<Response>`	`rxZremrangebyrank(String arg0, String arg1, String arg2)` Remove all members in a sorted set within the given indexes.
`Maybe<Response>`	`rxZremrangebyscore(String arg0, String arg1, String arg2)` Remove all members in a sorted set within the given scores.
`Maybe<Response>`	`rxZrevrange(List<String> args)` Return a range of members in a sorted set, by index, with scores ordered from high to low.
`Maybe<Response>`	`rxZrevrangebylex(List<String> args)` Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
`Maybe<Response>`	`rxZrevrangebyscore(List<String> args)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
`Maybe<Response>`	`rxZrevrank(String arg0, String arg1)` Determine the index of a member in a sorted set, with scores ordered from high to low.
`Maybe<Response>`	`rxZscan(List<String> args)` Incrementally iterate sorted sets elements and associated scores.
`Maybe<Response>`	`rxZscore(String arg0, String arg1)` Get the score associated with the given member in a sorted set.
`Maybe<Response>`	`rxZunion(List<String> args)` Add multiple sorted sets.
`Maybe<Response>`	`rxZunionstore(List<String> args)` Add multiple sorted sets and store the resulting sorted set in a new key.
`Maybe<Response>`	`sadd(List<String> args)` Add one or more members to a set.
`Maybe<Response>`	`save()` Synchronously save the dataset to disk.
`Maybe<Response>`	`scan(List<String> args)` Incrementally iterate the keys space.
`Maybe<Response>`	`scard(String arg0)` Get the number of members in a set.
`Maybe<Response>`	`script(List<String> args)` A container for Lua scripts management commands.
`Maybe<Response>`	`sdiff(List<String> args)` Subtract multiple sets.
`Maybe<Response>`	`sdiffstore(List<String> args)` Subtract multiple sets and store the resulting set in a key.
`Maybe<Response>`	`select(String arg0)` Change the selected database for the current connection.
`Maybe<Response>`	`set(List<String> args)` Set the string value of a key.
`Maybe<Response>`	`setbit(String arg0, String arg1, String arg2)` Sets or clears the bit at offset in the string value stored at key.
`Maybe<Response>`	`setex(String arg0, String arg1, String arg2)` Set the value and expiration of a key.
`Maybe<Response>`	`setnx(String arg0, String arg1)` Set the value of a key, only if the key does not exist.
`Maybe<Response>`	`setrange(String arg0, String arg1, String arg2)` Overwrite part of a string at key starting at the specified offset.
`Maybe<Response>`	`shutdown(List<String> args)` Synchronously save the dataset to disk and then shut down the server.
`Maybe<Response>`	`sinter(List<String> args)` Intersect multiple sets.
`Maybe<Response>`	`sintercard(List<String> args)` Intersect multiple sets and return the cardinality of the result.
`Maybe<Response>`	`sinterstore(List<String> args)` Intersect multiple sets and store the resulting set in a key.
`Maybe<Response>`	`sismember(String arg0, String arg1)` Determine if a given value is a member of a set.
`Maybe<Response>`	`slaveof(String arg0, String arg1)` Make the server a replica of another instance, or promote it as master.
`Maybe<Response>`	`slowlog(List<String> args)` A container for slow log commands.
`Maybe<Response>`	`smembers(String arg0)` Get all the members in a set.
`Maybe<Response>`	`smismember(List<String> args)` Returns the membership associated with the given elements for a set.
`Maybe<Response>`	`smove(String arg0, String arg1, String arg2)` Move a member from one set to another.
`Maybe<Response>`	`sort(List<String> args)` Sort the elements in a list, set or sorted set.
`Maybe<Response>`	`sortRo(List<String> args)` Sort the elements in a list, set or sorted set.
`Maybe<Response>`	`spop(List<String> args)` Remove and return one or multiple random members from a set.
`Maybe<Response>`	`spublish(String arg0, String arg1)` Post a message to a shard channel.
`Maybe<Response>`	`srandmember(List<String> args)` Get one or multiple random members from a set.
`Maybe<Response>`	`srem(List<String> args)` Remove one or more members from a set.
`Maybe<Response>`	`sscan(List<String> args)` Incrementally iterate Set elements.
`Maybe<Response>`	`ssubscribe(List<String> args)` Listen for messages published to the given shard channels.
`Maybe<Response>`	`strlen(String arg0)` Get the length of the value stored in a key.
`Maybe<Response>`	`subscribe(List<String> args)` Listen for messages published to the given channels.
`Maybe<Response>`	`substr(String arg0, String arg1, String arg2)` Get a substring of the string stored at a key.
`Maybe<Response>`	`sunion(List<String> args)` Add multiple sets.
`Maybe<Response>`	`sunionstore(List<String> args)` Add multiple sets and store the resulting set in a key.
`Maybe<Response>`	`sunsubscribe(List<String> args)` Stop listening for messages posted to the given shard channels.
`Maybe<Response>`	`swapdb(String arg0, String arg1)` Swaps two Redis databases.
`Maybe<Response>`	`sync()` Internal command used for replication.
`Maybe<Response>`	`tdigestAdd(List<String> args)` Redis command TDIGEST.ADD.
`Maybe<Response>`	`tdigestByrank(List<String> args)` Redis command TDIGEST.BYRANK.
`Maybe<Response>`	`tdigestByrevrank(List<String> args)` Redis command TDIGEST.BYREVRANK.
`Maybe<Response>`	`tdigestCdf(List<String> args)` Redis command TDIGEST.CDF.
`Maybe<Response>`	`tdigestCreate(List<String> args)` Redis command TDIGEST.CREATE.
`Maybe<Response>`	`tdigestInfo(List<String> args)` Redis command TDIGEST.INFO.
`Maybe<Response>`	`tdigestMax(List<String> args)` Redis command TDIGEST.MAX.
`Maybe<Response>`	`tdigestMerge(List<String> args)` Redis command TDIGEST.MERGE.
`Maybe<Response>`	`tdigestMin(List<String> args)` Redis command TDIGEST.MIN.
`Maybe<Response>`	`tdigestQuantile(List<String> args)` Redis command TDIGEST.QUANTILE.
`Maybe<Response>`	`tdigestRank(List<String> args)` Redis command TDIGEST.RANK.
`Maybe<Response>`	`tdigestReset(List<String> args)` Redis command TDIGEST.RESET.
`Maybe<Response>`	`tdigestRevrank(List<String> args)` Redis command TDIGEST.REVRANK.
`Maybe<Response>`	`tdigestTrimmedMean(List<String> args)` Redis command TDIGEST.TRIMMED_MEAN.
`Maybe<Response>`	`time()` Return the current server time.
`Maybe<Response>`	`timeseriesClusterset(List<String> args)` Redis command TIMESERIES.CLUSTERSET.
`Maybe<Response>`	`timeseriesClustersetfromshard(List<String> args)` Redis command TIMESERIES.CLUSTERSETFROMSHARD.
`Maybe<Response>`	`timeseriesHello(List<String> args)` Redis command TIMESERIES.HELLO.
`Maybe<Response>`	`timeseriesInfocluster(List<String> args)` Redis command TIMESERIES.INFOCLUSTER.
`Maybe<Response>`	`timeseriesInnercommunication(List<String> args)` Redis command TIMESERIES.INNERCOMMUNICATION.
`Maybe<Response>`	`timeseriesNetworktest(List<String> args)` Redis command TIMESERIES.NETWORKTEST.
`Maybe<Response>`	`timeseriesRefreshcluster(List<String> args)` Redis command TIMESERIES.REFRESHCLUSTER.
`Maybe<Response>`	`topkAdd(List<String> args)` Redis command TOPK.ADD.
`Maybe<Response>`	`topkCount(List<String> args)` Redis command TOPK.COUNT.
`Maybe<Response>`	`topkIncrby(List<String> args)` Redis command TOPK.INCRBY.
`Maybe<Response>`	`topkInfo(List<String> args)` Redis command TOPK.INFO.
`Maybe<Response>`	`topkList(List<String> args)` Redis command TOPK.LIST.
`Maybe<Response>`	`topkQuery(List<String> args)` Redis command TOPK.QUERY.
`Maybe<Response>`	`topkReserve(List<String> args)` Redis command TOPK.RESERVE.
`String`	`toString()`
`Maybe<Response>`	`touch(List<String> args)` Alters the last access time of a key(s).
`Maybe<Response>`	`tsAdd(List<String> args)` Redis command TS.ADD.
`Maybe<Response>`	`tsAlter(List<String> args)` Redis command TS.ALTER.
`Maybe<Response>`	`tsCreate(List<String> args)` Redis command TS.CREATE.
`Maybe<Response>`	`tsCreaterule(List<String> args)` Redis command TS.CREATERULE.
`Maybe<Response>`	`tsDecrby(List<String> args)` Redis command TS.DECRBY.
`Maybe<Response>`	`tsDel(List<String> args)` Redis command TS.DEL.
`Maybe<Response>`	`tsDeleterule(List<String> args)` Redis command TS.DELETERULE.
`Maybe<Response>`	`tsGet(List<String> args)` Redis command TS.GET.
`Maybe<Response>`	`tsIncrby(List<String> args)` Redis command TS.INCRBY.
`Maybe<Response>`	`tsInfo(List<String> args)` Redis command TS.INFO.
`Maybe<Response>`	`tsMadd(List<String> args)` Redis command TS.MADD.
`Maybe<Response>`	`tsMget(List<String> args)` Redis command TS.MGET.
`Maybe<Response>`	`tsMrange(List<String> args)` Redis command TS.MRANGE.
`Maybe<Response>`	`tsMrevrange(List<String> args)` Redis command TS.MREVRANGE.
`Maybe<Response>`	`tsQueryindex(List<String> args)` Redis command TS.QUERYINDEX.
`Maybe<Response>`	`tsRange(List<String> args)` Redis command TS.RANGE.
`Maybe<Response>`	`tsRevrange(List<String> args)` Redis command TS.REVRANGE.
`Maybe<Response>`	`ttl(String arg0)` Get the time to live for a key in seconds.
`Maybe<Response>`	`type(String arg0)` Determine the type stored at key.
`Maybe<Response>`	`unlink(List<String> args)` Delete a key asynchronously in another thread.
`Maybe<Response>`	`unsubscribe(List<String> args)` Stop listening for messages posted to the given channels.
`Maybe<Response>`	`unwatch()` Forget about all watched keys.
`Maybe<Response>`	`wait(String arg0, String arg1)` Wait for the synchronous replication of all the write commands sent in the context of the current connection.
`Maybe<Response>`	`watch(List<String> args)` Watch the given keys to determine execution of the MULTI/EXEC block.
`Maybe<Response>`	`xack(List<String> args)` Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group.
`Maybe<Response>`	`xadd(List<String> args)` Appends a new entry to a stream.
`Maybe<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.
`Maybe<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.
`Maybe<Response>`	`xdel(List<String> args)` Removes the specified entries from the stream.
`Maybe<Response>`	`xgroup(List<String> args)` A container for consumer groups commands.
`Maybe<Response>`	`xinfo(List<String> args)` A container for stream introspection commands.
`Maybe<Response>`	`xlen(String arg0)` Return the number of entries in a stream.
`Maybe<Response>`	`xpending(List<String> args)` Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
`Maybe<Response>`	`xrange(List<String> args)` Return a range of elements in a stream, with IDs matching the specified IDs interval.
`Maybe<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.
`Maybe<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.
`Maybe<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.
`Maybe<Response>`	`xsetid(List<String> args)` An internal command for replicating stream values.
`Maybe<Response>`	`xtrim(List<String> args)` Trims the stream to (approximately if '~' is passed) a certain size.
`Maybe<Response>`	`zadd(List<String> args)` Add one or more members to a sorted set, or update its score if it already exists.
`Maybe<Response>`	`zcard(String arg0)` Get the number of members in a sorted set.
`Maybe<Response>`	`zcount(String arg0, String arg1, String arg2)` Count the members in a sorted set with scores within the given values.
`Maybe<Response>`	`zdiff(List<String> args)` Subtract multiple sorted sets.
`Maybe<Response>`	`zdiffstore(List<String> args)` Subtract multiple sorted sets and store the resulting sorted set in a new key.
`Maybe<Response>`	`zincrby(String arg0, String arg1, String arg2)` Increment the score of a member in a sorted set.
`Maybe<Response>`	`zinter(List<String> args)` Intersect multiple sorted sets.
`Maybe<Response>`	`zintercard(List<String> args)` Intersect multiple sorted sets and return the cardinality of the result.
`Maybe<Response>`	`zinterstore(List<String> args)` Intersect multiple sorted sets and store the resulting sorted set in a new key.
`Maybe<Response>`	`zlexcount(String arg0, String arg1, String arg2)` Count the number of members in a sorted set between a given lexicographical range.
`Maybe<Response>`	`zmpop(List<String> args)` Remove and return members with scores in a sorted set.
`Maybe<Response>`	`zmscore(List<String> args)` Get the score associated with the given members in a sorted set.
`Maybe<Response>`	`zpopmax(List<String> args)` Remove and return members with the highest scores in a sorted set.
`Maybe<Response>`	`zpopmin(List<String> args)` Remove and return members with the lowest scores in a sorted set.
`Maybe<Response>`	`zrandmember(List<String> args)` Get one or multiple random elements from a sorted set.
`Maybe<Response>`	`zrange(List<String> args)` Return a range of members in a sorted set.
`Maybe<Response>`	`zrangebylex(List<String> args)` Return a range of members in a sorted set, by lexicographical range.
`Maybe<Response>`	`zrangebyscore(List<String> args)` Return a range of members in a sorted set, by score.
`Maybe<Response>`	`zrangestore(List<String> args)` Store a range of members from sorted set into another key.
`Maybe<Response>`	`zrank(String arg0, String arg1)` Determine the index of a member in a sorted set.
`Maybe<Response>`	`zrem(List<String> args)` Remove one or more members from a sorted set.
`Maybe<Response>`	`zremrangebylex(String arg0, String arg1, String arg2)` Remove all members in a sorted set between the given lexicographical range.
`Maybe<Response>`	`zremrangebyrank(String arg0, String arg1, String arg2)` Remove all members in a sorted set within the given indexes.
`Maybe<Response>`	`zremrangebyscore(String arg0, String arg1, String arg2)` Remove all members in a sorted set within the given scores.
`Maybe<Response>`	`zrevrange(List<String> args)` Return a range of members in a sorted set, by index, with scores ordered from high to low.
`Maybe<Response>`	`zrevrangebylex(List<String> args)` Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
`Maybe<Response>`	`zrevrangebyscore(List<String> args)` Return a range of members in a sorted set, by score, with scores ordered from high to low.
`Maybe<Response>`	`zrevrank(String arg0, String arg1)` Determine the index of a member in a sorted set, with scores ordered from high to low.
`Maybe<Response>`	`zscan(List<String> args)` Incrementally iterate sorted sets elements and associated scores.
`Maybe<Response>`	`zscore(String arg0, String arg1)` Get the score associated with the given member in a sorted set.
`Maybe<Response>`	`zunion(List<String> args)` Add multiple sorted sets.
`Maybe<Response>`	`zunionstore(List<String> args)` Add multiple sorted sets and store the resulting sorted set in a new key.

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

- Field Detail
  - __TYPE_ARG
```
public static final io.vertx.lang.rx.TypeArg<RedisAPI> __TYPE_ARG
```
- Constructor Detail
  - RedisAPI
```
public RedisAPI(RedisAPI delegate)
```
  - RedisAPI
```
public RedisAPI(Object delegate)
```
- Method Detail
  - 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
  - getDelegate
```
public RedisAPI getDelegate()
```
  - close
```
public void close()
```
  - ftAdd
```
public Maybe<Response> ftAdd(List<String> args)
```
    Redis command FT.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtAdd
```
public Maybe<Response> rxFtAdd(List<String> args)
```
    Redis command FT.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftAggregate
```
public Maybe<Response> ftAggregate(List<String> args)
```
    Redis command FT.AGGREGATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtAggregate
```
public Maybe<Response> rxFtAggregate(List<String> args)
```
    Redis command FT.AGGREGATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftAliasadd
```
public Maybe<Response> ftAliasadd(List<String> args)
```
    Redis command FT.ALIASADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtAliasadd
```
public Maybe<Response> rxFtAliasadd(List<String> args)
```
    Redis command FT.ALIASADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftAliasdel
```
public Maybe<Response> ftAliasdel(List<String> args)
```
    Redis command FT.ALIASDEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtAliasdel
```
public Maybe<Response> rxFtAliasdel(List<String> args)
```
    Redis command FT.ALIASDEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftAliasupdate
```
public Maybe<Response> ftAliasupdate(List<String> args)
```
    Redis command FT.ALIASUPDATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtAliasupdate
```
public Maybe<Response> rxFtAliasupdate(List<String> args)
```
    Redis command FT.ALIASUPDATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftAlter
```
public Maybe<Response> ftAlter(List<String> args)
```
    Redis command FT.ALTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtAlter
```
public Maybe<Response> rxFtAlter(List<String> args)
```
    Redis command FT.ALTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftConfig
```
public Maybe<Response> ftConfig(List<String> args)
```
    Redis command FT.CONFIG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtConfig
```
public Maybe<Response> rxFtConfig(List<String> args)
```
    Redis command FT.CONFIG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftCreate
```
public Maybe<Response> ftCreate(List<String> args)
```
    Redis command FT.CREATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtCreate
```
public Maybe<Response> rxFtCreate(List<String> args)
```
    Redis command FT.CREATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftCursor
```
public Maybe<Response> ftCursor(List<String> args)
```
    Redis command FT.CURSOR.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtCursor
```
public Maybe<Response> rxFtCursor(List<String> args)
```
    Redis command FT.CURSOR.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftDebug
```
public Maybe<Response> ftDebug(List<String> args)
```
    Redis command FT.DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtDebug
```
public Maybe<Response> rxFtDebug(List<String> args)
```
    Redis command FT.DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftDel
```
public Maybe<Response> ftDel(List<String> args)
```
    Redis command FT.DEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtDel
```
public Maybe<Response> rxFtDel(List<String> args)
```
    Redis command FT.DEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftDictadd
```
public Maybe<Response> ftDictadd(List<String> args)
```
    Redis command FT.DICTADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtDictadd
```
public Maybe<Response> rxFtDictadd(List<String> args)
```
    Redis command FT.DICTADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftDictdel
```
public Maybe<Response> ftDictdel(List<String> args)
```
    Redis command FT.DICTDEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtDictdel
```
public Maybe<Response> rxFtDictdel(List<String> args)
```
    Redis command FT.DICTDEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftDictdump
```
public Maybe<Response> ftDictdump(List<String> args)
```
    Redis command FT.DICTDUMP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtDictdump
```
public Maybe<Response> rxFtDictdump(List<String> args)
```
    Redis command FT.DICTDUMP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftDrop
```
public Maybe<Response> ftDrop(List<String> args)
```
    Redis command FT.DROP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtDrop
```
public Maybe<Response> rxFtDrop(List<String> args)
```
    Redis command FT.DROP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftDropindex
```
public Maybe<Response> ftDropindex(List<String> args)
```
    Redis command FT.DROPINDEX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtDropindex
```
public Maybe<Response> rxFtDropindex(List<String> args)
```
    Redis command FT.DROPINDEX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftExplain
```
public Maybe<Response> ftExplain(List<String> args)
```
    Redis command FT.EXPLAIN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtExplain
```
public Maybe<Response> rxFtExplain(List<String> args)
```
    Redis command FT.EXPLAIN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftExplaincli
```
public Maybe<Response> ftExplaincli(List<String> args)
```
    Redis command FT.EXPLAINCLI.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtExplaincli
```
public Maybe<Response> rxFtExplaincli(List<String> args)
```
    Redis command FT.EXPLAINCLI.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftGet
```
public Maybe<Response> ftGet(List<String> args)
```
    Redis command FT.GET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtGet
```
public Maybe<Response> rxFtGet(List<String> args)
```
    Redis command FT.GET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftInfo
```
public Maybe<Response> ftInfo(List<String> args)
```
    Redis command FT.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtInfo
```
public Maybe<Response> rxFtInfo(List<String> args)
```
    Redis command FT.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftMget
```
public Maybe<Response> ftMget(List<String> args)
```
    Redis command FT.MGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtMget
```
public Maybe<Response> rxFtMget(List<String> args)
```
    Redis command FT.MGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftProfile
```
public Maybe<Response> ftProfile(List<String> args)
```
    Redis command FT.PROFILE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtProfile
```
public Maybe<Response> rxFtProfile(List<String> args)
```
    Redis command FT.PROFILE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftSafeadd
```
public Maybe<Response> ftSafeadd(List<String> args)
```
    Redis command FT.SAFEADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtSafeadd
```
public Maybe<Response> rxFtSafeadd(List<String> args)
```
    Redis command FT.SAFEADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftSearch
```
public Maybe<Response> ftSearch(List<String> args)
```
    Redis command FT.SEARCH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtSearch
```
public Maybe<Response> rxFtSearch(List<String> args)
```
    Redis command FT.SEARCH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftSpellcheck
```
public Maybe<Response> ftSpellcheck(List<String> args)
```
    Redis command FT.SPELLCHECK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtSpellcheck
```
public Maybe<Response> rxFtSpellcheck(List<String> args)
```
    Redis command FT.SPELLCHECK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftSugadd
```
public Maybe<Response> ftSugadd(List<String> args)
```
    Redis command FT.SUGADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtSugadd
```
public Maybe<Response> rxFtSugadd(List<String> args)
```
    Redis command FT.SUGADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftSugdel
```
public Maybe<Response> ftSugdel(List<String> args)
```
    Redis command FT.SUGDEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtSugdel
```
public Maybe<Response> rxFtSugdel(List<String> args)
```
    Redis command FT.SUGDEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftSugget
```
public Maybe<Response> ftSugget(List<String> args)
```
    Redis command FT.SUGGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtSugget
```
public Maybe<Response> rxFtSugget(List<String> args)
```
    Redis command FT.SUGGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftSuglen
```
public Maybe<Response> ftSuglen(List<String> args)
```
    Redis command FT.SUGLEN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtSuglen
```
public Maybe<Response> rxFtSuglen(List<String> args)
```
    Redis command FT.SUGLEN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftSynadd
```
public Maybe<Response> ftSynadd(List<String> args)
```
    Redis command FT.SYNADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtSynadd
```
public Maybe<Response> rxFtSynadd(List<String> args)
```
    Redis command FT.SYNADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftSyndump
```
public Maybe<Response> ftSyndump(List<String> args)
```
    Redis command FT.SYNDUMP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtSyndump
```
public Maybe<Response> rxFtSyndump(List<String> args)
```
    Redis command FT.SYNDUMP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftSynupdate
```
public Maybe<Response> ftSynupdate(List<String> args)
```
    Redis command FT.SYNUPDATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtSynupdate
```
public Maybe<Response> rxFtSynupdate(List<String> args)
```
    Redis command FT.SYNUPDATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftTagvals
```
public Maybe<Response> ftTagvals(List<String> args)
```
    Redis command FT.TAGVALS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtTagvals
```
public Maybe<Response> rxFtTagvals(List<String> args)
```
    Redis command FT.TAGVALS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftAliasaddifnx
```
public Maybe<Response> ftAliasaddifnx(List<String> args)
```
    Redis command FT._ALIASADDIFNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtAliasaddifnx
```
public Maybe<Response> rxFtAliasaddifnx(List<String> args)
```
    Redis command FT._ALIASADDIFNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftAliasdelifx
```
public Maybe<Response> ftAliasdelifx(List<String> args)
```
    Redis command FT._ALIASDELIFX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtAliasdelifx
```
public Maybe<Response> rxFtAliasdelifx(List<String> args)
```
    Redis command FT._ALIASDELIFX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftAlterifnx
```
public Maybe<Response> ftAlterifnx(List<String> args)
```
    Redis command FT._ALTERIFNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtAlterifnx
```
public Maybe<Response> rxFtAlterifnx(List<String> args)
```
    Redis command FT._ALTERIFNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftCreateifnx
```
public Maybe<Response> ftCreateifnx(List<String> args)
```
    Redis command FT._CREATEIFNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtCreateifnx
```
public Maybe<Response> rxFtCreateifnx(List<String> args)
```
    Redis command FT._CREATEIFNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftDropifx
```
public Maybe<Response> ftDropifx(List<String> args)
```
    Redis command FT._DROPIFX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtDropifx
```
public Maybe<Response> rxFtDropifx(List<String> args)
```
    Redis command FT._DROPIFX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftDropindexifx
```
public Maybe<Response> ftDropindexifx(List<String> args)
```
    Redis command FT._DROPINDEXIFX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtDropindexifx
```
public Maybe<Response> rxFtDropindexifx(List<String> args)
```
    Redis command FT._DROPINDEXIFX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ftList
```
public Maybe<Response> ftList(List<String> args)
```
    Redis command FT._LIST.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFtList
```
public Maybe<Response> rxFtList(List<String> args)
```
    Redis command FT._LIST.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - acl
```
public Maybe<Response> acl(List<String> args)
```
    A container for Access List Control commands.
    Redis command ACL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxAcl
```
public Maybe<Response> rxAcl(List<String> args)
```
    A container for Access List Control commands.
    Redis command ACL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - append
```
public Maybe<Response> append(String arg0,
                              String arg1)
```
    Append a value to a key.
    Redis command APPEND.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxAppend
```
public Maybe<Response> rxAppend(String arg0,
                                String arg1)
```
    Append a value to a key.
    Redis command APPEND.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - asking
```
public Maybe<Response> asking()
```
    Sent by cluster clients after an -ASK redirect.
    Redis command ASKING.
    
    Returns:
    
    fluent self
  - rxAsking
```
public Maybe<Response> rxAsking()
```
    Sent by cluster clients after an -ASK redirect.
    Redis command ASKING.
    
    Returns:
    
    fluent self
  - auth
```
public Maybe<Response> auth(List<String> args)
```
    Authenticate to the server.
    Redis command AUTH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxAuth
```
public Maybe<Response> rxAuth(List<String> args)
```
    Authenticate to the server.
    Redis command AUTH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bfAdd
```
public Maybe<Response> bfAdd(List<String> args)
```
    Redis command BF.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBfAdd
```
public Maybe<Response> rxBfAdd(List<String> args)
```
    Redis command BF.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bfCard
```
public Maybe<Response> bfCard(List<String> args)
```
    Redis command BF.CARD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBfCard
```
public Maybe<Response> rxBfCard(List<String> args)
```
    Redis command BF.CARD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bfDebug
```
public Maybe<Response> bfDebug(List<String> args)
```
    Redis command BF.DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBfDebug
```
public Maybe<Response> rxBfDebug(List<String> args)
```
    Redis command BF.DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bfExists
```
public Maybe<Response> bfExists(List<String> args)
```
    Redis command BF.EXISTS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBfExists
```
public Maybe<Response> rxBfExists(List<String> args)
```
    Redis command BF.EXISTS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bfInfo
```
public Maybe<Response> bfInfo(List<String> args)
```
    Redis command BF.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBfInfo
```
public Maybe<Response> rxBfInfo(List<String> args)
```
    Redis command BF.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bfInsert
```
public Maybe<Response> bfInsert(List<String> args)
```
    Redis command BF.INSERT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBfInsert
```
public Maybe<Response> rxBfInsert(List<String> args)
```
    Redis command BF.INSERT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bfLoadchunk
```
public Maybe<Response> bfLoadchunk(List<String> args)
```
    Redis command BF.LOADCHUNK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBfLoadchunk
```
public Maybe<Response> rxBfLoadchunk(List<String> args)
```
    Redis command BF.LOADCHUNK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bfMadd
```
public Maybe<Response> bfMadd(List<String> args)
```
    Redis command BF.MADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBfMadd
```
public Maybe<Response> rxBfMadd(List<String> args)
```
    Redis command BF.MADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bfMexists
```
public Maybe<Response> bfMexists(List<String> args)
```
    Redis command BF.MEXISTS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBfMexists
```
public Maybe<Response> rxBfMexists(List<String> args)
```
    Redis command BF.MEXISTS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bfReserve
```
public Maybe<Response> bfReserve(List<String> args)
```
    Redis command BF.RESERVE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBfReserve
```
public Maybe<Response> rxBfReserve(List<String> args)
```
    Redis command BF.RESERVE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bfScandump
```
public Maybe<Response> bfScandump(List<String> args)
```
    Redis command BF.SCANDUMP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBfScandump
```
public Maybe<Response> rxBfScandump(List<String> args)
```
    Redis command BF.SCANDUMP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bgrewriteaof
```
public Maybe<Response> bgrewriteaof()
```
    Asynchronously rewrite the append-only file.
    Redis command BGREWRITEAOF.
    
    Returns:
    
    fluent self
  - rxBgrewriteaof
```
public Maybe<Response> rxBgrewriteaof()
```
    Asynchronously rewrite the append-only file.
    Redis command BGREWRITEAOF.
    
    Returns:
    
    fluent self
  - bgsave
```
public Maybe<Response> bgsave(List<String> args)
```
    Asynchronously save the dataset to disk.
    Redis command BGSAVE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBgsave
```
public Maybe<Response> rxBgsave(List<String> args)
```
    Asynchronously save the dataset to disk.
    Redis command BGSAVE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bitcount
```
public Maybe<Response> bitcount(List<String> args)
```
    Count set bits in a string.
    Redis command BITCOUNT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBitcount
```
public Maybe<Response> rxBitcount(List<String> args)
```
    Count set bits in a string.
    Redis command BITCOUNT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bitfield
```
public Maybe<Response> bitfield(List<String> args)
```
    Perform arbitrary bitfield integer operations on strings.
    Redis command BITFIELD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBitfield
```
public Maybe<Response> rxBitfield(List<String> args)
```
    Perform arbitrary bitfield integer operations on strings.
    Redis command BITFIELD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bitfieldRo
```
public Maybe<Response> bitfieldRo(List<String> args)
```
    Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD.
    Redis command BITFIELD_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBitfieldRo
```
public Maybe<Response> rxBitfieldRo(List<String> args)
```
    Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD.
    Redis command BITFIELD_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bitop
```
public Maybe<Response> bitop(List<String> args)
```
    Perform bitwise operations between strings.
    Redis command BITOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBitop
```
public Maybe<Response> rxBitop(List<String> args)
```
    Perform bitwise operations between strings.
    Redis command BITOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bitpos
```
public Maybe<Response> bitpos(List<String> args)
```
    Find first bit set or clear in a string.
    Redis command BITPOS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBitpos
```
public Maybe<Response> rxBitpos(List<String> args)
```
    Find first bit set or clear in a string.
    Redis command BITPOS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - blmove
```
public Maybe<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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    arg3 -
    
    arg4 -
    
    Returns:
    
    fluent self
  - rxBlmove
```
public Maybe<Response> rxBlmove(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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    arg3 -
    
    arg4 -
    
    Returns:
    
    fluent self
  - blmpop
```
public Maybe<Response> blmpop(List<String> args)
```
    Pop elements from a list, or block until one is available.
    Redis command BLMPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBlmpop
```
public Maybe<Response> rxBlmpop(List<String> args)
```
    Pop elements from a list, or block until one is available.
    Redis command BLMPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - blpop
```
public Maybe<Response> blpop(List<String> args)
```
    Remove and get the first element in a list, or block until one is available.
    Redis command BLPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBlpop
```
public Maybe<Response> rxBlpop(List<String> args)
```
    Remove and get the first element in a list, or block until one is available.
    Redis command BLPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - brpop
```
public Maybe<Response> brpop(List<String> args)
```
    Remove and get the last element in a list, or block until one is available.
    Redis command BRPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBrpop
```
public Maybe<Response> rxBrpop(List<String> args)
```
    Remove and get the last element in a list, or block until one is available.
    Redis command BRPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - brpoplpush
```
public Maybe<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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxBrpoplpush
```
public Maybe<Response> rxBrpoplpush(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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - bzmpop
```
public Maybe<Response> bzmpop(List<String> args)
```
    Remove and return members with scores in a sorted set or block until one is available.
    Redis command BZMPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBzmpop
```
public Maybe<Response> rxBzmpop(List<String> args)
```
    Remove and return members with scores in a sorted set or block until one is available.
    Redis command BZMPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bzpopmax
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBzpopmax
```
public Maybe<Response> rxBzpopmax(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - bzpopmin
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxBzpopmin
```
public Maybe<Response> rxBzpopmin(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfAdd
```
public Maybe<Response> cfAdd(List<String> args)
```
    Redis command CF.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfAdd
```
public Maybe<Response> rxCfAdd(List<String> args)
```
    Redis command CF.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfAddnx
```
public Maybe<Response> cfAddnx(List<String> args)
```
    Redis command CF.ADDNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfAddnx
```
public Maybe<Response> rxCfAddnx(List<String> args)
```
    Redis command CF.ADDNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfCompact
```
public Maybe<Response> cfCompact(List<String> args)
```
    Redis command CF.COMPACT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfCompact
```
public Maybe<Response> rxCfCompact(List<String> args)
```
    Redis command CF.COMPACT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfCount
```
public Maybe<Response> cfCount(List<String> args)
```
    Redis command CF.COUNT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfCount
```
public Maybe<Response> rxCfCount(List<String> args)
```
    Redis command CF.COUNT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfDebug
```
public Maybe<Response> cfDebug(List<String> args)
```
    Redis command CF.DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfDebug
```
public Maybe<Response> rxCfDebug(List<String> args)
```
    Redis command CF.DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfDel
```
public Maybe<Response> cfDel(List<String> args)
```
    Redis command CF.DEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfDel
```
public Maybe<Response> rxCfDel(List<String> args)
```
    Redis command CF.DEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfExists
```
public Maybe<Response> cfExists(List<String> args)
```
    Redis command CF.EXISTS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfExists
```
public Maybe<Response> rxCfExists(List<String> args)
```
    Redis command CF.EXISTS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfInfo
```
public Maybe<Response> cfInfo(List<String> args)
```
    Redis command CF.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfInfo
```
public Maybe<Response> rxCfInfo(List<String> args)
```
    Redis command CF.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfInsert
```
public Maybe<Response> cfInsert(List<String> args)
```
    Redis command CF.INSERT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfInsert
```
public Maybe<Response> rxCfInsert(List<String> args)
```
    Redis command CF.INSERT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfInsertnx
```
public Maybe<Response> cfInsertnx(List<String> args)
```
    Redis command CF.INSERTNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfInsertnx
```
public Maybe<Response> rxCfInsertnx(List<String> args)
```
    Redis command CF.INSERTNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfLoadchunk
```
public Maybe<Response> cfLoadchunk(List<String> args)
```
    Redis command CF.LOADCHUNK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfLoadchunk
```
public Maybe<Response> rxCfLoadchunk(List<String> args)
```
    Redis command CF.LOADCHUNK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfMexists
```
public Maybe<Response> cfMexists(List<String> args)
```
    Redis command CF.MEXISTS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfMexists
```
public Maybe<Response> rxCfMexists(List<String> args)
```
    Redis command CF.MEXISTS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfReserve
```
public Maybe<Response> cfReserve(List<String> args)
```
    Redis command CF.RESERVE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfReserve
```
public Maybe<Response> rxCfReserve(List<String> args)
```
    Redis command CF.RESERVE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cfScandump
```
public Maybe<Response> cfScandump(List<String> args)
```
    Redis command CF.SCANDUMP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCfScandump
```
public Maybe<Response> rxCfScandump(List<String> args)
```
    Redis command CF.SCANDUMP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - client
```
public Maybe<Response> client(List<String> args)
```
    A container for client connection commands.
    Redis command CLIENT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxClient
```
public Maybe<Response> rxClient(List<String> args)
```
    A container for client connection commands.
    Redis command CLIENT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cluster
```
public Maybe<Response> cluster(List<String> args)
```
    A container for cluster commands.
    Redis command CLUSTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCluster
```
public Maybe<Response> rxCluster(List<String> args)
```
    A container for cluster commands.
    Redis command CLUSTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cmsIncrby
```
public Maybe<Response> cmsIncrby(List<String> args)
```
    Redis command CMS.INCRBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCmsIncrby
```
public Maybe<Response> rxCmsIncrby(List<String> args)
```
    Redis command CMS.INCRBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cmsInfo
```
public Maybe<Response> cmsInfo(List<String> args)
```
    Redis command CMS.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCmsInfo
```
public Maybe<Response> rxCmsInfo(List<String> args)
```
    Redis command CMS.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cmsInitbydim
```
public Maybe<Response> cmsInitbydim(List<String> args)
```
    Redis command CMS.INITBYDIM.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCmsInitbydim
```
public Maybe<Response> rxCmsInitbydim(List<String> args)
```
    Redis command CMS.INITBYDIM.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cmsInitbyprob
```
public Maybe<Response> cmsInitbyprob(List<String> args)
```
    Redis command CMS.INITBYPROB.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCmsInitbyprob
```
public Maybe<Response> rxCmsInitbyprob(List<String> args)
```
    Redis command CMS.INITBYPROB.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cmsMerge
```
public Maybe<Response> cmsMerge(List<String> args)
```
    Redis command CMS.MERGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCmsMerge
```
public Maybe<Response> rxCmsMerge(List<String> args)
```
    Redis command CMS.MERGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - cmsQuery
```
public Maybe<Response> cmsQuery(List<String> args)
```
    Redis command CMS.QUERY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCmsQuery
```
public Maybe<Response> rxCmsQuery(List<String> args)
```
    Redis command CMS.QUERY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - command
```
public Maybe<Response> command(List<String> args)
```
    Get array of Redis command details.
    Redis command COMMAND.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCommand
```
public Maybe<Response> rxCommand(List<String> args)
```
    Get array of Redis command details.
    Redis command COMMAND.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - config
```
public Maybe<Response> config(List<String> args)
```
    A container for server configuration commands.
    Redis command CONFIG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxConfig
```
public Maybe<Response> rxConfig(List<String> args)
```
    A container for server configuration commands.
    Redis command CONFIG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - copy
```
public Maybe<Response> copy(List<String> args)
```
    Copy a key.
    Redis command COPY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxCopy
```
public Maybe<Response> rxCopy(List<String> args)
```
    Copy a key.
    Redis command COPY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - dbsize
```
public Maybe<Response> dbsize()
```
    Return the number of keys in the selected database.
    Redis command DBSIZE.
    
    Returns:
    
    fluent self
  - rxDbsize
```
public Maybe<Response> rxDbsize()
```
    Return the number of keys in the selected database.
    Redis command DBSIZE.
    
    Returns:
    
    fluent self
  - debug
```
public Maybe<Response> debug(List<String> args)
```
    A container for debugging commands.
    Redis command DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxDebug
```
public Maybe<Response> rxDebug(List<String> args)
```
    A container for debugging commands.
    Redis command DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - decr
```
public Maybe<Response> decr(String arg0)
```
    Decrement the integer value of a key by one.
    Redis command DECR.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxDecr
```
public Maybe<Response> rxDecr(String arg0)
```
    Decrement the integer value of a key by one.
    Redis command DECR.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - decrby
```
public Maybe<Response> decrby(String arg0,
                              String arg1)
```
    Decrement the integer value of a key by the given number.
    Redis command DECRBY.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxDecrby
```
public Maybe<Response> rxDecrby(String arg0,
                                String arg1)
```
    Decrement the integer value of a key by the given number.
    Redis command DECRBY.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - del
```
public Maybe<Response> del(List<String> args)
```
    Delete a key.
    Redis command DEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxDel
```
public Maybe<Response> rxDel(List<String> args)
```
    Delete a key.
    Redis command DEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - discard
```
public Maybe<Response> discard()
```
    Discard all commands issued after MULTI.
    Redis command DISCARD.
    
    Returns:
    
    fluent self
  - rxDiscard
```
public Maybe<Response> rxDiscard()
```
    Discard all commands issued after MULTI.
    Redis command DISCARD.
    
    Returns:
    
    fluent self
  - dump
```
public Maybe<Response> dump(String arg0)
```
    Return a serialized version of the value stored at the specified key.
    Redis command DUMP.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxDump
```
public Maybe<Response> rxDump(String arg0)
```
    Return a serialized version of the value stored at the specified key.
    Redis command DUMP.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - echo
```
public Maybe<Response> echo(String arg0)
```
    Echo the given string.
    Redis command ECHO.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxEcho
```
public Maybe<Response> rxEcho(String arg0)
```
    Echo the given string.
    Redis command ECHO.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - eval
```
public Maybe<Response> eval(List<String> args)
```
    Execute a Lua script server side.
    Redis command EVAL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxEval
```
public Maybe<Response> rxEval(List<String> args)
```
    Execute a Lua script server side.
    Redis command EVAL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - evalRo
```
public Maybe<Response> evalRo(List<String> args)
```
    Execute a read-only Lua script server side.
    Redis command EVAL_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxEvalRo
```
public Maybe<Response> rxEvalRo(List<String> args)
```
    Execute a read-only Lua script server side.
    Redis command EVAL_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - evalsha
```
public Maybe<Response> evalsha(List<String> args)
```
    Execute a Lua script server side.
    Redis command EVALSHA.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxEvalsha
```
public Maybe<Response> rxEvalsha(List<String> args)
```
    Execute a Lua script server side.
    Redis command EVALSHA.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - evalshaRo
```
public Maybe<Response> evalshaRo(List<String> args)
```
    Execute a read-only Lua script server side.
    Redis command EVALSHA_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxEvalshaRo
```
public Maybe<Response> rxEvalshaRo(List<String> args)
```
    Execute a read-only Lua script server side.
    Redis command EVALSHA_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - exec
```
public Maybe<Response> exec()
```
    Execute all commands issued after MULTI.
    Redis command EXEC.
    
    Returns:
    
    fluent self
  - rxExec
```
public Maybe<Response> rxExec()
```
    Execute all commands issued after MULTI.
    Redis command EXEC.
    
    Returns:
    
    fluent self
  - exists
```
public Maybe<Response> exists(List<String> args)
```
    Determine if a key exists.
    Redis command EXISTS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxExists
```
public Maybe<Response> rxExists(List<String> args)
```
    Determine if a key exists.
    Redis command EXISTS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - expire
```
public Maybe<Response> expire(List<String> args)
```
    Set a key's time to live in seconds.
    Redis command EXPIRE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxExpire
```
public Maybe<Response> rxExpire(List<String> args)
```
    Set a key's time to live in seconds.
    Redis command EXPIRE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - expireat
```
public Maybe<Response> expireat(List<String> args)
```
    Set the expiration for a key as a UNIX timestamp.
    Redis command EXPIREAT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxExpireat
```
public Maybe<Response> rxExpireat(List<String> args)
```
    Set the expiration for a key as a UNIX timestamp.
    Redis command EXPIREAT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - expiretime
```
public Maybe<Response> expiretime(String arg0)
```
    Get the expiration Unix timestamp for a key.
    Redis command EXPIRETIME.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxExpiretime
```
public Maybe<Response> rxExpiretime(String arg0)
```
    Get the expiration Unix timestamp for a key.
    Redis command EXPIRETIME.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - failover
```
public Maybe<Response> failover(List<String> args)
```
    Start a coordinated failover between this server and one of its replicas.
    Redis command FAILOVER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFailover
```
public Maybe<Response> rxFailover(List<String> args)
```
    Start a coordinated failover between this server and one of its replicas.
    Redis command FAILOVER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - fcall
```
public Maybe<Response> fcall(List<String> args)
```
    Invoke a function.
    Redis command FCALL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFcall
```
public Maybe<Response> rxFcall(List<String> args)
```
    Invoke a function.
    Redis command FCALL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - fcallRo
```
public Maybe<Response> fcallRo(List<String> args)
```
    Invoke a read-only function.
    Redis command FCALL_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFcallRo
```
public Maybe<Response> rxFcallRo(List<String> args)
```
    Invoke a read-only function.
    Redis command FCALL_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - flushall
```
public Maybe<Response> flushall(List<String> args)
```
    Remove all keys from all databases.
    Redis command FLUSHALL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFlushall
```
public Maybe<Response> rxFlushall(List<String> args)
```
    Remove all keys from all databases.
    Redis command FLUSHALL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - flushdb
```
public Maybe<Response> flushdb(List<String> args)
```
    Remove all keys from the current database.
    Redis command FLUSHDB.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFlushdb
```
public Maybe<Response> rxFlushdb(List<String> args)
```
    Remove all keys from the current database.
    Redis command FLUSHDB.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - function
```
public Maybe<Response> function(List<String> args)
```
    A container for function commands.
    Redis command FUNCTION.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxFunction
```
public Maybe<Response> rxFunction(List<String> args)
```
    A container for function commands.
    Redis command FUNCTION.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - geoadd
```
public Maybe<Response> geoadd(List<String> args)
```
    Add one or more geospatial items in the geospatial index represented using a sorted set.
    Redis command GEOADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGeoadd
```
public Maybe<Response> rxGeoadd(List<String> args)
```
    Add one or more geospatial items in the geospatial index represented using a sorted set.
    Redis command GEOADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - geodist
```
public Maybe<Response> geodist(List<String> args)
```
    Returns the distance between two members of a geospatial index.
    Redis command GEODIST.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGeodist
```
public Maybe<Response> rxGeodist(List<String> args)
```
    Returns the distance between two members of a geospatial index.
    Redis command GEODIST.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - geohash
```
public Maybe<Response> geohash(List<String> args)
```
    Returns members of a geospatial index as standard geohash strings.
    Redis command GEOHASH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGeohash
```
public Maybe<Response> rxGeohash(List<String> args)
```
    Returns members of a geospatial index as standard geohash strings.
    Redis command GEOHASH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - geopos
```
public Maybe<Response> geopos(List<String> args)
```
    Returns longitude and latitude of members of a geospatial index.
    Redis command GEOPOS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGeopos
```
public Maybe<Response> rxGeopos(List<String> args)
```
    Returns longitude and latitude of members of a geospatial index.
    Redis command GEOPOS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - georadius
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGeoradius
```
public Maybe<Response> rxGeoradius(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - georadiusRo
```
public Maybe<Response> georadiusRo(List<String> args)
```
    A read-only variant for GEORADIUS.
    Redis command GEORADIUS_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGeoradiusRo
```
public Maybe<Response> rxGeoradiusRo(List<String> args)
```
    A read-only variant for GEORADIUS.
    Redis command GEORADIUS_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - georadiusbymember
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGeoradiusbymember
```
public Maybe<Response> rxGeoradiusbymember(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - georadiusbymemberRo
```
public Maybe<Response> georadiusbymemberRo(List<String> args)
```
    A read-only variant for GEORADIUSBYMEMBER.
    Redis command GEORADIUSBYMEMBER_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGeoradiusbymemberRo
```
public Maybe<Response> rxGeoradiusbymemberRo(List<String> args)
```
    A read-only variant for GEORADIUSBYMEMBER.
    Redis command GEORADIUSBYMEMBER_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - geosearch
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGeosearch
```
public Maybe<Response> rxGeosearch(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - geosearchstore
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGeosearchstore
```
public Maybe<Response> rxGeosearchstore(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - get
```
public Maybe<Response> get(String arg0)
```
    Get the value of a key.
    Redis command GET.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxGet
```
public Maybe<Response> rxGet(String arg0)
```
    Get the value of a key.
    Redis command GET.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - getbit
```
public Maybe<Response> getbit(String arg0,
                              String arg1)
```
    Returns the bit value at offset in the string value stored at key.
    Redis command GETBIT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxGetbit
```
public Maybe<Response> rxGetbit(String arg0,
                                String arg1)
```
    Returns the bit value at offset in the string value stored at key.
    Redis command GETBIT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - getdel
```
public Maybe<Response> getdel(String arg0)
```
    Get the value of a key and delete the key.
    Redis command GETDEL.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxGetdel
```
public Maybe<Response> rxGetdel(String arg0)
```
    Get the value of a key and delete the key.
    Redis command GETDEL.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - getex
```
public Maybe<Response> getex(List<String> args)
```
    Get the value of a key and optionally set its expiration.
    Redis command GETEX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGetex
```
public Maybe<Response> rxGetex(List<String> args)
```
    Get the value of a key and optionally set its expiration.
    Redis command GETEX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - getrange
```
public Maybe<Response> getrange(String arg0,
                                String arg1,
                                String arg2)
```
    Get a substring of the string stored at a key.
    Redis command GETRANGE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxGetrange
```
public Maybe<Response> rxGetrange(String arg0,
                                  String arg1,
                                  String arg2)
```
    Get a substring of the string stored at a key.
    Redis command GETRANGE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - getset
```
public Maybe<Response> getset(String arg0,
                              String arg1)
```
    Set the string value of a key and return its old value.
    Redis command GETSET.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxGetset
```
public Maybe<Response> rxGetset(String arg0,
                                String arg1)
```
    Set the string value of a key and return its old value.
    Redis command GETSET.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - graphBulk
```
public Maybe<Response> graphBulk(List<String> args)
```
    Redis command GRAPH.BULK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGraphBulk
```
public Maybe<Response> rxGraphBulk(List<String> args)
```
    Redis command GRAPH.BULK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - graphConfig
```
public Maybe<Response> graphConfig(List<String> args)
```
    Redis command GRAPH.CONFIG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGraphConfig
```
public Maybe<Response> rxGraphConfig(List<String> args)
```
    Redis command GRAPH.CONFIG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - graphDebug
```
public Maybe<Response> graphDebug(List<String> args)
```
    Redis command GRAPH.DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGraphDebug
```
public Maybe<Response> rxGraphDebug(List<String> args)
```
    Redis command GRAPH.DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - graphDelete
```
public Maybe<Response> graphDelete(List<String> args)
```
    Redis command GRAPH.DELETE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGraphDelete
```
public Maybe<Response> rxGraphDelete(List<String> args)
```
    Redis command GRAPH.DELETE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - graphExplain
```
public Maybe<Response> graphExplain(List<String> args)
```
    Redis command GRAPH.EXPLAIN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGraphExplain
```
public Maybe<Response> rxGraphExplain(List<String> args)
```
    Redis command GRAPH.EXPLAIN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - graphList
```
public Maybe<Response> graphList(List<String> args)
```
    Redis command GRAPH.LIST.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGraphList
```
public Maybe<Response> rxGraphList(List<String> args)
```
    Redis command GRAPH.LIST.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - graphProfile
```
public Maybe<Response> graphProfile(List<String> args)
```
    Redis command GRAPH.PROFILE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGraphProfile
```
public Maybe<Response> rxGraphProfile(List<String> args)
```
    Redis command GRAPH.PROFILE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - graphQuery
```
public Maybe<Response> graphQuery(List<String> args)
```
    Redis command GRAPH.QUERY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGraphQuery
```
public Maybe<Response> rxGraphQuery(List<String> args)
```
    Redis command GRAPH.QUERY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - graphRoQuery
```
public Maybe<Response> graphRoQuery(List<String> args)
```
    Redis command GRAPH.RO_QUERY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGraphRoQuery
```
public Maybe<Response> rxGraphRoQuery(List<String> args)
```
    Redis command GRAPH.RO_QUERY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - graphSlowlog
```
public Maybe<Response> graphSlowlog(List<String> args)
```
    Redis command GRAPH.SLOWLOG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxGraphSlowlog
```
public Maybe<Response> rxGraphSlowlog(List<String> args)
```
    Redis command GRAPH.SLOWLOG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - hdel
```
public Maybe<Response> hdel(List<String> args)
```
    Delete one or more hash fields.
    Redis command HDEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxHdel
```
public Maybe<Response> rxHdel(List<String> args)
```
    Delete one or more hash fields.
    Redis command HDEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - hello
```
public Maybe<Response> hello(List<String> args)
```
    Handshake with Redis.
    Redis command HELLO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxHello
```
public Maybe<Response> rxHello(List<String> args)
```
    Handshake with Redis.
    Redis command HELLO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - hexists
```
public Maybe<Response> hexists(String arg0,
                               String arg1)
```
    Determine if a hash field exists.
    Redis command HEXISTS.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxHexists
```
public Maybe<Response> rxHexists(String arg0,
                                 String arg1)
```
    Determine if a hash field exists.
    Redis command HEXISTS.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - hget
```
public Maybe<Response> hget(String arg0,
                            String arg1)
```
    Get the value of a hash field.
    Redis command HGET.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxHget
```
public Maybe<Response> rxHget(String arg0,
                              String arg1)
```
    Get the value of a hash field.
    Redis command HGET.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - hgetall
```
public Maybe<Response> hgetall(String arg0)
```
    Get all the fields and values in a hash.
    Redis command HGETALL.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxHgetall
```
public Maybe<Response> rxHgetall(String arg0)
```
    Get all the fields and values in a hash.
    Redis command HGETALL.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - hincrby
```
public Maybe<Response> hincrby(String arg0,
                               String arg1,
                               String arg2)
```
    Increment the integer value of a hash field by the given number.
    Redis command HINCRBY.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxHincrby
```
public Maybe<Response> rxHincrby(String arg0,
                                 String arg1,
                                 String arg2)
```
    Increment the integer value of a hash field by the given number.
    Redis command HINCRBY.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - hincrbyfloat
```
public Maybe<Response> hincrbyfloat(String arg0,
                                    String arg1,
                                    String arg2)
```
    Increment the float value of a hash field by the given amount.
    Redis command HINCRBYFLOAT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxHincrbyfloat
```
public Maybe<Response> rxHincrbyfloat(String arg0,
                                      String arg1,
                                      String arg2)
```
    Increment the float value of a hash field by the given amount.
    Redis command HINCRBYFLOAT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - hkeys
```
public Maybe<Response> hkeys(String arg0)
```
    Get all the fields in a hash.
    Redis command HKEYS.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxHkeys
```
public Maybe<Response> rxHkeys(String arg0)
```
    Get all the fields in a hash.
    Redis command HKEYS.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - hlen
```
public Maybe<Response> hlen(String arg0)
```
    Get the number of fields in a hash.
    Redis command HLEN.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxHlen
```
public Maybe<Response> rxHlen(String arg0)
```
    Get the number of fields in a hash.
    Redis command HLEN.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - hmget
```
public Maybe<Response> hmget(List<String> args)
```
    Get the values of all the given hash fields.
    Redis command HMGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxHmget
```
public Maybe<Response> rxHmget(List<String> args)
```
    Get the values of all the given hash fields.
    Redis command HMGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - hmset
```
public Maybe<Response> hmset(List<String> args)
```
    Set multiple hash fields to multiple values.
    Redis command HMSET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxHmset
```
public Maybe<Response> rxHmset(List<String> args)
```
    Set multiple hash fields to multiple values.
    Redis command HMSET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - hrandfield
```
public Maybe<Response> hrandfield(List<String> args)
```
    Get one or multiple random fields from a hash.
    Redis command HRANDFIELD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxHrandfield
```
public Maybe<Response> rxHrandfield(List<String> args)
```
    Get one or multiple random fields from a hash.
    Redis command HRANDFIELD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - hscan
```
public Maybe<Response> hscan(List<String> args)
```
    Incrementally iterate hash fields and associated values.
    Redis command HSCAN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxHscan
```
public Maybe<Response> rxHscan(List<String> args)
```
    Incrementally iterate hash fields and associated values.
    Redis command HSCAN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - hset
```
public Maybe<Response> hset(List<String> args)
```
    Set the string value of a hash field.
    Redis command HSET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxHset
```
public Maybe<Response> rxHset(List<String> args)
```
    Set the string value of a hash field.
    Redis command HSET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - hsetnx
```
public Maybe<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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxHsetnx
```
public Maybe<Response> rxHsetnx(String arg0,
                                String arg1,
                                String arg2)
```
    Set the value of a hash field, only if the field does not exist.
    Redis command HSETNX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - hstrlen
```
public Maybe<Response> hstrlen(String arg0,
                               String arg1)
```
    Get the length of the value of a hash field.
    Redis command HSTRLEN.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxHstrlen
```
public Maybe<Response> rxHstrlen(String arg0,
                                 String arg1)
```
    Get the length of the value of a hash field.
    Redis command HSTRLEN.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - hvals
```
public Maybe<Response> hvals(String arg0)
```
    Get all the values in a hash.
    Redis command HVALS.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxHvals
```
public Maybe<Response> rxHvals(String arg0)
```
    Get all the values in a hash.
    Redis command HVALS.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - incr
```
public Maybe<Response> incr(String arg0)
```
    Increment the integer value of a key by one.
    Redis command INCR.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxIncr
```
public Maybe<Response> rxIncr(String arg0)
```
    Increment the integer value of a key by one.
    Redis command INCR.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - incrby
```
public Maybe<Response> incrby(String arg0,
                              String arg1)
```
    Increment the integer value of a key by the given amount.
    Redis command INCRBY.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxIncrby
```
public Maybe<Response> rxIncrby(String arg0,
                                String arg1)
```
    Increment the integer value of a key by the given amount.
    Redis command INCRBY.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - incrbyfloat
```
public Maybe<Response> incrbyfloat(String arg0,
                                   String arg1)
```
    Increment the float value of a key by the given amount.
    Redis command INCRBYFLOAT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxIncrbyfloat
```
public Maybe<Response> rxIncrbyfloat(String arg0,
                                     String arg1)
```
    Increment the float value of a key by the given amount.
    Redis command INCRBYFLOAT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - info
```
public Maybe<Response> info(List<String> args)
```
    Get information and statistics about the server.
    Redis command INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxInfo
```
public Maybe<Response> rxInfo(List<String> args)
```
    Get information and statistics about the server.
    Redis command INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonArrappend
```
public Maybe<Response> jsonArrappend(List<String> args)
```
    Redis command JSON.ARRAPPEND.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonArrappend
```
public Maybe<Response> rxJsonArrappend(List<String> args)
```
    Redis command JSON.ARRAPPEND.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonArrindex
```
public Maybe<Response> jsonArrindex(List<String> args)
```
    Redis command JSON.ARRINDEX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonArrindex
```
public Maybe<Response> rxJsonArrindex(List<String> args)
```
    Redis command JSON.ARRINDEX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonArrinsert
```
public Maybe<Response> jsonArrinsert(List<String> args)
```
    Redis command JSON.ARRINSERT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonArrinsert
```
public Maybe<Response> rxJsonArrinsert(List<String> args)
```
    Redis command JSON.ARRINSERT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonArrlen
```
public Maybe<Response> jsonArrlen(List<String> args)
```
    Redis command JSON.ARRLEN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonArrlen
```
public Maybe<Response> rxJsonArrlen(List<String> args)
```
    Redis command JSON.ARRLEN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonArrpop
```
public Maybe<Response> jsonArrpop(List<String> args)
```
    Redis command JSON.ARRPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonArrpop
```
public Maybe<Response> rxJsonArrpop(List<String> args)
```
    Redis command JSON.ARRPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonArrtrim
```
public Maybe<Response> jsonArrtrim(List<String> args)
```
    Redis command JSON.ARRTRIM.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonArrtrim
```
public Maybe<Response> rxJsonArrtrim(List<String> args)
```
    Redis command JSON.ARRTRIM.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonClear
```
public Maybe<Response> jsonClear(List<String> args)
```
    Redis command JSON.CLEAR.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonClear
```
public Maybe<Response> rxJsonClear(List<String> args)
```
    Redis command JSON.CLEAR.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonDebug
```
public Maybe<Response> jsonDebug(List<String> args)
```
    Redis command JSON.DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonDebug
```
public Maybe<Response> rxJsonDebug(List<String> args)
```
    Redis command JSON.DEBUG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonDel
```
public Maybe<Response> jsonDel(List<String> args)
```
    Redis command JSON.DEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonDel
```
public Maybe<Response> rxJsonDel(List<String> args)
```
    Redis command JSON.DEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonForget
```
public Maybe<Response> jsonForget(List<String> args)
```
    Redis command JSON.FORGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonForget
```
public Maybe<Response> rxJsonForget(List<String> args)
```
    Redis command JSON.FORGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonGet
```
public Maybe<Response> jsonGet(List<String> args)
```
    Redis command JSON.GET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonGet
```
public Maybe<Response> rxJsonGet(List<String> args)
```
    Redis command JSON.GET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonMget
```
public Maybe<Response> jsonMget(List<String> args)
```
    Redis command JSON.MGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonMget
```
public Maybe<Response> rxJsonMget(List<String> args)
```
    Redis command JSON.MGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonNumincrby
```
public Maybe<Response> jsonNumincrby(List<String> args)
```
    Redis command JSON.NUMINCRBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonNumincrby
```
public Maybe<Response> rxJsonNumincrby(List<String> args)
```
    Redis command JSON.NUMINCRBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonNummultby
```
public Maybe<Response> jsonNummultby(List<String> args)
```
    Redis command JSON.NUMMULTBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonNummultby
```
public Maybe<Response> rxJsonNummultby(List<String> args)
```
    Redis command JSON.NUMMULTBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonNumpowby
```
public Maybe<Response> jsonNumpowby(List<String> args)
```
    Redis command JSON.NUMPOWBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonNumpowby
```
public Maybe<Response> rxJsonNumpowby(List<String> args)
```
    Redis command JSON.NUMPOWBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonObjkeys
```
public Maybe<Response> jsonObjkeys(List<String> args)
```
    Redis command JSON.OBJKEYS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonObjkeys
```
public Maybe<Response> rxJsonObjkeys(List<String> args)
```
    Redis command JSON.OBJKEYS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonObjlen
```
public Maybe<Response> jsonObjlen(List<String> args)
```
    Redis command JSON.OBJLEN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonObjlen
```
public Maybe<Response> rxJsonObjlen(List<String> args)
```
    Redis command JSON.OBJLEN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonResp
```
public Maybe<Response> jsonResp(List<String> args)
```
    Redis command JSON.RESP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonResp
```
public Maybe<Response> rxJsonResp(List<String> args)
```
    Redis command JSON.RESP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonSet
```
public Maybe<Response> jsonSet(List<String> args)
```
    Redis command JSON.SET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonSet
```
public Maybe<Response> rxJsonSet(List<String> args)
```
    Redis command JSON.SET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonStrappend
```
public Maybe<Response> jsonStrappend(List<String> args)
```
    Redis command JSON.STRAPPEND.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonStrappend
```
public Maybe<Response> rxJsonStrappend(List<String> args)
```
    Redis command JSON.STRAPPEND.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonStrlen
```
public Maybe<Response> jsonStrlen(List<String> args)
```
    Redis command JSON.STRLEN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonStrlen
```
public Maybe<Response> rxJsonStrlen(List<String> args)
```
    Redis command JSON.STRLEN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonToggle
```
public Maybe<Response> jsonToggle(List<String> args)
```
    Redis command JSON.TOGGLE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonToggle
```
public Maybe<Response> rxJsonToggle(List<String> args)
```
    Redis command JSON.TOGGLE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - jsonType
```
public Maybe<Response> jsonType(List<String> args)
```
    Redis command JSON.TYPE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxJsonType
```
public Maybe<Response> rxJsonType(List<String> args)
```
    Redis command JSON.TYPE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - keys
```
public Maybe<Response> keys(String arg0)
```
    Find all keys matching the given pattern.
    Redis command KEYS.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxKeys
```
public Maybe<Response> rxKeys(String arg0)
```
    Find all keys matching the given pattern.
    Redis command KEYS.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - lastsave
```
public Maybe<Response> lastsave()
```
    Get the UNIX time stamp of the last successful save to disk.
    Redis command LASTSAVE.
    
    Returns:
    
    fluent self
  - rxLastsave
```
public Maybe<Response> rxLastsave()
```
    Get the UNIX time stamp of the last successful save to disk.
    Redis command LASTSAVE.
    
    Returns:
    
    fluent self
  - latency
```
public Maybe<Response> latency(List<String> args)
```
    A container for latency diagnostics commands.
    Redis command LATENCY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxLatency
```
public Maybe<Response> rxLatency(List<String> args)
```
    A container for latency diagnostics commands.
    Redis command LATENCY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - lcs
```
public Maybe<Response> lcs(List<String> args)
```
    Find longest common substring.
    Redis command LCS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxLcs
```
public Maybe<Response> rxLcs(List<String> args)
```
    Find longest common substring.
    Redis command LCS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - lindex
```
public Maybe<Response> lindex(String arg0,
                              String arg1)
```
    Get an element from a list by its index.
    Redis command LINDEX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxLindex
```
public Maybe<Response> rxLindex(String arg0,
                                String arg1)
```
    Get an element from a list by its index.
    Redis command LINDEX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - linsert
```
public Maybe<Response> linsert(String arg0,
                               String arg1,
                               String arg2,
                               String arg3)
```
    Insert an element before or after another element in a list.
    Redis command LINSERT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    arg3 -
    
    Returns:
    
    fluent self
  - rxLinsert
```
public Maybe<Response> rxLinsert(String arg0,
                                 String arg1,
                                 String arg2,
                                 String arg3)
```
    Insert an element before or after another element in a list.
    Redis command LINSERT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    arg3 -
    
    Returns:
    
    fluent self
  - llen
```
public Maybe<Response> llen(String arg0)
```
    Get the length of a list.
    Redis command LLEN.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxLlen
```
public Maybe<Response> rxLlen(String arg0)
```
    Get the length of a list.
    Redis command LLEN.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - lmove
```
public Maybe<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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    arg3 -
    
    Returns:
    
    fluent self
  - rxLmove
```
public Maybe<Response> rxLmove(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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    arg3 -
    
    Returns:
    
    fluent self
  - lmpop
```
public Maybe<Response> lmpop(List<String> args)
```
    Pop elements from a list.
    Redis command LMPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxLmpop
```
public Maybe<Response> rxLmpop(List<String> args)
```
    Pop elements from a list.
    Redis command LMPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - lolwut
```
public Maybe<Response> lolwut(List<String> args)
```
    Display some computer art and the Redis version.
    Redis command LOLWUT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxLolwut
```
public Maybe<Response> rxLolwut(List<String> args)
```
    Display some computer art and the Redis version.
    Redis command LOLWUT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - lpop
```
public Maybe<Response> lpop(List<String> args)
```
    Remove and get the first elements in a list.
    Redis command LPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxLpop
```
public Maybe<Response> rxLpop(List<String> args)
```
    Remove and get the first elements in a list.
    Redis command LPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - lpos
```
public Maybe<Response> lpos(List<String> args)
```
    Return the index of matching elements on a list.
    Redis command LPOS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxLpos
```
public Maybe<Response> rxLpos(List<String> args)
```
    Return the index of matching elements on a list.
    Redis command LPOS.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - lpush
```
public Maybe<Response> lpush(List<String> args)
```
    Prepend one or multiple elements to a list.
    Redis command LPUSH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxLpush
```
public Maybe<Response> rxLpush(List<String> args)
```
    Prepend one or multiple elements to a list.
    Redis command LPUSH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - lpushx
```
public Maybe<Response> lpushx(List<String> args)
```
    Prepend an element to a list, only if the list exists.
    Redis command LPUSHX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxLpushx
```
public Maybe<Response> rxLpushx(List<String> args)
```
    Prepend an element to a list, only if the list exists.
    Redis command LPUSHX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - lrange
```
public Maybe<Response> lrange(String arg0,
                              String arg1,
                              String arg2)
```
    Get a range of elements from a list.
    Redis command LRANGE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxLrange
```
public Maybe<Response> rxLrange(String arg0,
                                String arg1,
                                String arg2)
```
    Get a range of elements from a list.
    Redis command LRANGE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - lrem
```
public Maybe<Response> lrem(String arg0,
                            String arg1,
                            String arg2)
```
    Remove elements from a list.
    Redis command LREM.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxLrem
```
public Maybe<Response> rxLrem(String arg0,
                              String arg1,
                              String arg2)
```
    Remove elements from a list.
    Redis command LREM.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - lset
```
public Maybe<Response> lset(String arg0,
                            String arg1,
                            String arg2)
```
    Set the value of an element in a list by its index.
    Redis command LSET.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxLset
```
public Maybe<Response> rxLset(String arg0,
                              String arg1,
                              String arg2)
```
    Set the value of an element in a list by its index.
    Redis command LSET.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - ltrim
```
public Maybe<Response> ltrim(String arg0,
                             String arg1,
                             String arg2)
```
    Trim a list to the specified range.
    Redis command LTRIM.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxLtrim
```
public Maybe<Response> rxLtrim(String arg0,
                               String arg1,
                               String arg2)
```
    Trim a list to the specified range.
    Redis command LTRIM.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - memory
```
public Maybe<Response> memory(List<String> args)
```
    A container for memory diagnostics commands.
    Redis command MEMORY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxMemory
```
public Maybe<Response> rxMemory(List<String> args)
```
    A container for memory diagnostics commands.
    Redis command MEMORY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - mget
```
public Maybe<Response> mget(List<String> args)
```
    Get the values of all the given keys.
    Redis command MGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxMget
```
public Maybe<Response> rxMget(List<String> args)
```
    Get the values of all the given keys.
    Redis command MGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - migrate
```
public Maybe<Response> migrate(List<String> args)
```
    Atomically transfer a key from a Redis instance to another one.
    Redis command MIGRATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxMigrate
```
public Maybe<Response> rxMigrate(List<String> args)
```
    Atomically transfer a key from a Redis instance to another one.
    Redis command MIGRATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - module
```
public Maybe<Response> module(List<String> args)
```
    A container for module commands.
    Redis command MODULE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxModule
```
public Maybe<Response> rxModule(List<String> args)
```
    A container for module commands.
    Redis command MODULE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - monitor
```
public Maybe<Response> monitor()
```
    Listen for all requests received by the server in real time.
    Redis command MONITOR.
    
    Returns:
    
    fluent self
  - rxMonitor
```
public Maybe<Response> rxMonitor()
```
    Listen for all requests received by the server in real time.
    Redis command MONITOR.
    
    Returns:
    
    fluent self
  - move
```
public Maybe<Response> move(String arg0,
                            String arg1)
```
    Move a key to another database.
    Redis command MOVE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxMove
```
public Maybe<Response> rxMove(String arg0,
                              String arg1)
```
    Move a key to another database.
    Redis command MOVE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - mset
```
public Maybe<Response> mset(List<String> args)
```
    Set multiple keys to multiple values.
    Redis command MSET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxMset
```
public Maybe<Response> rxMset(List<String> args)
```
    Set multiple keys to multiple values.
    Redis command MSET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - msetnx
```
public Maybe<Response> msetnx(List<String> args)
```
    Set multiple keys to multiple values, only if none of the keys exist.
    Redis command MSETNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxMsetnx
```
public Maybe<Response> rxMsetnx(List<String> args)
```
    Set multiple keys to multiple values, only if none of the keys exist.
    Redis command MSETNX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - multi
```
public Maybe<Response> multi()
```
    Mark the start of a transaction block.
    Redis command MULTI.
    
    Returns:
    
    fluent self
  - rxMulti
```
public Maybe<Response> rxMulti()
```
    Mark the start of a transaction block.
    Redis command MULTI.
    
    Returns:
    
    fluent self
  - object
```
public Maybe<Response> object(List<String> args)
```
    A container for object introspection commands.
    Redis command OBJECT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxObject
```
public Maybe<Response> rxObject(List<String> args)
```
    A container for object introspection commands.
    Redis command OBJECT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - persist
```
public Maybe<Response> persist(String arg0)
```
    Remove the expiration from a key.
    Redis command PERSIST.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxPersist
```
public Maybe<Response> rxPersist(String arg0)
```
    Remove the expiration from a key.
    Redis command PERSIST.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - pexpire
```
public Maybe<Response> pexpire(List<String> args)
```
    Set a key's time to live in milliseconds.
    Redis command PEXPIRE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxPexpire
```
public Maybe<Response> rxPexpire(List<String> args)
```
    Set a key's time to live in milliseconds.
    Redis command PEXPIRE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - pexpireat
```
public Maybe<Response> pexpireat(List<String> args)
```
    Set the expiration for a key as a UNIX timestamp specified in milliseconds.
    Redis command PEXPIREAT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxPexpireat
```
public Maybe<Response> rxPexpireat(List<String> args)
```
    Set the expiration for a key as a UNIX timestamp specified in milliseconds.
    Redis command PEXPIREAT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - pexpiretime
```
public Maybe<Response> pexpiretime(String arg0)
```
    Get the expiration Unix timestamp for a key in milliseconds.
    Redis command PEXPIRETIME.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxPexpiretime
```
public Maybe<Response> rxPexpiretime(String arg0)
```
    Get the expiration Unix timestamp for a key in milliseconds.
    Redis command PEXPIRETIME.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - pfadd
```
public Maybe<Response> pfadd(List<String> args)
```
    Adds the specified elements to the specified HyperLogLog.
    Redis command PFADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxPfadd
```
public Maybe<Response> rxPfadd(List<String> args)
```
    Adds the specified elements to the specified HyperLogLog.
    Redis command PFADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - pfcount
```
public Maybe<Response> pfcount(List<String> args)
```
    Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    Redis command PFCOUNT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxPfcount
```
public Maybe<Response> rxPfcount(List<String> args)
```
    Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
    Redis command PFCOUNT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - pfdebug
```
public Maybe<Response> pfdebug(String arg0,
                               String arg1)
```
    Internal commands for debugging HyperLogLog values.
    Redis command PFDEBUG.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxPfdebug
```
public Maybe<Response> rxPfdebug(String arg0,
                                 String arg1)
```
    Internal commands for debugging HyperLogLog values.
    Redis command PFDEBUG.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - pfmerge
```
public Maybe<Response> pfmerge(List<String> args)
```
    Merge N different HyperLogLogs into a single one.
    Redis command PFMERGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxPfmerge
```
public Maybe<Response> rxPfmerge(List<String> args)
```
    Merge N different HyperLogLogs into a single one.
    Redis command PFMERGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - pfselftest
```
public Maybe<Response> pfselftest()
```
    An internal command for testing HyperLogLog values.
    Redis command PFSELFTEST.
    
    Returns:
    
    fluent self
  - rxPfselftest
```
public Maybe<Response> rxPfselftest()
```
    An internal command for testing HyperLogLog values.
    Redis command PFSELFTEST.
    
    Returns:
    
    fluent self
  - ping
```
public Maybe<Response> ping(List<String> args)
```
    Ping the server.
    Redis command PING.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxPing
```
public Maybe<Response> rxPing(List<String> args)
```
    Ping the server.
    Redis command PING.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - psetex
```
public Maybe<Response> psetex(String arg0,
                              String arg1,
                              String arg2)
```
    Set the value and expiration in milliseconds of a key.
    Redis command PSETEX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxPsetex
```
public Maybe<Response> rxPsetex(String arg0,
                                String arg1,
                                String arg2)
```
    Set the value and expiration in milliseconds of a key.
    Redis command PSETEX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - psubscribe
```
public Maybe<Response> psubscribe(List<String> args)
```
    Listen for messages published to channels matching the given patterns.
    Redis command PSUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxPsubscribe
```
public Maybe<Response> rxPsubscribe(List<String> args)
```
    Listen for messages published to channels matching the given patterns.
    Redis command PSUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - psync
```
public Maybe<Response> psync(List<String> args)
```
    Internal command used for replication.
    Redis command PSYNC.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxPsync
```
public Maybe<Response> rxPsync(List<String> args)
```
    Internal command used for replication.
    Redis command PSYNC.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - pttl
```
public Maybe<Response> pttl(String arg0)
```
    Get the time to live for a key in milliseconds.
    Redis command PTTL.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxPttl
```
public Maybe<Response> rxPttl(String arg0)
```
    Get the time to live for a key in milliseconds.
    Redis command PTTL.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - publish
```
public Maybe<Response> publish(String arg0,
                               String arg1)
```
    Post a message to a channel.
    Redis command PUBLISH.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxPublish
```
public Maybe<Response> rxPublish(String arg0,
                                 String arg1)
```
    Post a message to a channel.
    Redis command PUBLISH.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - pubsub
```
public Maybe<Response> pubsub(List<String> args)
```
    A container for Pub/Sub commands.
    Redis command PUBSUB.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxPubsub
```
public Maybe<Response> rxPubsub(List<String> args)
```
    A container for Pub/Sub commands.
    Redis command PUBSUB.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - punsubscribe
```
public Maybe<Response> punsubscribe(List<String> args)
```
    Stop listening for messages posted to channels matching the given patterns.
    Redis command PUNSUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxPunsubscribe
```
public Maybe<Response> rxPunsubscribe(List<String> args)
```
    Stop listening for messages posted to channels matching the given patterns.
    Redis command PUNSUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - quit
```
public Maybe<Response> quit(List<String> args)
```
    Close the connection.
    Redis command QUIT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxQuit
```
public Maybe<Response> rxQuit(List<String> args)
```
    Close the connection.
    Redis command QUIT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - randomkey
```
public Maybe<Response> randomkey()
```
    Return a random key from the keyspace.
    Redis command RANDOMKEY.
    
    Returns:
    
    fluent self
  - rxRandomkey
```
public Maybe<Response> rxRandomkey()
```
    Return a random key from the keyspace.
    Redis command RANDOMKEY.
    
    Returns:
    
    fluent self
  - readonly
```
public Maybe<Response> readonly()
```
    Enables read queries for a connection to a cluster replica node.
    Redis command READONLY.
    
    Returns:
    
    fluent self
  - rxReadonly
```
public Maybe<Response> rxReadonly()
```
    Enables read queries for a connection to a cluster replica node.
    Redis command READONLY.
    
    Returns:
    
    fluent self
  - readwrite
```
public Maybe<Response> readwrite()
```
    Disables read queries for a connection to a cluster replica node.
    Redis command READWRITE.
    
    Returns:
    
    fluent self
  - rxReadwrite
```
public Maybe<Response> rxReadwrite()
```
    Disables read queries for a connection to a cluster replica node.
    Redis command READWRITE.
    
    Returns:
    
    fluent self
  - rename
```
public Maybe<Response> rename(String arg0,
                              String arg1)
```
    Rename a key.
    Redis command RENAME.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxRename
```
public Maybe<Response> rxRename(String arg0,
                                String arg1)
```
    Rename a key.
    Redis command RENAME.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - renamenx
```
public Maybe<Response> renamenx(String arg0,
                                String arg1)
```
    Rename a key, only if the new key does not exist.
    Redis command RENAMENX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxRenamenx
```
public Maybe<Response> rxRenamenx(String arg0,
                                  String arg1)
```
    Rename a key, only if the new key does not exist.
    Redis command RENAMENX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - replconf
```
public Maybe<Response> replconf(List<String> args)
```
    An internal command for configuring the replication stream.
    Redis command REPLCONF.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxReplconf
```
public Maybe<Response> rxReplconf(List<String> args)
```
    An internal command for configuring the replication stream.
    Redis command REPLCONF.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - replicaof
```
public Maybe<Response> replicaof(String arg0,
                                 String arg1)
```
    Make the server a replica of another instance, or promote it as master.
    Redis command REPLICAOF.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxReplicaof
```
public Maybe<Response> rxReplicaof(String arg0,
                                   String arg1)
```
    Make the server a replica of another instance, or promote it as master.
    Redis command REPLICAOF.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - reset
```
public Maybe<Response> reset()
```
    Reset the connection.
    Redis command RESET.
    
    Returns:
    
    fluent self
  - rxReset
```
public Maybe<Response> rxReset()
```
    Reset the connection.
    Redis command RESET.
    
    Returns:
    
    fluent self
  - restore
```
public Maybe<Response> restore(List<String> args)
```
    Create a key using the provided serialized value, previously obtained using DUMP.
    Redis command RESTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxRestore
```
public Maybe<Response> rxRestore(List<String> args)
```
    Create a key using the provided serialized value, previously obtained using DUMP.
    Redis command RESTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - restoreAsking
```
public Maybe<Response> restoreAsking(List<String> args)
```
    An internal command for migrating keys in a cluster.
    Redis command RESTORE-ASKING.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxRestoreAsking
```
public Maybe<Response> rxRestoreAsking(List<String> args)
```
    An internal command for migrating keys in a cluster.
    Redis command RESTORE-ASKING.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - role
```
public Maybe<Response> role()
```
    Return the role of the instance in the context of replication.
    Redis command ROLE.
    
    Returns:
    
    fluent self
  - rxRole
```
public Maybe<Response> rxRole()
```
    Return the role of the instance in the context of replication.
    Redis command ROLE.
    
    Returns:
    
    fluent self
  - rpop
```
public Maybe<Response> rpop(List<String> args)
```
    Remove and get the last elements in a list.
    Redis command RPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxRpop
```
public Maybe<Response> rxRpop(List<String> args)
```
    Remove and get the last elements in a list.
    Redis command RPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rpoplpush
```
public Maybe<Response> rpoplpush(String arg0,
                                 String arg1)
```
    Remove the last element in a list, prepend it to another list and return it.
    Redis command RPOPLPUSH.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxRpoplpush
```
public Maybe<Response> rxRpoplpush(String arg0,
                                   String arg1)
```
    Remove the last element in a list, prepend it to another list and return it.
    Redis command RPOPLPUSH.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rpush
```
public Maybe<Response> rpush(List<String> args)
```
    Append one or multiple elements to a list.
    Redis command RPUSH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxRpush
```
public Maybe<Response> rxRpush(List<String> args)
```
    Append one or multiple elements to a list.
    Redis command RPUSH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rpushx
```
public Maybe<Response> rpushx(List<String> args)
```
    Append an element to a list, only if the list exists.
    Redis command RPUSHX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxRpushx
```
public Maybe<Response> rxRpushx(List<String> args)
```
    Append an element to a list, only if the list exists.
    Redis command RPUSHX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - sadd
```
public Maybe<Response> sadd(List<String> args)
```
    Add one or more members to a set.
    Redis command SADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSadd
```
public Maybe<Response> rxSadd(List<String> args)
```
    Add one or more members to a set.
    Redis command SADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - save
```
public Maybe<Response> save()
```
    Synchronously save the dataset to disk.
    Redis command SAVE.
    
    Returns:
    
    fluent self
  - rxSave
```
public Maybe<Response> rxSave()
```
    Synchronously save the dataset to disk.
    Redis command SAVE.
    
    Returns:
    
    fluent self
  - scan
```
public Maybe<Response> scan(List<String> args)
```
    Incrementally iterate the keys space.
    Redis command SCAN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxScan
```
public Maybe<Response> rxScan(List<String> args)
```
    Incrementally iterate the keys space.
    Redis command SCAN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - scard
```
public Maybe<Response> scard(String arg0)
```
    Get the number of members in a set.
    Redis command SCARD.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxScard
```
public Maybe<Response> rxScard(String arg0)
```
    Get the number of members in a set.
    Redis command SCARD.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - script
```
public Maybe<Response> script(List<String> args)
```
    A container for Lua scripts management commands.
    Redis command SCRIPT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxScript
```
public Maybe<Response> rxScript(List<String> args)
```
    A container for Lua scripts management commands.
    Redis command SCRIPT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - sdiff
```
public Maybe<Response> sdiff(List<String> args)
```
    Subtract multiple sets.
    Redis command SDIFF.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSdiff
```
public Maybe<Response> rxSdiff(List<String> args)
```
    Subtract multiple sets.
    Redis command SDIFF.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - sdiffstore
```
public Maybe<Response> sdiffstore(List<String> args)
```
    Subtract multiple sets and store the resulting set in a key.
    Redis command SDIFFSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSdiffstore
```
public Maybe<Response> rxSdiffstore(List<String> args)
```
    Subtract multiple sets and store the resulting set in a key.
    Redis command SDIFFSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - select
```
public Maybe<Response> select(String arg0)
```
    Change the selected database for the current connection.
    Redis command SELECT.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxSelect
```
public Maybe<Response> rxSelect(String arg0)
```
    Change the selected database for the current connection.
    Redis command SELECT.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - set
```
public Maybe<Response> set(List<String> args)
```
    Set the string value of a key.
    Redis command SET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSet
```
public Maybe<Response> rxSet(List<String> args)
```
    Set the string value of a key.
    Redis command SET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - setbit
```
public Maybe<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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxSetbit
```
public Maybe<Response> rxSetbit(String arg0,
                                String arg1,
                                String arg2)
```
    Sets or clears the bit at offset in the string value stored at key.
    Redis command SETBIT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - setex
```
public Maybe<Response> setex(String arg0,
                             String arg1,
                             String arg2)
```
    Set the value and expiration of a key.
    Redis command SETEX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxSetex
```
public Maybe<Response> rxSetex(String arg0,
                               String arg1,
                               String arg2)
```
    Set the value and expiration of a key.
    Redis command SETEX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - setnx
```
public Maybe<Response> setnx(String arg0,
                             String arg1)
```
    Set the value of a key, only if the key does not exist.
    Redis command SETNX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxSetnx
```
public Maybe<Response> rxSetnx(String arg0,
                               String arg1)
```
    Set the value of a key, only if the key does not exist.
    Redis command SETNX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - setrange
```
public Maybe<Response> setrange(String arg0,
                                String arg1,
                                String arg2)
```
    Overwrite part of a string at key starting at the specified offset.
    Redis command SETRANGE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxSetrange
```
public Maybe<Response> rxSetrange(String arg0,
                                  String arg1,
                                  String arg2)
```
    Overwrite part of a string at key starting at the specified offset.
    Redis command SETRANGE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - shutdown
```
public Maybe<Response> shutdown(List<String> args)
```
    Synchronously save the dataset to disk and then shut down the server.
    Redis command SHUTDOWN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxShutdown
```
public Maybe<Response> rxShutdown(List<String> args)
```
    Synchronously save the dataset to disk and then shut down the server.
    Redis command SHUTDOWN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - sinter
```
public Maybe<Response> sinter(List<String> args)
```
    Intersect multiple sets.
    Redis command SINTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSinter
```
public Maybe<Response> rxSinter(List<String> args)
```
    Intersect multiple sets.
    Redis command SINTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - sintercard
```
public Maybe<Response> sintercard(List<String> args)
```
    Intersect multiple sets and return the cardinality of the result.
    Redis command SINTERCARD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSintercard
```
public Maybe<Response> rxSintercard(List<String> args)
```
    Intersect multiple sets and return the cardinality of the result.
    Redis command SINTERCARD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - sinterstore
```
public Maybe<Response> sinterstore(List<String> args)
```
    Intersect multiple sets and store the resulting set in a key.
    Redis command SINTERSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSinterstore
```
public Maybe<Response> rxSinterstore(List<String> args)
```
    Intersect multiple sets and store the resulting set in a key.
    Redis command SINTERSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - sismember
```
public Maybe<Response> sismember(String arg0,
                                 String arg1)
```
    Determine if a given value is a member of a set.
    Redis command SISMEMBER.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxSismember
```
public Maybe<Response> rxSismember(String arg0,
                                   String arg1)
```
    Determine if a given value is a member of a set.
    Redis command SISMEMBER.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - slaveof
```
public Maybe<Response> slaveof(String arg0,
                               String arg1)
```
    Make the server a replica of another instance, or promote it as master.
    Redis command SLAVEOF.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxSlaveof
```
public Maybe<Response> rxSlaveof(String arg0,
                                 String arg1)
```
    Make the server a replica of another instance, or promote it as master.
    Redis command SLAVEOF.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - slowlog
```
public Maybe<Response> slowlog(List<String> args)
```
    A container for slow log commands.
    Redis command SLOWLOG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSlowlog
```
public Maybe<Response> rxSlowlog(List<String> args)
```
    A container for slow log commands.
    Redis command SLOWLOG.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - smembers
```
public Maybe<Response> smembers(String arg0)
```
    Get all the members in a set.
    Redis command SMEMBERS.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxSmembers
```
public Maybe<Response> rxSmembers(String arg0)
```
    Get all the members in a set.
    Redis command SMEMBERS.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - smismember
```
public Maybe<Response> smismember(List<String> args)
```
    Returns the membership associated with the given elements for a set.
    Redis command SMISMEMBER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSmismember
```
public Maybe<Response> rxSmismember(List<String> args)
```
    Returns the membership associated with the given elements for a set.
    Redis command SMISMEMBER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - smove
```
public Maybe<Response> smove(String arg0,
                             String arg1,
                             String arg2)
```
    Move a member from one set to another.
    Redis command SMOVE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxSmove
```
public Maybe<Response> rxSmove(String arg0,
                               String arg1,
                               String arg2)
```
    Move a member from one set to another.
    Redis command SMOVE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - sort
```
public Maybe<Response> sort(List<String> args)
```
    Sort the elements in a list, set or sorted set.
    Redis command SORT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSort
```
public Maybe<Response> rxSort(List<String> args)
```
    Sort the elements in a list, set or sorted set.
    Redis command SORT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - sortRo
```
public Maybe<Response> sortRo(List<String> args)
```
    Sort the elements in a list, set or sorted set. Read-only variant of SORT.
    Redis command SORT_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSortRo
```
public Maybe<Response> rxSortRo(List<String> args)
```
    Sort the elements in a list, set or sorted set. Read-only variant of SORT.
    Redis command SORT_RO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - spop
```
public Maybe<Response> spop(List<String> args)
```
    Remove and return one or multiple random members from a set.
    Redis command SPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSpop
```
public Maybe<Response> rxSpop(List<String> args)
```
    Remove and return one or multiple random members from a set.
    Redis command SPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - spublish
```
public Maybe<Response> spublish(String arg0,
                                String arg1)
```
    Post a message to a shard channel.
    Redis command SPUBLISH.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxSpublish
```
public Maybe<Response> rxSpublish(String arg0,
                                  String arg1)
```
    Post a message to a shard channel.
    Redis command SPUBLISH.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - srandmember
```
public Maybe<Response> srandmember(List<String> args)
```
    Get one or multiple random members from a set.
    Redis command SRANDMEMBER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSrandmember
```
public Maybe<Response> rxSrandmember(List<String> args)
```
    Get one or multiple random members from a set.
    Redis command SRANDMEMBER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - srem
```
public Maybe<Response> srem(List<String> args)
```
    Remove one or more members from a set.
    Redis command SREM.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSrem
```
public Maybe<Response> rxSrem(List<String> args)
```
    Remove one or more members from a set.
    Redis command SREM.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - sscan
```
public Maybe<Response> sscan(List<String> args)
```
    Incrementally iterate Set elements.
    Redis command SSCAN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSscan
```
public Maybe<Response> rxSscan(List<String> args)
```
    Incrementally iterate Set elements.
    Redis command SSCAN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ssubscribe
```
public Maybe<Response> ssubscribe(List<String> args)
```
    Listen for messages published to the given shard channels.
    Redis command SSUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSsubscribe
```
public Maybe<Response> rxSsubscribe(List<String> args)
```
    Listen for messages published to the given shard channels.
    Redis command SSUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - strlen
```
public Maybe<Response> strlen(String arg0)
```
    Get the length of the value stored in a key.
    Redis command STRLEN.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxStrlen
```
public Maybe<Response> rxStrlen(String arg0)
```
    Get the length of the value stored in a key.
    Redis command STRLEN.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - subscribe
```
public Maybe<Response> subscribe(List<String> args)
```
    Listen for messages published to the given channels.
    Redis command SUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSubscribe
```
public Maybe<Response> rxSubscribe(List<String> args)
```
    Listen for messages published to the given channels.
    Redis command SUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - substr
```
public Maybe<Response> substr(String arg0,
                              String arg1,
                              String arg2)
```
    Get a substring of the string stored at a key.
    Redis command SUBSTR.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxSubstr
```
public Maybe<Response> rxSubstr(String arg0,
                                String arg1,
                                String arg2)
```
    Get a substring of the string stored at a key.
    Redis command SUBSTR.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - sunion
```
public Maybe<Response> sunion(List<String> args)
```
    Add multiple sets.
    Redis command SUNION.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSunion
```
public Maybe<Response> rxSunion(List<String> args)
```
    Add multiple sets.
    Redis command SUNION.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - sunionstore
```
public Maybe<Response> sunionstore(List<String> args)
```
    Add multiple sets and store the resulting set in a key.
    Redis command SUNIONSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSunionstore
```
public Maybe<Response> rxSunionstore(List<String> args)
```
    Add multiple sets and store the resulting set in a key.
    Redis command SUNIONSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - sunsubscribe
```
public Maybe<Response> sunsubscribe(List<String> args)
```
    Stop listening for messages posted to the given shard channels.
    Redis command SUNSUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxSunsubscribe
```
public Maybe<Response> rxSunsubscribe(List<String> args)
```
    Stop listening for messages posted to the given shard channels.
    Redis command SUNSUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - swapdb
```
public Maybe<Response> swapdb(String arg0,
                              String arg1)
```
    Swaps two Redis databases.
    Redis command SWAPDB.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxSwapdb
```
public Maybe<Response> rxSwapdb(String arg0,
                                String arg1)
```
    Swaps two Redis databases.
    Redis command SWAPDB.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - sync
```
public Maybe<Response> sync()
```
    Internal command used for replication.
    Redis command SYNC.
    
    Returns:
    
    fluent self
  - rxSync
```
public Maybe<Response> rxSync()
```
    Internal command used for replication.
    Redis command SYNC.
    
    Returns:
    
    fluent self
  - tdigestAdd
```
public Maybe<Response> tdigestAdd(List<String> args)
```
    Redis command TDIGEST.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestAdd
```
public Maybe<Response> rxTdigestAdd(List<String> args)
```
    Redis command TDIGEST.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestByrank
```
public Maybe<Response> tdigestByrank(List<String> args)
```
    Redis command TDIGEST.BYRANK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestByrank
```
public Maybe<Response> rxTdigestByrank(List<String> args)
```
    Redis command TDIGEST.BYRANK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestByrevrank
```
public Maybe<Response> tdigestByrevrank(List<String> args)
```
    Redis command TDIGEST.BYREVRANK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestByrevrank
```
public Maybe<Response> rxTdigestByrevrank(List<String> args)
```
    Redis command TDIGEST.BYREVRANK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestCdf
```
public Maybe<Response> tdigestCdf(List<String> args)
```
    Redis command TDIGEST.CDF.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestCdf
```
public Maybe<Response> rxTdigestCdf(List<String> args)
```
    Redis command TDIGEST.CDF.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestCreate
```
public Maybe<Response> tdigestCreate(List<String> args)
```
    Redis command TDIGEST.CREATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestCreate
```
public Maybe<Response> rxTdigestCreate(List<String> args)
```
    Redis command TDIGEST.CREATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestInfo
```
public Maybe<Response> tdigestInfo(List<String> args)
```
    Redis command TDIGEST.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestInfo
```
public Maybe<Response> rxTdigestInfo(List<String> args)
```
    Redis command TDIGEST.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestMax
```
public Maybe<Response> tdigestMax(List<String> args)
```
    Redis command TDIGEST.MAX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestMax
```
public Maybe<Response> rxTdigestMax(List<String> args)
```
    Redis command TDIGEST.MAX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestMerge
```
public Maybe<Response> tdigestMerge(List<String> args)
```
    Redis command TDIGEST.MERGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestMerge
```
public Maybe<Response> rxTdigestMerge(List<String> args)
```
    Redis command TDIGEST.MERGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestMin
```
public Maybe<Response> tdigestMin(List<String> args)
```
    Redis command TDIGEST.MIN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestMin
```
public Maybe<Response> rxTdigestMin(List<String> args)
```
    Redis command TDIGEST.MIN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestQuantile
```
public Maybe<Response> tdigestQuantile(List<String> args)
```
    Redis command TDIGEST.QUANTILE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestQuantile
```
public Maybe<Response> rxTdigestQuantile(List<String> args)
```
    Redis command TDIGEST.QUANTILE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestRank
```
public Maybe<Response> tdigestRank(List<String> args)
```
    Redis command TDIGEST.RANK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestRank
```
public Maybe<Response> rxTdigestRank(List<String> args)
```
    Redis command TDIGEST.RANK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestReset
```
public Maybe<Response> tdigestReset(List<String> args)
```
    Redis command TDIGEST.RESET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestReset
```
public Maybe<Response> rxTdigestReset(List<String> args)
```
    Redis command TDIGEST.RESET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestRevrank
```
public Maybe<Response> tdigestRevrank(List<String> args)
```
    Redis command TDIGEST.REVRANK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestRevrank
```
public Maybe<Response> rxTdigestRevrank(List<String> args)
```
    Redis command TDIGEST.REVRANK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tdigestTrimmedMean
```
public Maybe<Response> tdigestTrimmedMean(List<String> args)
```
    Redis command TDIGEST.TRIMMED_MEAN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTdigestTrimmedMean
```
public Maybe<Response> rxTdigestTrimmedMean(List<String> args)
```
    Redis command TDIGEST.TRIMMED_MEAN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - time
```
public Maybe<Response> time()
```
    Return the current server time.
    Redis command TIME.
    
    Returns:
    
    fluent self
  - rxTime
```
public Maybe<Response> rxTime()
```
    Return the current server time.
    Redis command TIME.
    
    Returns:
    
    fluent self
  - timeseriesClusterset
```
public Maybe<Response> timeseriesClusterset(List<String> args)
```
    Redis command TIMESERIES.CLUSTERSET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTimeseriesClusterset
```
public Maybe<Response> rxTimeseriesClusterset(List<String> args)
```
    Redis command TIMESERIES.CLUSTERSET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - timeseriesClustersetfromshard
```
public Maybe<Response> timeseriesClustersetfromshard(List<String> args)
```
    Redis command TIMESERIES.CLUSTERSETFROMSHARD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTimeseriesClustersetfromshard
```
public Maybe<Response> rxTimeseriesClustersetfromshard(List<String> args)
```
    Redis command TIMESERIES.CLUSTERSETFROMSHARD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - timeseriesHello
```
public Maybe<Response> timeseriesHello(List<String> args)
```
    Redis command TIMESERIES.HELLO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTimeseriesHello
```
public Maybe<Response> rxTimeseriesHello(List<String> args)
```
    Redis command TIMESERIES.HELLO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - timeseriesInfocluster
```
public Maybe<Response> timeseriesInfocluster(List<String> args)
```
    Redis command TIMESERIES.INFOCLUSTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTimeseriesInfocluster
```
public Maybe<Response> rxTimeseriesInfocluster(List<String> args)
```
    Redis command TIMESERIES.INFOCLUSTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - timeseriesInnercommunication
```
public Maybe<Response> timeseriesInnercommunication(List<String> args)
```
    Redis command TIMESERIES.INNERCOMMUNICATION.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTimeseriesInnercommunication
```
public Maybe<Response> rxTimeseriesInnercommunication(List<String> args)
```
    Redis command TIMESERIES.INNERCOMMUNICATION.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - timeseriesNetworktest
```
public Maybe<Response> timeseriesNetworktest(List<String> args)
```
    Redis command TIMESERIES.NETWORKTEST.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTimeseriesNetworktest
```
public Maybe<Response> rxTimeseriesNetworktest(List<String> args)
```
    Redis command TIMESERIES.NETWORKTEST.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - timeseriesRefreshcluster
```
public Maybe<Response> timeseriesRefreshcluster(List<String> args)
```
    Redis command TIMESERIES.REFRESHCLUSTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTimeseriesRefreshcluster
```
public Maybe<Response> rxTimeseriesRefreshcluster(List<String> args)
```
    Redis command TIMESERIES.REFRESHCLUSTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - topkAdd
```
public Maybe<Response> topkAdd(List<String> args)
```
    Redis command TOPK.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTopkAdd
```
public Maybe<Response> rxTopkAdd(List<String> args)
```
    Redis command TOPK.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - topkCount
```
public Maybe<Response> topkCount(List<String> args)
```
    Redis command TOPK.COUNT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTopkCount
```
public Maybe<Response> rxTopkCount(List<String> args)
```
    Redis command TOPK.COUNT.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - topkIncrby
```
public Maybe<Response> topkIncrby(List<String> args)
```
    Redis command TOPK.INCRBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTopkIncrby
```
public Maybe<Response> rxTopkIncrby(List<String> args)
```
    Redis command TOPK.INCRBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - topkInfo
```
public Maybe<Response> topkInfo(List<String> args)
```
    Redis command TOPK.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTopkInfo
```
public Maybe<Response> rxTopkInfo(List<String> args)
```
    Redis command TOPK.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - topkList
```
public Maybe<Response> topkList(List<String> args)
```
    Redis command TOPK.LIST.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTopkList
```
public Maybe<Response> rxTopkList(List<String> args)
```
    Redis command TOPK.LIST.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - topkQuery
```
public Maybe<Response> topkQuery(List<String> args)
```
    Redis command TOPK.QUERY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTopkQuery
```
public Maybe<Response> rxTopkQuery(List<String> args)
```
    Redis command TOPK.QUERY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - topkReserve
```
public Maybe<Response> topkReserve(List<String> args)
```
    Redis command TOPK.RESERVE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTopkReserve
```
public Maybe<Response> rxTopkReserve(List<String> args)
```
    Redis command TOPK.RESERVE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - touch
```
public Maybe<Response> touch(List<String> args)
```
    Alters the last access time of a key(s). Returns the number of existing keys specified.
    Redis command TOUCH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTouch
```
public Maybe<Response> rxTouch(List<String> args)
```
    Alters the last access time of a key(s). Returns the number of existing keys specified.
    Redis command TOUCH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsAdd
```
public Maybe<Response> tsAdd(List<String> args)
```
    Redis command TS.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsAdd
```
public Maybe<Response> rxTsAdd(List<String> args)
```
    Redis command TS.ADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsAlter
```
public Maybe<Response> tsAlter(List<String> args)
```
    Redis command TS.ALTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsAlter
```
public Maybe<Response> rxTsAlter(List<String> args)
```
    Redis command TS.ALTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsCreate
```
public Maybe<Response> tsCreate(List<String> args)
```
    Redis command TS.CREATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsCreate
```
public Maybe<Response> rxTsCreate(List<String> args)
```
    Redis command TS.CREATE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsCreaterule
```
public Maybe<Response> tsCreaterule(List<String> args)
```
    Redis command TS.CREATERULE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsCreaterule
```
public Maybe<Response> rxTsCreaterule(List<String> args)
```
    Redis command TS.CREATERULE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsDecrby
```
public Maybe<Response> tsDecrby(List<String> args)
```
    Redis command TS.DECRBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsDecrby
```
public Maybe<Response> rxTsDecrby(List<String> args)
```
    Redis command TS.DECRBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsDel
```
public Maybe<Response> tsDel(List<String> args)
```
    Redis command TS.DEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsDel
```
public Maybe<Response> rxTsDel(List<String> args)
```
    Redis command TS.DEL.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsDeleterule
```
public Maybe<Response> tsDeleterule(List<String> args)
```
    Redis command TS.DELETERULE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsDeleterule
```
public Maybe<Response> rxTsDeleterule(List<String> args)
```
    Redis command TS.DELETERULE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsGet
```
public Maybe<Response> tsGet(List<String> args)
```
    Redis command TS.GET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsGet
```
public Maybe<Response> rxTsGet(List<String> args)
```
    Redis command TS.GET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsIncrby
```
public Maybe<Response> tsIncrby(List<String> args)
```
    Redis command TS.INCRBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsIncrby
```
public Maybe<Response> rxTsIncrby(List<String> args)
```
    Redis command TS.INCRBY.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsInfo
```
public Maybe<Response> tsInfo(List<String> args)
```
    Redis command TS.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsInfo
```
public Maybe<Response> rxTsInfo(List<String> args)
```
    Redis command TS.INFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsMadd
```
public Maybe<Response> tsMadd(List<String> args)
```
    Redis command TS.MADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsMadd
```
public Maybe<Response> rxTsMadd(List<String> args)
```
    Redis command TS.MADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsMget
```
public Maybe<Response> tsMget(List<String> args)
```
    Redis command TS.MGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsMget
```
public Maybe<Response> rxTsMget(List<String> args)
```
    Redis command TS.MGET.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsMrange
```
public Maybe<Response> tsMrange(List<String> args)
```
    Redis command TS.MRANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsMrange
```
public Maybe<Response> rxTsMrange(List<String> args)
```
    Redis command TS.MRANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsMrevrange
```
public Maybe<Response> tsMrevrange(List<String> args)
```
    Redis command TS.MREVRANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsMrevrange
```
public Maybe<Response> rxTsMrevrange(List<String> args)
```
    Redis command TS.MREVRANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsQueryindex
```
public Maybe<Response> tsQueryindex(List<String> args)
```
    Redis command TS.QUERYINDEX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsQueryindex
```
public Maybe<Response> rxTsQueryindex(List<String> args)
```
    Redis command TS.QUERYINDEX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsRange
```
public Maybe<Response> tsRange(List<String> args)
```
    Redis command TS.RANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsRange
```
public Maybe<Response> rxTsRange(List<String> args)
```
    Redis command TS.RANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - tsRevrange
```
public Maybe<Response> tsRevrange(List<String> args)
```
    Redis command TS.REVRANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxTsRevrange
```
public Maybe<Response> rxTsRevrange(List<String> args)
```
    Redis command TS.REVRANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - ttl
```
public Maybe<Response> ttl(String arg0)
```
    Get the time to live for a key in seconds.
    Redis command TTL.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxTtl
```
public Maybe<Response> rxTtl(String arg0)
```
    Get the time to live for a key in seconds.
    Redis command TTL.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - type
```
public Maybe<Response> type(String arg0)
```
    Determine the type stored at key.
    Redis command TYPE.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxType
```
public Maybe<Response> rxType(String arg0)
```
    Determine the type stored at key.
    Redis command TYPE.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - unlink
```
public Maybe<Response> unlink(List<String> args)
```
    Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
    Redis command UNLINK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxUnlink
```
public Maybe<Response> rxUnlink(List<String> args)
```
    Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
    Redis command UNLINK.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - unsubscribe
```
public Maybe<Response> unsubscribe(List<String> args)
```
    Stop listening for messages posted to the given channels.
    Redis command UNSUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxUnsubscribe
```
public Maybe<Response> rxUnsubscribe(List<String> args)
```
    Stop listening for messages posted to the given channels.
    Redis command UNSUBSCRIBE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - unwatch
```
public Maybe<Response> unwatch()
```
    Forget about all watched keys.
    Redis command UNWATCH.
    
    Returns:
    
    fluent self
  - rxUnwatch
```
public Maybe<Response> rxUnwatch()
```
    Forget about all watched keys.
    Redis command UNWATCH.
    
    Returns:
    
    fluent self
  - wait
```
public Maybe<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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxWait
```
public Maybe<Response> rxWait(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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - watch
```
public Maybe<Response> watch(List<String> args)
```
    Watch the given keys to determine execution of the MULTI/EXEC block.
    Redis command WATCH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxWatch
```
public Maybe<Response> rxWatch(List<String> args)
```
    Watch the given keys to determine execution of the MULTI/EXEC block.
    Redis command WATCH.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xack
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXack
```
public Maybe<Response> rxXack(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xadd
```
public Maybe<Response> xadd(List<String> args)
```
    Appends a new entry to a stream.
    Redis command XADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXadd
```
public Maybe<Response> rxXadd(List<String> args)
```
    Appends a new entry to a stream.
    Redis command XADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xautoclaim
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXautoclaim
```
public Maybe<Response> rxXautoclaim(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xclaim
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXclaim
```
public Maybe<Response> rxXclaim(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xdel
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXdel
```
public Maybe<Response> rxXdel(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xgroup
```
public Maybe<Response> xgroup(List<String> args)
```
    A container for consumer groups commands.
    Redis command XGROUP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXgroup
```
public Maybe<Response> rxXgroup(List<String> args)
```
    A container for consumer groups commands.
    Redis command XGROUP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xinfo
```
public Maybe<Response> xinfo(List<String> args)
```
    A container for stream introspection commands.
    Redis command XINFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXinfo
```
public Maybe<Response> rxXinfo(List<String> args)
```
    A container for stream introspection commands.
    Redis command XINFO.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xlen
```
public Maybe<Response> xlen(String arg0)
```
    Return the number of entries in a stream.
    Redis command XLEN.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxXlen
```
public Maybe<Response> rxXlen(String arg0)
```
    Return the number of entries in a stream.
    Redis command XLEN.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - xpending
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXpending
```
public Maybe<Response> rxXpending(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xrange
```
public Maybe<Response> xrange(List<String> args)
```
    Return a range of elements in a stream, with IDs matching the specified IDs interval.
    Redis command XRANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXrange
```
public Maybe<Response> rxXrange(List<String> args)
```
    Return a range of elements in a stream, with IDs matching the specified IDs interval.
    Redis command XRANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xread
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXread
```
public Maybe<Response> rxXread(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xreadgroup
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXreadgroup
```
public Maybe<Response> rxXreadgroup(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xrevrange
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXrevrange
```
public Maybe<Response> rxXrevrange(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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xsetid
```
public Maybe<Response> xsetid(List<String> args)
```
    An internal command for replicating stream values.
    Redis command XSETID.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXsetid
```
public Maybe<Response> rxXsetid(List<String> args)
```
    An internal command for replicating stream values.
    Redis command XSETID.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - xtrim
```
public Maybe<Response> xtrim(List<String> args)
```
    Trims the stream to (approximately if '~' is passed) a certain size.
    Redis command XTRIM.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxXtrim
```
public Maybe<Response> rxXtrim(List<String> args)
```
    Trims the stream to (approximately if '~' is passed) a certain size.
    Redis command XTRIM.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zadd
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZadd
```
public Maybe<Response> rxZadd(List<String> args)
```
    Add one or more members to a sorted set, or update its score if it already exists.
    Redis command ZADD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zcard
```
public Maybe<Response> zcard(String arg0)
```
    Get the number of members in a sorted set.
    Redis command ZCARD.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - rxZcard
```
public Maybe<Response> rxZcard(String arg0)
```
    Get the number of members in a sorted set.
    Redis command ZCARD.
    
    Parameters:
    
    arg0 -
    
    Returns:
    
    fluent self
  - zcount
```
public Maybe<Response> zcount(String arg0,
                              String arg1,
                              String arg2)
```
    Count the members in a sorted set with scores within the given values.
    Redis command ZCOUNT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxZcount
```
public Maybe<Response> rxZcount(String arg0,
                                String arg1,
                                String arg2)
```
    Count the members in a sorted set with scores within the given values.
    Redis command ZCOUNT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - zdiff
```
public Maybe<Response> zdiff(List<String> args)
```
    Subtract multiple sorted sets.
    Redis command ZDIFF.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZdiff
```
public Maybe<Response> rxZdiff(List<String> args)
```
    Subtract multiple sorted sets.
    Redis command ZDIFF.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zdiffstore
```
public Maybe<Response> zdiffstore(List<String> args)
```
    Subtract multiple sorted sets and store the resulting sorted set in a new key.
    Redis command ZDIFFSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZdiffstore
```
public Maybe<Response> rxZdiffstore(List<String> args)
```
    Subtract multiple sorted sets and store the resulting sorted set in a new key.
    Redis command ZDIFFSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zincrby
```
public Maybe<Response> zincrby(String arg0,
                               String arg1,
                               String arg2)
```
    Increment the score of a member in a sorted set.
    Redis command ZINCRBY.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxZincrby
```
public Maybe<Response> rxZincrby(String arg0,
                                 String arg1,
                                 String arg2)
```
    Increment the score of a member in a sorted set.
    Redis command ZINCRBY.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - zinter
```
public Maybe<Response> zinter(List<String> args)
```
    Intersect multiple sorted sets.
    Redis command ZINTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZinter
```
public Maybe<Response> rxZinter(List<String> args)
```
    Intersect multiple sorted sets.
    Redis command ZINTER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zintercard
```
public Maybe<Response> zintercard(List<String> args)
```
    Intersect multiple sorted sets and return the cardinality of the result.
    Redis command ZINTERCARD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZintercard
```
public Maybe<Response> rxZintercard(List<String> args)
```
    Intersect multiple sorted sets and return the cardinality of the result.
    Redis command ZINTERCARD.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zinterstore
```
public Maybe<Response> zinterstore(List<String> args)
```
    Intersect multiple sorted sets and store the resulting sorted set in a new key.
    Redis command ZINTERSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZinterstore
```
public Maybe<Response> rxZinterstore(List<String> args)
```
    Intersect multiple sorted sets and store the resulting sorted set in a new key.
    Redis command ZINTERSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zlexcount
```
public Maybe<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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxZlexcount
```
public Maybe<Response> rxZlexcount(String arg0,
                                   String arg1,
                                   String arg2)
```
    Count the number of members in a sorted set between a given lexicographical range.
    Redis command ZLEXCOUNT.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - zmpop
```
public Maybe<Response> zmpop(List<String> args)
```
    Remove and return members with scores in a sorted set.
    Redis command ZMPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZmpop
```
public Maybe<Response> rxZmpop(List<String> args)
```
    Remove and return members with scores in a sorted set.
    Redis command ZMPOP.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zmscore
```
public Maybe<Response> zmscore(List<String> args)
```
    Get the score associated with the given members in a sorted set.
    Redis command ZMSCORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZmscore
```
public Maybe<Response> rxZmscore(List<String> args)
```
    Get the score associated with the given members in a sorted set.
    Redis command ZMSCORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zpopmax
```
public Maybe<Response> zpopmax(List<String> args)
```
    Remove and return members with the highest scores in a sorted set.
    Redis command ZPOPMAX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZpopmax
```
public Maybe<Response> rxZpopmax(List<String> args)
```
    Remove and return members with the highest scores in a sorted set.
    Redis command ZPOPMAX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zpopmin
```
public Maybe<Response> zpopmin(List<String> args)
```
    Remove and return members with the lowest scores in a sorted set.
    Redis command ZPOPMIN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZpopmin
```
public Maybe<Response> rxZpopmin(List<String> args)
```
    Remove and return members with the lowest scores in a sorted set.
    Redis command ZPOPMIN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zrandmember
```
public Maybe<Response> zrandmember(List<String> args)
```
    Get one or multiple random elements from a sorted set.
    Redis command ZRANDMEMBER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZrandmember
```
public Maybe<Response> rxZrandmember(List<String> args)
```
    Get one or multiple random elements from a sorted set.
    Redis command ZRANDMEMBER.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zrange
```
public Maybe<Response> zrange(List<String> args)
```
    Return a range of members in a sorted set.
    Redis command ZRANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZrange
```
public Maybe<Response> rxZrange(List<String> args)
```
    Return a range of members in a sorted set.
    Redis command ZRANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zrangebylex
```
public Maybe<Response> zrangebylex(List<String> args)
```
    Return a range of members in a sorted set, by lexicographical range.
    Redis command ZRANGEBYLEX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZrangebylex
```
public Maybe<Response> rxZrangebylex(List<String> args)
```
    Return a range of members in a sorted set, by lexicographical range.
    Redis command ZRANGEBYLEX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zrangebyscore
```
public Maybe<Response> zrangebyscore(List<String> args)
```
    Return a range of members in a sorted set, by score.
    Redis command ZRANGEBYSCORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZrangebyscore
```
public Maybe<Response> rxZrangebyscore(List<String> args)
```
    Return a range of members in a sorted set, by score.
    Redis command ZRANGEBYSCORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zrangestore
```
public Maybe<Response> zrangestore(List<String> args)
```
    Store a range of members from sorted set into another key.
    Redis command ZRANGESTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZrangestore
```
public Maybe<Response> rxZrangestore(List<String> args)
```
    Store a range of members from sorted set into another key.
    Redis command ZRANGESTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zrank
```
public Maybe<Response> zrank(String arg0,
                             String arg1)
```
    Determine the index of a member in a sorted set.
    Redis command ZRANK.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxZrank
```
public Maybe<Response> rxZrank(String arg0,
                               String arg1)
```
    Determine the index of a member in a sorted set.
    Redis command ZRANK.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - zrem
```
public Maybe<Response> zrem(List<String> args)
```
    Remove one or more members from a sorted set.
    Redis command ZREM.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZrem
```
public Maybe<Response> rxZrem(List<String> args)
```
    Remove one or more members from a sorted set.
    Redis command ZREM.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zremrangebylex
```
public Maybe<Response> zremrangebylex(String arg0,
                                      String arg1,
                                      String arg2)
```
    Remove all members in a sorted set between the given lexicographical range.
    Redis command ZREMRANGEBYLEX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxZremrangebylex
```
public Maybe<Response> rxZremrangebylex(String arg0,
                                        String arg1,
                                        String arg2)
```
    Remove all members in a sorted set between the given lexicographical range.
    Redis command ZREMRANGEBYLEX.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - zremrangebyrank
```
public Maybe<Response> zremrangebyrank(String arg0,
                                       String arg1,
                                       String arg2)
```
    Remove all members in a sorted set within the given indexes.
    Redis command ZREMRANGEBYRANK.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxZremrangebyrank
```
public Maybe<Response> rxZremrangebyrank(String arg0,
                                         String arg1,
                                         String arg2)
```
    Remove all members in a sorted set within the given indexes.
    Redis command ZREMRANGEBYRANK.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - zremrangebyscore
```
public Maybe<Response> zremrangebyscore(String arg0,
                                        String arg1,
                                        String arg2)
```
    Remove all members in a sorted set within the given scores.
    Redis command ZREMRANGEBYSCORE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - rxZremrangebyscore
```
public Maybe<Response> rxZremrangebyscore(String arg0,
                                          String arg1,
                                          String arg2)
```
    Remove all members in a sorted set within the given scores.
    Redis command ZREMRANGEBYSCORE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    arg2 -
    
    Returns:
    
    fluent self
  - zrevrange
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZrevrange
```
public Maybe<Response> rxZrevrange(List<String> args)
```
    Return a range of members in a sorted set, by index, with scores ordered from high to low.
    Redis command ZREVRANGE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zrevrangebylex
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZrevrangebylex
```
public Maybe<Response> rxZrevrangebylex(List<String> args)
```
    Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
    Redis command ZREVRANGEBYLEX.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zrevrangebyscore
```
public Maybe<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.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZrevrangebyscore
```
public Maybe<Response> rxZrevrangebyscore(List<String> args)
```
    Return a range of members in a sorted set, by score, with scores ordered from high to low.
    Redis command ZREVRANGEBYSCORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zrevrank
```
public Maybe<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.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxZrevrank
```
public Maybe<Response> rxZrevrank(String arg0,
                                  String arg1)
```
    Determine the index of a member in a sorted set, with scores ordered from high to low.
    Redis command ZREVRANK.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - zscan
```
public Maybe<Response> zscan(List<String> args)
```
    Incrementally iterate sorted sets elements and associated scores.
    Redis command ZSCAN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZscan
```
public Maybe<Response> rxZscan(List<String> args)
```
    Incrementally iterate sorted sets elements and associated scores.
    Redis command ZSCAN.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zscore
```
public Maybe<Response> zscore(String arg0,
                              String arg1)
```
    Get the score associated with the given member in a sorted set.
    Redis command ZSCORE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - rxZscore
```
public Maybe<Response> rxZscore(String arg0,
                                String arg1)
```
    Get the score associated with the given member in a sorted set.
    Redis command ZSCORE.
    
    Parameters:
    
    arg0 -
    
    arg1 -
    
    Returns:
    
    fluent self
  - zunion
```
public Maybe<Response> zunion(List<String> args)
```
    Add multiple sorted sets.
    Redis command ZUNION.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZunion
```
public Maybe<Response> rxZunion(List<String> args)
```
    Add multiple sorted sets.
    Redis command ZUNION.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - zunionstore
```
public Maybe<Response> zunionstore(List<String> args)
```
    Add multiple sorted sets and store the resulting sorted set in a new key.
    Redis command ZUNIONSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - rxZunionstore
```
public Maybe<Response> rxZunionstore(List<String> args)
```
    Add multiple sorted sets and store the resulting sorted set in a new key.
    Redis command ZUNIONSTORE.
    
    Parameters:
    
    args -
    
    Returns:
    
    fluent self
  - api
```
public static RedisAPI api(Redis client)
```
  - api
```
public static RedisAPI api(RedisConnection connection)
```
  - newInstance
```
public static RedisAPI newInstance(RedisAPI arg)
```

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

toString

equals

hashCode

getDelegate

close

ftAdd

rxFtAdd

ftAggregate

rxFtAggregate

ftAliasadd

rxFtAliasadd

ftAliasdel

rxFtAliasdel

ftAliasupdate

rxFtAliasupdate

ftAlter

rxFtAlter

ftConfig

rxFtConfig

ftCreate

rxFtCreate

ftCursor

rxFtCursor

ftDebug

rxFtDebug

ftDel

rxFtDel

ftDictadd

rxFtDictadd

ftDictdel

rxFtDictdel

ftDictdump

rxFtDictdump

ftDrop

rxFtDrop

ftDropindex

rxFtDropindex

ftExplain

rxFtExplain

ftExplaincli

rxFtExplaincli

ftGet

rxFtGet

ftInfo

rxFtInfo

ftMget

rxFtMget

ftProfile

rxFtProfile

ftSafeadd

rxFtSafeadd

ftSearch

rxFtSearch

ftSpellcheck

rxFtSpellcheck

ftSugadd

rxFtSugadd

ftSugdel

rxFtSugdel

ftSugget

rxFtSugget

ftSuglen

rxFtSuglen

ftSynadd

rxFtSynadd

ftSyndump

rxFtSyndump

ftSynupdate

rxFtSynupdate