RedisAPI (Vert.x Stack - Docs 4.1.8 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)` Redis command acl.
`static RedisAPI`	`api(Redis client)`
`static RedisAPI`	`api(RedisConnection connection)`
`Maybe<Response>`	`append(String arg0, String arg1)` Redis command append.
`Maybe<Response>`	`asking()` Redis command asking.
`Maybe<Response>`	`auth(List<String> args)` Redis command auth.
`Maybe<Response>`	`bgrewriteaof()` Redis command bgrewriteaof.
`Maybe<Response>`	`bgsave(List<String> args)` Redis command bgsave.
`Maybe<Response>`	`bitcount(List<String> args)` Redis command bitcount.
`Maybe<Response>`	`bitfield(List<String> args)` Redis command bitfield.
`Maybe<Response>`	`bitfieldRo(List<String> args)` Redis command bitfieldRo.
`Maybe<Response>`	`bitop(List<String> args)` Redis command bitop.
`Maybe<Response>`	`bitpos(List<String> args)` Redis command bitpos.
`Maybe<Response>`	`blpop(List<String> args)` Redis command blpop.
`Maybe<Response>`	`brpop(List<String> args)` Redis command brpop.
`Maybe<Response>`	`brpoplpush(String arg0, String arg1, String arg2)` Redis command brpoplpush.
`Maybe<Response>`	`bzpopmax(List<String> args)` Redis command bzpopmax.
`Maybe<Response>`	`bzpopmin(List<String> args)` Redis command bzpopmin.
`Maybe<Response>`	`client(List<String> args)` Redis command client.
`void`	`close()`
`Maybe<Response>`	`cluster(List<String> args)` Redis command cluster.
`Maybe<Response>`	`command(List<String> args)` Redis command command.
`Maybe<Response>`	`config(List<String> args)` Redis command config.
`Maybe<Response>`	`dbsize()` Redis command dbsize.
`Maybe<Response>`	`debug(List<String> args)` Redis command debug.
`Maybe<Response>`	`decr(String arg0)` Redis command decr.
`Maybe<Response>`	`decrby(String arg0, String arg1)` Redis command decrby.
`Maybe<Response>`	`del(List<String> args)` Redis command del.
`Maybe<Response>`	`discard()` Redis command discard.
`Maybe<Response>`	`dump(String arg0)` Redis command dump.
`Maybe<Response>`	`echo(String arg0)` Redis command echo.
`boolean`	`equals(Object o)`
`Maybe<Response>`	`eval(List<String> args)` Redis command eval.
`Maybe<Response>`	`evalsha(List<String> args)` Redis command evalsha.
`Maybe<Response>`	`exec()` Redis command exec.
`Maybe<Response>`	`exists(List<String> args)` Redis command exists.
`Maybe<Response>`	`expire(String arg0, String arg1)` Redis command expire.
`Maybe<Response>`	`expireat(String arg0, String arg1)` Redis command expireat.
`Maybe<Response>`	`flushall(List<String> args)` Redis command flushall.
`Maybe<Response>`	`flushdb(List<String> args)` Redis command flushdb.
`Maybe<Response>`	`geoadd(List<String> args)` Redis command geoadd.
`Maybe<Response>`	`geodist(List<String> args)` Redis command geodist.
`Maybe<Response>`	`geohash(List<String> args)` Redis command geohash.
`Maybe<Response>`	`geopos(List<String> args)` Redis command geopos.
`Maybe<Response>`	`georadius(List<String> args)` Redis command georadius.
`Maybe<Response>`	`georadiusbymember(List<String> args)` Redis command georadiusbymember.
`Maybe<Response>`	`georadiusbymemberRo(List<String> args)` Redis command georadiusbymemberRo.
`Maybe<Response>`	`georadiusRo(List<String> args)` Redis command georadiusRo.
`Maybe<Response>`	`get(String arg0)` Redis command get.
`Maybe<Response>`	`getbit(String arg0, String arg1)` Redis command getbit.
`RedisAPI`	`getDelegate()`
`Maybe<Response>`	`getrange(String arg0, String arg1, String arg2)` Redis command getrange.
`Maybe<Response>`	`getset(String arg0, String arg1)` Redis command getset.
`int`	`hashCode()`
`Maybe<Response>`	`hdel(List<String> args)` Redis command hdel.
`Maybe<Response>`	`hello(List<String> args)` Redis command hello.
`Maybe<Response>`	`hexists(String arg0, String arg1)` Redis command hexists.
`Maybe<Response>`	`hget(String arg0, String arg1)` Redis command hget.
`Maybe<Response>`	`hgetall(String arg0)` Redis command hgetall.
`Maybe<Response>`	`hincrby(String arg0, String arg1, String arg2)` Redis command hincrby.
`Maybe<Response>`	`hincrbyfloat(String arg0, String arg1, String arg2)` Redis command hincrbyfloat.
`Maybe<Response>`	`hkeys(String arg0)` Redis command hkeys.
`Maybe<Response>`	`hlen(String arg0)` Redis command hlen.
`Maybe<Response>`	`hmget(List<String> args)` Redis command hmget.
`Maybe<Response>`	`hmset(List<String> args)` Redis command hmset.
`Maybe<Response>`	`host(List<String> args)` Redis command host.
`Maybe<Response>`	`hscan(List<String> args)` Redis command hscan.
`Maybe<Response>`	`hset(List<String> args)` Redis command hset.
`Maybe<Response>`	`hsetnx(String arg0, String arg1, String arg2)` Redis command hsetnx.
`Maybe<Response>`	`hstrlen(String arg0, String arg1)` Redis command hstrlen.
`Maybe<Response>`	`hvals(String arg0)` Redis command hvals.
`Maybe<Response>`	`incr(String arg0)` Redis command incr.
`Maybe<Response>`	`incrby(String arg0, String arg1)` Redis command incrby.
`Maybe<Response>`	`incrbyfloat(String arg0, String arg1)` Redis command incrbyfloat.
`Maybe<Response>`	`info(List<String> args)` Redis command info.
`Maybe<Response>`	`keys(String arg0)` Redis command keys.
`Maybe<Response>`	`lastsave()` Redis command lastsave.
`Maybe<Response>`	`latency(List<String> args)` Redis command latency.
`Maybe<Response>`	`lindex(String arg0, String arg1)` Redis command lindex.
`Maybe<Response>`	`linsert(String arg0, String arg1, String arg2, String arg3)` Redis command linsert.
`Maybe<Response>`	`llen(String arg0)` Redis command llen.
`Maybe<Response>`	`lolwut(List<String> args)` Redis command lolwut.
`Maybe<Response>`	`lpop(String arg0)` Redis command lpop.
`Maybe<Response>`	`lpush(List<String> args)` Redis command lpush.
`Maybe<Response>`	`lpushx(List<String> args)` Redis command lpushx.
`Maybe<Response>`	`lrange(String arg0, String arg1, String arg2)` Redis command lrange.
`Maybe<Response>`	`lrem(String arg0, String arg1, String arg2)` Redis command lrem.
`Maybe<Response>`	`lset(String arg0, String arg1, String arg2)` Redis command lset.
`Maybe<Response>`	`ltrim(String arg0, String arg1, String arg2)` Redis command ltrim.
`Maybe<Response>`	`memory(List<String> args)` Redis command memory.
`Maybe<Response>`	`mget(List<String> args)` Redis command mget.
`Maybe<Response>`	`migrate(List<String> args)` Redis command migrate.
`Maybe<Response>`	`module(List<String> args)` Redis command module.
`Maybe<Response>`	`monitor()` Redis command monitor.
`Maybe<Response>`	`move(String arg0, String arg1)` Redis command move.
`Maybe<Response>`	`mset(List<String> args)` Redis command mset.
`Maybe<Response>`	`msetnx(List<String> args)` Redis command msetnx.
`Maybe<Response>`	`multi()` Redis command multi.
`static RedisAPI`	`newInstance(RedisAPI arg)`
`Maybe<Response>`	`object(List<String> args)` Redis command object.
`Maybe<Response>`	`persist(String arg0)` Redis command persist.
`Maybe<Response>`	`pexpire(String arg0, String arg1)` Redis command pexpire.
`Maybe<Response>`	`pexpireat(String arg0, String arg1)` Redis command pexpireat.
`Maybe<Response>`	`pfadd(List<String> args)` Redis command pfadd.
`Maybe<Response>`	`pfcount(List<String> args)` Redis command pfcount.
`Maybe<Response>`	`pfdebug(List<String> args)` Redis command pfdebug.
`Maybe<Response>`	`pfmerge(List<String> args)` Redis command pfmerge.
`Maybe<Response>`	`pfselftest()` Redis command pfselftest.
`Maybe<Response>`	`ping(List<String> args)` Redis command ping.
`Maybe<Response>`	`post(List<String> args)` Redis command post.
`Maybe<Response>`	`psetex(String arg0, String arg1, String arg2)` Redis command psetex.
`Maybe<Response>`	`psubscribe(List<String> args)` Redis command psubscribe.
`Maybe<Response>`	`psync(String arg0, String arg1)` Redis command psync.
`Maybe<Response>`	`pttl(String arg0)` Redis command pttl.
`Maybe<Response>`	`publish(String arg0, String arg1)` Redis command publish.
`Maybe<Response>`	`pubsub(List<String> args)` Redis command pubsub.
`Maybe<Response>`	`punsubscribe(List<String> args)` Redis command punsubscribe.
`Maybe<Response>`	`randomkey()` Redis command randomkey.
`Maybe<Response>`	`readonly()` Redis command readonly.
`Maybe<Response>`	`readwrite()` Redis command readwrite.
`Maybe<Response>`	`rename(String arg0, String arg1)` Redis command rename.
`Maybe<Response>`	`renamenx(String arg0, String arg1)` Redis command renamenx.
`Maybe<Response>`	`replconf(List<String> args)` Redis command replconf.
`Maybe<Response>`	`replicaof(String arg0, String arg1)` Redis command replicaof.
`Maybe<Response>`	`restore(List<String> args)` Redis command restore.
`Maybe<Response>`	`restoreAsking(List<String> args)` Redis command restoreAsking.
`Maybe<Response>`	`role()` Redis command role.
`Maybe<Response>`	`rpop(String arg0)` Redis command rpop.
`Maybe<Response>`	`rpoplpush(String arg0, String arg1)` Redis command rpoplpush.
`Maybe<Response>`	`rpush(List<String> args)` Redis command rpush.
`Maybe<Response>`	`rpushx(List<String> args)` Redis command rpushx.
`Maybe<Response>`	`rxAcl(List<String> args)` Redis command acl.
`Maybe<Response>`	`rxAppend(String arg0, String arg1)` Redis command append.
`Maybe<Response>`	`rxAsking()` Redis command asking.
`Maybe<Response>`	`rxAuth(List<String> args)` Redis command auth.
`Maybe<Response>`	`rxBgrewriteaof()` Redis command bgrewriteaof.
`Maybe<Response>`	`rxBgsave(List<String> args)` Redis command bgsave.
`Maybe<Response>`	`rxBitcount(List<String> args)` Redis command bitcount.
`Maybe<Response>`	`rxBitfield(List<String> args)` Redis command bitfield.
`Maybe<Response>`	`rxBitfieldRo(List<String> args)` Redis command bitfieldRo.
`Maybe<Response>`	`rxBitop(List<String> args)` Redis command bitop.
`Maybe<Response>`	`rxBitpos(List<String> args)` Redis command bitpos.
`Maybe<Response>`	`rxBlpop(List<String> args)` Redis command blpop.
`Maybe<Response>`	`rxBrpop(List<String> args)` Redis command brpop.
`Maybe<Response>`	`rxBrpoplpush(String arg0, String arg1, String arg2)` Redis command brpoplpush.
`Maybe<Response>`	`rxBzpopmax(List<String> args)` Redis command bzpopmax.
`Maybe<Response>`	`rxBzpopmin(List<String> args)` Redis command bzpopmin.
`Maybe<Response>`	`rxClient(List<String> args)` Redis command client.
`Maybe<Response>`	`rxCluster(List<String> args)` Redis command cluster.
`Maybe<Response>`	`rxCommand(List<String> args)` Redis command command.
`Maybe<Response>`	`rxConfig(List<String> args)` Redis command config.
`Maybe<Response>`	`rxDbsize()` Redis command dbsize.
`Maybe<Response>`	`rxDebug(List<String> args)` Redis command debug.
`Maybe<Response>`	`rxDecr(String arg0)` Redis command decr.
`Maybe<Response>`	`rxDecrby(String arg0, String arg1)` Redis command decrby.
`Maybe<Response>`	`rxDel(List<String> args)` Redis command del.
`Maybe<Response>`	`rxDiscard()` Redis command discard.
`Maybe<Response>`	`rxDump(String arg0)` Redis command dump.
`Maybe<Response>`	`rxEcho(String arg0)` Redis command echo.
`Maybe<Response>`	`rxEval(List<String> args)` Redis command eval.
`Maybe<Response>`	`rxEvalsha(List<String> args)` Redis command evalsha.
`Maybe<Response>`	`rxExec()` Redis command exec.
`Maybe<Response>`	`rxExists(List<String> args)` Redis command exists.
`Maybe<Response>`	`rxExpire(String arg0, String arg1)` Redis command expire.
`Maybe<Response>`	`rxExpireat(String arg0, String arg1)` Redis command expireat.
`Maybe<Response>`	`rxFlushall(List<String> args)` Redis command flushall.
`Maybe<Response>`	`rxFlushdb(List<String> args)` Redis command flushdb.
`Maybe<Response>`	`rxGeoadd(List<String> args)` Redis command geoadd.
`Maybe<Response>`	`rxGeodist(List<String> args)` Redis command geodist.
`Maybe<Response>`	`rxGeohash(List<String> args)` Redis command geohash.
`Maybe<Response>`	`rxGeopos(List<String> args)` Redis command geopos.
`Maybe<Response>`	`rxGeoradius(List<String> args)` Redis command georadius.
`Maybe<Response>`	`rxGeoradiusbymember(List<String> args)` Redis command georadiusbymember.
`Maybe<Response>`	`rxGeoradiusbymemberRo(List<String> args)` Redis command georadiusbymemberRo.
`Maybe<Response>`	`rxGeoradiusRo(List<String> args)` Redis command georadiusRo.
`Maybe<Response>`	`rxGet(String arg0)` Redis command get.
`Maybe<Response>`	`rxGetbit(String arg0, String arg1)` Redis command getbit.
`Maybe<Response>`	`rxGetrange(String arg0, String arg1, String arg2)` Redis command getrange.
`Maybe<Response>`	`rxGetset(String arg0, String arg1)` Redis command getset.
`Maybe<Response>`	`rxHdel(List<String> args)` Redis command hdel.
`Maybe<Response>`	`rxHello(List<String> args)` Redis command hello.
`Maybe<Response>`	`rxHexists(String arg0, String arg1)` Redis command hexists.
`Maybe<Response>`	`rxHget(String arg0, String arg1)` Redis command hget.
`Maybe<Response>`	`rxHgetall(String arg0)` Redis command hgetall.
`Maybe<Response>`	`rxHincrby(String arg0, String arg1, String arg2)` Redis command hincrby.
`Maybe<Response>`	`rxHincrbyfloat(String arg0, String arg1, String arg2)` Redis command hincrbyfloat.
`Maybe<Response>`	`rxHkeys(String arg0)` Redis command hkeys.
`Maybe<Response>`	`rxHlen(String arg0)` Redis command hlen.
`Maybe<Response>`	`rxHmget(List<String> args)` Redis command hmget.
`Maybe<Response>`	`rxHmset(List<String> args)` Redis command hmset.
`Maybe<Response>`	`rxHost(List<String> args)` Redis command host.
`Maybe<Response>`	`rxHscan(List<String> args)` Redis command hscan.
`Maybe<Response>`	`rxHset(List<String> args)` Redis command hset.
`Maybe<Response>`	`rxHsetnx(String arg0, String arg1, String arg2)` Redis command hsetnx.
`Maybe<Response>`	`rxHstrlen(String arg0, String arg1)` Redis command hstrlen.
`Maybe<Response>`	`rxHvals(String arg0)` Redis command hvals.
`Maybe<Response>`	`rxIncr(String arg0)` Redis command incr.
`Maybe<Response>`	`rxIncrby(String arg0, String arg1)` Redis command incrby.
`Maybe<Response>`	`rxIncrbyfloat(String arg0, String arg1)` Redis command incrbyfloat.
`Maybe<Response>`	`rxInfo(List<String> args)` Redis command info.
`Maybe<Response>`	`rxKeys(String arg0)` Redis command keys.
`Maybe<Response>`	`rxLastsave()` Redis command lastsave.
`Maybe<Response>`	`rxLatency(List<String> args)` Redis command latency.
`Maybe<Response>`	`rxLindex(String arg0, String arg1)` Redis command lindex.
`Maybe<Response>`	`rxLinsert(String arg0, String arg1, String arg2, String arg3)` Redis command linsert.
`Maybe<Response>`	`rxLlen(String arg0)` Redis command llen.
`Maybe<Response>`	`rxLolwut(List<String> args)` Redis command lolwut.
`Maybe<Response>`	`rxLpop(String arg0)` Redis command lpop.
`Maybe<Response>`	`rxLpush(List<String> args)` Redis command lpush.
`Maybe<Response>`	`rxLpushx(List<String> args)` Redis command lpushx.
`Maybe<Response>`	`rxLrange(String arg0, String arg1, String arg2)` Redis command lrange.
`Maybe<Response>`	`rxLrem(String arg0, String arg1, String arg2)` Redis command lrem.
`Maybe<Response>`	`rxLset(String arg0, String arg1, String arg2)` Redis command lset.
`Maybe<Response>`	`rxLtrim(String arg0, String arg1, String arg2)` Redis command ltrim.
`Maybe<Response>`	`rxMemory(List<String> args)` Redis command memory.
`Maybe<Response>`	`rxMget(List<String> args)` Redis command mget.
`Maybe<Response>`	`rxMigrate(List<String> args)` Redis command migrate.
`Maybe<Response>`	`rxModule(List<String> args)` Redis command module.
`Maybe<Response>`	`rxMonitor()` Redis command monitor.
`Maybe<Response>`	`rxMove(String arg0, String arg1)` Redis command move.
`Maybe<Response>`	`rxMset(List<String> args)` Redis command mset.
`Maybe<Response>`	`rxMsetnx(List<String> args)` Redis command msetnx.
`Maybe<Response>`	`rxMulti()` Redis command multi.
`Maybe<Response>`	`rxObject(List<String> args)` Redis command object.
`Maybe<Response>`	`rxPersist(String arg0)` Redis command persist.
`Maybe<Response>`	`rxPexpire(String arg0, String arg1)` Redis command pexpire.
`Maybe<Response>`	`rxPexpireat(String arg0, String arg1)` Redis command pexpireat.
`Maybe<Response>`	`rxPfadd(List<String> args)` Redis command pfadd.
`Maybe<Response>`	`rxPfcount(List<String> args)` Redis command pfcount.
`Maybe<Response>`	`rxPfdebug(List<String> args)` Redis command pfdebug.
`Maybe<Response>`	`rxPfmerge(List<String> args)` Redis command pfmerge.
`Maybe<Response>`	`rxPfselftest()` Redis command pfselftest.
`Maybe<Response>`	`rxPing(List<String> args)` Redis command ping.
`Maybe<Response>`	`rxPost(List<String> args)` Redis command post.
`Maybe<Response>`	`rxPsetex(String arg0, String arg1, String arg2)` Redis command psetex.
`Maybe<Response>`	`rxPsubscribe(List<String> args)` Redis command psubscribe.
`Maybe<Response>`	`rxPsync(String arg0, String arg1)` Redis command psync.
`Maybe<Response>`	`rxPttl(String arg0)` Redis command pttl.
`Maybe<Response>`	`rxPublish(String arg0, String arg1)` Redis command publish.
`Maybe<Response>`	`rxPubsub(List<String> args)` Redis command pubsub.
`Maybe<Response>`	`rxPunsubscribe(List<String> args)` Redis command punsubscribe.
`Maybe<Response>`	`rxRandomkey()` Redis command randomkey.
`Maybe<Response>`	`rxReadonly()` Redis command readonly.
`Maybe<Response>`	`rxReadwrite()` Redis command readwrite.
`Maybe<Response>`	`rxRename(String arg0, String arg1)` Redis command rename.
`Maybe<Response>`	`rxRenamenx(String arg0, String arg1)` Redis command renamenx.
`Maybe<Response>`	`rxReplconf(List<String> args)` Redis command replconf.
`Maybe<Response>`	`rxReplicaof(String arg0, String arg1)` Redis command replicaof.
`Maybe<Response>`	`rxRestore(List<String> args)` Redis command restore.
`Maybe<Response>`	`rxRestoreAsking(List<String> args)` Redis command restoreAsking.
`Maybe<Response>`	`rxRole()` Redis command role.
`Maybe<Response>`	`rxRpop(String arg0)` Redis command rpop.
`Maybe<Response>`	`rxRpoplpush(String arg0, String arg1)` Redis command rpoplpush.
`Maybe<Response>`	`rxRpush(List<String> args)` Redis command rpush.
`Maybe<Response>`	`rxRpushx(List<String> args)` Redis command rpushx.
`Maybe<Response>`	`rxSadd(List<String> args)` Redis command sadd.
`Maybe<Response>`	`rxSave()` Redis command save.
`Maybe<Response>`	`rxScan(List<String> args)` Redis command scan.
`Maybe<Response>`	`rxScard(String arg0)` Redis command scard.
`Maybe<Response>`	`rxScript(List<String> args)` Redis command script.
`Maybe<Response>`	`rxSdiff(List<String> args)` Redis command sdiff.
`Maybe<Response>`	`rxSdiffstore(List<String> args)` Redis command sdiffstore.
`Maybe<Response>`	`rxSelect(String arg0)` Redis command select.
`Maybe<Response>`	`rxSet(List<String> args)` Redis command set.
`Maybe<Response>`	`rxSetbit(String arg0, String arg1, String arg2)` Redis command setbit.
`Maybe<Response>`	`rxSetex(String arg0, String arg1, String arg2)` Redis command setex.
`Maybe<Response>`	`rxSetnx(String arg0, String arg1)` Redis command setnx.
`Maybe<Response>`	`rxSetrange(String arg0, String arg1, String arg2)` Redis command setrange.
`Maybe<Response>`	`rxShutdown(List<String> args)` Redis command shutdown.
`Maybe<Response>`	`rxSinter(List<String> args)` Redis command sinter.
`Maybe<Response>`	`rxSinterstore(List<String> args)` Redis command sinterstore.
`Maybe<Response>`	`rxSismember(String arg0, String arg1)` Redis command sismember.
`Maybe<Response>`	`rxSlaveof(String arg0, String arg1)` Redis command slaveof.
`Maybe<Response>`	`rxSlowlog(List<String> args)` Redis command slowlog.
`Maybe<Response>`	`rxSmembers(String arg0)` Redis command smembers.
`Maybe<Response>`	`rxSmove(String arg0, String arg1, String arg2)` Redis command smove.
`Maybe<Response>`	`rxSort(List<String> args)` Redis command sort.
`Maybe<Response>`	`rxSpop(List<String> args)` Redis command spop.
`Maybe<Response>`	`rxSrandmember(List<String> args)` Redis command srandmember.
`Maybe<Response>`	`rxSrem(List<String> args)` Redis command srem.
`Maybe<Response>`	`rxSscan(List<String> args)` Redis command sscan.
`Maybe<Response>`	`rxStralgo(List<String> args)` Redis command stralgo.
`Maybe<Response>`	`rxStrlen(String arg0)` Redis command strlen.
`Maybe<Response>`	`rxSubscribe(List<String> args)` Redis command subscribe.
`Maybe<Response>`	`rxSubstr(String arg0, String arg1, String arg2)` Redis command substr.
`Maybe<Response>`	`rxSunion(List<String> args)` Redis command sunion.
`Maybe<Response>`	`rxSunionstore(List<String> args)` Redis command sunionstore.
`Maybe<Response>`	`rxSwapdb(String arg0, String arg1)` Redis command swapdb.
`Maybe<Response>`	`rxSync()` Redis command sync.
`Maybe<Response>`	`rxTime()` Redis command time.
`Maybe<Response>`	`rxTouch(List<String> args)` Redis command touch.
`Maybe<Response>`	`rxTtl(String arg0)` Redis command ttl.
`Maybe<Response>`	`rxType(String arg0)` Redis command type.
`Maybe<Response>`	`rxUnlink(List<String> args)` Redis command unlink.
`Maybe<Response>`	`rxUnsubscribe(List<String> args)` Redis command unsubscribe.
`Maybe<Response>`	`rxUnwatch()` Redis command unwatch.
`Maybe<Response>`	`rxWait(String arg0, String arg1)` Redis command wait.
`Maybe<Response>`	`rxWatch(List<String> args)` Redis command watch.
`Maybe<Response>`	`rxXack(List<String> args)` Redis command xack.
`Maybe<Response>`	`rxXadd(List<String> args)` Redis command xadd.
`Maybe<Response>`	`rxXclaim(List<String> args)` Redis command xclaim.
`Maybe<Response>`	`rxXdel(List<String> args)` Redis command xdel.
`Maybe<Response>`	`rxXgroup(List<String> args)` Redis command xgroup.
`Maybe<Response>`	`rxXinfo(List<String> args)` Redis command xinfo.
`Maybe<Response>`	`rxXlen(String arg0)` Redis command xlen.
`Maybe<Response>`	`rxXpending(List<String> args)` Redis command xpending.
`Maybe<Response>`	`rxXrange(List<String> args)` Redis command xrange.
`Maybe<Response>`	`rxXread(List<String> args)` Redis command xread.
`Maybe<Response>`	`rxXreadgroup(List<String> args)` Redis command xreadgroup.
`Maybe<Response>`	`rxXrevrange(List<String> args)` Redis command xrevrange.
`Maybe<Response>`	`rxXsetid(String arg0, String arg1)` Redis command xsetid.
`Maybe<Response>`	`rxXtrim(List<String> args)` Redis command xtrim.
`Maybe<Response>`	`rxZadd(List<String> args)` Redis command zadd.
`Maybe<Response>`	`rxZcard(String arg0)` Redis command zcard.
`Maybe<Response>`	`rxZcount(String arg0, String arg1, String arg2)` Redis command zcount.
`Maybe<Response>`	`rxZincrby(String arg0, String arg1, String arg2)` Redis command zincrby.
`Maybe<Response>`	`rxZinterstore(List<String> args)` Redis command zinterstore.
`Maybe<Response>`	`rxZlexcount(String arg0, String arg1, String arg2)` Redis command zlexcount.
`Maybe<Response>`	`rxZpopmax(List<String> args)` Redis command zpopmax.
`Maybe<Response>`	`rxZpopmin(List<String> args)` Redis command zpopmin.
`Maybe<Response>`	`rxZrange(List<String> args)` Redis command zrange.
`Maybe<Response>`	`rxZrangebylex(List<String> args)` Redis command zrangebylex.
`Maybe<Response>`	`rxZrangebyscore(List<String> args)` Redis command zrangebyscore.
`Maybe<Response>`	`rxZrank(String arg0, String arg1)` Redis command zrank.
`Maybe<Response>`	`rxZrem(List<String> args)` Redis command zrem.
`Maybe<Response>`	`rxZremrangebylex(String arg0, String arg1, String arg2)` Redis command zremrangebylex.
`Maybe<Response>`	`rxZremrangebyrank(String arg0, String arg1, String arg2)` Redis command zremrangebyrank.
`Maybe<Response>`	`rxZremrangebyscore(String arg0, String arg1, String arg2)` Redis command zremrangebyscore.
`Maybe<Response>`	`rxZrevrange(List<String> args)` Redis command zrevrange.
`Maybe<Response>`	`rxZrevrangebylex(List<String> args)` Redis command zrevrangebylex.
`Maybe<Response>`	`rxZrevrangebyscore(List<String> args)` Redis command zrevrangebyscore.
`Maybe<Response>`	`rxZrevrank(String arg0, String arg1)` Redis command zrevrank.
`Maybe<Response>`	`rxZscan(List<String> args)` Redis command zscan.
`Maybe<Response>`	`rxZscore(String arg0, String arg1)` Redis command zscore.
`Maybe<Response>`	`rxZunionstore(List<String> args)` Redis command zunionstore.
`Maybe<Response>`	`sadd(List<String> args)` Redis command sadd.
`Maybe<Response>`	`save()` Redis command save.
`Maybe<Response>`	`scan(List<String> args)` Redis command scan.
`Maybe<Response>`	`scard(String arg0)` Redis command scard.
`Maybe<Response>`	`script(List<String> args)` Redis command script.
`Maybe<Response>`	`sdiff(List<String> args)` Redis command sdiff.
`Maybe<Response>`	`sdiffstore(List<String> args)` Redis command sdiffstore.
`Maybe<Response>`	`select(String arg0)` Redis command select.
`Maybe<Response>`	`set(List<String> args)` Redis command set.
`Maybe<Response>`	`setbit(String arg0, String arg1, String arg2)` Redis command setbit.
`Maybe<Response>`	`setex(String arg0, String arg1, String arg2)` Redis command setex.
`Maybe<Response>`	`setnx(String arg0, String arg1)` Redis command setnx.
`Maybe<Response>`	`setrange(String arg0, String arg1, String arg2)` Redis command setrange.
`Maybe<Response>`	`shutdown(List<String> args)` Redis command shutdown.
`Maybe<Response>`	`sinter(List<String> args)` Redis command sinter.
`Maybe<Response>`	`sinterstore(List<String> args)` Redis command sinterstore.
`Maybe<Response>`	`sismember(String arg0, String arg1)` Redis command sismember.
`Maybe<Response>`	`slaveof(String arg0, String arg1)` Redis command slaveof.
`Maybe<Response>`	`slowlog(List<String> args)` Redis command slowlog.
`Maybe<Response>`	`smembers(String arg0)` Redis command smembers.
`Maybe<Response>`	`smove(String arg0, String arg1, String arg2)` Redis command smove.
`Maybe<Response>`	`sort(List<String> args)` Redis command sort.
`Maybe<Response>`	`spop(List<String> args)` Redis command spop.
`Maybe<Response>`	`srandmember(List<String> args)` Redis command srandmember.
`Maybe<Response>`	`srem(List<String> args)` Redis command srem.
`Maybe<Response>`	`sscan(List<String> args)` Redis command sscan.
`Maybe<Response>`	`stralgo(List<String> args)` Redis command stralgo.
`Maybe<Response>`	`strlen(String arg0)` Redis command strlen.
`Maybe<Response>`	`subscribe(List<String> args)` Redis command subscribe.
`Maybe<Response>`	`substr(String arg0, String arg1, String arg2)` Redis command substr.
`Maybe<Response>`	`sunion(List<String> args)` Redis command sunion.
`Maybe<Response>`	`sunionstore(List<String> args)` Redis command sunionstore.
`Maybe<Response>`	`swapdb(String arg0, String arg1)` Redis command swapdb.
`Maybe<Response>`	`sync()` Redis command sync.
`Maybe<Response>`	`time()` Redis command time.
`String`	`toString()`
`Maybe<Response>`	`touch(List<String> args)` Redis command touch.
`Maybe<Response>`	`ttl(String arg0)` Redis command ttl.
`Maybe<Response>`	`type(String arg0)` Redis command type.
`Maybe<Response>`	`unlink(List<String> args)` Redis command unlink.
`Maybe<Response>`	`unsubscribe(List<String> args)` Redis command unsubscribe.
`Maybe<Response>`	`unwatch()` Redis command unwatch.
`Maybe<Response>`	`wait(String arg0, String arg1)` Redis command wait.
`Maybe<Response>`	`watch(List<String> args)` Redis command watch.
`Maybe<Response>`	`xack(List<String> args)` Redis command xack.
`Maybe<Response>`	`xadd(List<String> args)` Redis command xadd.
`Maybe<Response>`	`xclaim(List<String> args)` Redis command xclaim.
`Maybe<Response>`	`xdel(List<String> args)` Redis command xdel.
`Maybe<Response>`	`xgroup(List<String> args)` Redis command xgroup.
`Maybe<Response>`	`xinfo(List<String> args)` Redis command xinfo.
`Maybe<Response>`	`xlen(String arg0)` Redis command xlen.
`Maybe<Response>`	`xpending(List<String> args)` Redis command xpending.
`Maybe<Response>`	`xrange(List<String> args)` Redis command xrange.
`Maybe<Response>`	`xread(List<String> args)` Redis command xread.
`Maybe<Response>`	`xreadgroup(List<String> args)` Redis command xreadgroup.
`Maybe<Response>`	`xrevrange(List<String> args)` Redis command xrevrange.
`Maybe<Response>`	`xsetid(String arg0, String arg1)` Redis command xsetid.
`Maybe<Response>`	`xtrim(List<String> args)` Redis command xtrim.
`Maybe<Response>`	`zadd(List<String> args)` Redis command zadd.
`Maybe<Response>`	`zcard(String arg0)` Redis command zcard.
`Maybe<Response>`	`zcount(String arg0, String arg1, String arg2)` Redis command zcount.
`Maybe<Response>`	`zincrby(String arg0, String arg1, String arg2)` Redis command zincrby.
`Maybe<Response>`	`zinterstore(List<String> args)` Redis command zinterstore.
`Maybe<Response>`	`zlexcount(String arg0, String arg1, String arg2)` Redis command zlexcount.
`Maybe<Response>`	`zpopmax(List<String> args)` Redis command zpopmax.
`Maybe<Response>`	`zpopmin(List<String> args)` Redis command zpopmin.
`Maybe<Response>`	`zrange(List<String> args)` Redis command zrange.
`Maybe<Response>`	`zrangebylex(List<String> args)` Redis command zrangebylex.
`Maybe<Response>`	`zrangebyscore(List<String> args)` Redis command zrangebyscore.
`Maybe<Response>`	`zrank(String arg0, String arg1)` Redis command zrank.
`Maybe<Response>`	`zrem(List<String> args)` Redis command zrem.
`Maybe<Response>`	`zremrangebylex(String arg0, String arg1, String arg2)` Redis command zremrangebylex.
`Maybe<Response>`	`zremrangebyrank(String arg0, String arg1, String arg2)` Redis command zremrangebyrank.
`Maybe<Response>`	`zremrangebyscore(String arg0, String arg1, String arg2)` Redis command zremrangebyscore.
`Maybe<Response>`	`zrevrange(List<String> args)` Redis command zrevrange.
`Maybe<Response>`	`zrevrangebylex(List<String> args)` Redis command zrevrangebylex.
`Maybe<Response>`	`zrevrangebyscore(List<String> args)` Redis command zrevrangebyscore.
`Maybe<Response>`	`zrevrank(String arg0, String arg1)` Redis command zrevrank.
`Maybe<Response>`	`zscan(List<String> args)` Redis command zscan.
`Maybe<Response>`	`zscore(String arg0, String arg1)` Redis command zscore.
`Maybe<Response>`	`zunionstore(List<String> args)` Redis command zunionstore.

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()
```

acl
```
public Maybe<Response> acl(List<String> args)
```
Redis command acl.

Parameters:

args -

Returns:

fluent self

rxAcl
```
public Maybe<Response> rxAcl(List<String> args)
```
Redis command acl.

Parameters:

args -

Returns:

fluent self

append

public Maybe<Response> append(String arg0,
                              String arg1)

Redis command append.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxAppend

public Maybe<Response> rxAppend(String arg0,
                                String arg1)

Redis command append.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

asking
```
public Maybe<Response> asking()
```
Redis command asking.

Returns:

fluent self

rxAsking
```
public Maybe<Response> rxAsking()
```
Redis command asking.

Returns:

fluent self

auth
```
public Maybe<Response> auth(List<String> args)
```
Redis command auth.

Parameters:

args -

Returns:

fluent self

rxAuth
```
public Maybe<Response> rxAuth(List<String> args)
```
Redis command auth.

Parameters:

args -

Returns:

fluent self

bgrewriteaof
```
public Maybe<Response> bgrewriteaof()
```
Redis command bgrewriteaof.

Returns:

fluent self

rxBgrewriteaof
```
public Maybe<Response> rxBgrewriteaof()
```
Redis command bgrewriteaof.

Returns:

fluent self

bgsave
```
public Maybe<Response> bgsave(List<String> args)
```
Redis command bgsave.

Parameters:

args -

Returns:

fluent self

rxBgsave
```
public Maybe<Response> rxBgsave(List<String> args)
```
Redis command bgsave.

Parameters:

args -

Returns:

fluent self

bitcount
```
public Maybe<Response> bitcount(List<String> args)
```
Redis command bitcount.

Parameters:

args -

Returns:

fluent self

rxBitcount
```
public Maybe<Response> rxBitcount(List<String> args)
```
Redis command bitcount.

Parameters:

args -

Returns:

fluent self

bitfield
```
public Maybe<Response> bitfield(List<String> args)
```
Redis command bitfield.

Parameters:

args -

Returns:

fluent self

rxBitfield
```
public Maybe<Response> rxBitfield(List<String> args)
```
Redis command bitfield.

Parameters:

args -

Returns:

fluent self

bitfieldRo
```
public Maybe<Response> bitfieldRo(List<String> args)
```
Redis command bitfieldRo.

Parameters:

args -

Returns:

fluent self

rxBitfieldRo
```
public Maybe<Response> rxBitfieldRo(List<String> args)
```
Redis command bitfieldRo.

Parameters:

args -

Returns:

fluent self

bitop
```
public Maybe<Response> bitop(List<String> args)
```
Redis command bitop.

Parameters:

args -

Returns:

fluent self

rxBitop
```
public Maybe<Response> rxBitop(List<String> args)
```
Redis command bitop.

Parameters:

args -

Returns:

fluent self

bitpos
```
public Maybe<Response> bitpos(List<String> args)
```
Redis command bitpos.

Parameters:

args -

Returns:

fluent self

rxBitpos
```
public Maybe<Response> rxBitpos(List<String> args)
```
Redis command bitpos.

Parameters:

args -

Returns:

fluent self

blpop
```
public Maybe<Response> blpop(List<String> args)
```
Redis command blpop.

Parameters:

args -

Returns:

fluent self

rxBlpop
```
public Maybe<Response> rxBlpop(List<String> args)
```
Redis command blpop.

Parameters:

args -

Returns:

fluent self

brpop
```
public Maybe<Response> brpop(List<String> args)
```
Redis command brpop.

Parameters:

args -

Returns:

fluent self

rxBrpop
```
public Maybe<Response> rxBrpop(List<String> args)
```
Redis command brpop.

Parameters:

args -

Returns:

fluent self

brpoplpush

public Maybe<Response> brpoplpush(String arg0,
                                  String arg1,
                                  String arg2)

Redis command brpoplpush.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxBrpoplpush

public Maybe<Response> rxBrpoplpush(String arg0,
                                    String arg1,
                                    String arg2)

Redis command brpoplpush.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

bzpopmax
```
public Maybe<Response> bzpopmax(List<String> args)
```
Redis command bzpopmax.

Parameters:

args -

Returns:

fluent self

rxBzpopmax
```
public Maybe<Response> rxBzpopmax(List<String> args)
```
Redis command bzpopmax.

Parameters:

args -

Returns:

fluent self

bzpopmin
```
public Maybe<Response> bzpopmin(List<String> args)
```
Redis command bzpopmin.

Parameters:

args -

Returns:

fluent self

rxBzpopmin
```
public Maybe<Response> rxBzpopmin(List<String> args)
```
Redis command bzpopmin.

Parameters:

args -

Returns:

fluent self

client
```
public Maybe<Response> client(List<String> args)
```
Redis command client.

Parameters:

args -

Returns:

fluent self

rxClient
```
public Maybe<Response> rxClient(List<String> args)
```
Redis command client.

Parameters:

args -

Returns:

fluent self

cluster
```
public Maybe<Response> cluster(List<String> args)
```
Redis command cluster.

Parameters:

args -

Returns:

fluent self

rxCluster
```
public Maybe<Response> rxCluster(List<String> args)
```
Redis command cluster.

Parameters:

args -

Returns:

fluent self

command
```
public Maybe<Response> command(List<String> args)
```
Redis command command.

Parameters:

args -

Returns:

fluent self

rxCommand
```
public Maybe<Response> rxCommand(List<String> args)
```
Redis command command.

Parameters:

args -

Returns:

fluent self

config
```
public Maybe<Response> config(List<String> args)
```
Redis command config.

Parameters:

args -

Returns:

fluent self

rxConfig
```
public Maybe<Response> rxConfig(List<String> args)
```
Redis command config.

Parameters:

args -

Returns:

fluent self

dbsize
```
public Maybe<Response> dbsize()
```
Redis command dbsize.

Returns:

fluent self

rxDbsize
```
public Maybe<Response> rxDbsize()
```
Redis command dbsize.

Returns:

fluent self

debug
```
public Maybe<Response> debug(List<String> args)
```
Redis command debug.

Parameters:

args -

Returns:

fluent self

rxDebug
```
public Maybe<Response> rxDebug(List<String> args)
```
Redis command debug.

Parameters:

args -

Returns:

fluent self

decr
```
public Maybe<Response> decr(String arg0)
```
Redis command decr.

Parameters:

arg0 -

Returns:

fluent self

rxDecr
```
public Maybe<Response> rxDecr(String arg0)
```
Redis command decr.

Parameters:

arg0 -

Returns:

fluent self

decrby

public Maybe<Response> decrby(String arg0,
                              String arg1)

Redis command decrby.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxDecrby

public Maybe<Response> rxDecrby(String arg0,
                                String arg1)

Redis command decrby.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

del
```
public Maybe<Response> del(List<String> args)
```
Redis command del.

Parameters:

args -

Returns:

fluent self

rxDel
```
public Maybe<Response> rxDel(List<String> args)
```
Redis command del.

Parameters:

args -

Returns:

fluent self

discard
```
public Maybe<Response> discard()
```
Redis command discard.

Returns:

fluent self

rxDiscard
```
public Maybe<Response> rxDiscard()
```
Redis command discard.

Returns:

fluent self

dump
```
public Maybe<Response> dump(String arg0)
```
Redis command dump.

Parameters:

arg0 -

Returns:

fluent self

rxDump
```
public Maybe<Response> rxDump(String arg0)
```
Redis command dump.

Parameters:

arg0 -

Returns:

fluent self

echo
```
public Maybe<Response> echo(String arg0)
```
Redis command echo.

Parameters:

arg0 -

Returns:

fluent self

rxEcho
```
public Maybe<Response> rxEcho(String arg0)
```
Redis command echo.

Parameters:

arg0 -

Returns:

fluent self

eval
```
public Maybe<Response> eval(List<String> args)
```
Redis command eval.

Parameters:

args -

Returns:

fluent self

rxEval
```
public Maybe<Response> rxEval(List<String> args)
```
Redis command eval.

Parameters:

args -

Returns:

fluent self

evalsha
```
public Maybe<Response> evalsha(List<String> args)
```
Redis command evalsha.

Parameters:

args -

Returns:

fluent self

rxEvalsha
```
public Maybe<Response> rxEvalsha(List<String> args)
```
Redis command evalsha.

Parameters:

args -

Returns:

fluent self

exec
```
public Maybe<Response> exec()
```
Redis command exec.

Returns:

fluent self

rxExec
```
public Maybe<Response> rxExec()
```
Redis command exec.

Returns:

fluent self

exists
```
public Maybe<Response> exists(List<String> args)
```
Redis command exists.

Parameters:

args -

Returns:

fluent self

rxExists
```
public Maybe<Response> rxExists(List<String> args)
```
Redis command exists.

Parameters:

args -

Returns:

fluent self

expire

public Maybe<Response> expire(String arg0,
                              String arg1)

Redis command expire.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxExpire

public Maybe<Response> rxExpire(String arg0,
                                String arg1)

Redis command expire.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

expireat

public Maybe<Response> expireat(String arg0,
                                String arg1)

Redis command expireat.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxExpireat

public Maybe<Response> rxExpireat(String arg0,
                                  String arg1)

Redis command expireat.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

flushall
```
public Maybe<Response> flushall(List<String> args)
```
Redis command flushall.

Parameters:

args -

Returns:

fluent self

rxFlushall
```
public Maybe<Response> rxFlushall(List<String> args)
```
Redis command flushall.

Parameters:

args -

Returns:

fluent self

flushdb
```
public Maybe<Response> flushdb(List<String> args)
```
Redis command flushdb.

Parameters:

args -

Returns:

fluent self

rxFlushdb
```
public Maybe<Response> rxFlushdb(List<String> args)
```
Redis command flushdb.

Parameters:

args -

Returns:

fluent self

geoadd
```
public Maybe<Response> geoadd(List<String> args)
```
Redis command geoadd.

Parameters:

args -

Returns:

fluent self

rxGeoadd
```
public Maybe<Response> rxGeoadd(List<String> args)
```
Redis command geoadd.

Parameters:

args -

Returns:

fluent self

geodist
```
public Maybe<Response> geodist(List<String> args)
```
Redis command geodist.

Parameters:

args -

Returns:

fluent self

rxGeodist
```
public Maybe<Response> rxGeodist(List<String> args)
```
Redis command geodist.

Parameters:

args -

Returns:

fluent self

geohash
```
public Maybe<Response> geohash(List<String> args)
```
Redis command geohash.

Parameters:

args -

Returns:

fluent self

rxGeohash
```
public Maybe<Response> rxGeohash(List<String> args)
```
Redis command geohash.

Parameters:

args -

Returns:

fluent self

geopos
```
public Maybe<Response> geopos(List<String> args)
```
Redis command geopos.

Parameters:

args -

Returns:

fluent self

rxGeopos
```
public Maybe<Response> rxGeopos(List<String> args)
```
Redis command geopos.

Parameters:

args -

Returns:

fluent self

georadius
```
public Maybe<Response> georadius(List<String> args)
```
Redis command georadius.

Parameters:

args -

Returns:

fluent self

rxGeoradius
```
public Maybe<Response> rxGeoradius(List<String> args)
```
Redis command georadius.

Parameters:

args -

Returns:

fluent self

georadiusRo
```
public Maybe<Response> georadiusRo(List<String> args)
```
Redis command georadiusRo.

Parameters:

args -

Returns:

fluent self

rxGeoradiusRo
```
public Maybe<Response> rxGeoradiusRo(List<String> args)
```
Redis command georadiusRo.

Parameters:

args -

Returns:

fluent self

georadiusbymember
```
public Maybe<Response> georadiusbymember(List<String> args)
```
Redis command georadiusbymember.

Parameters:

args -

Returns:

fluent self

rxGeoradiusbymember
```
public Maybe<Response> rxGeoradiusbymember(List<String> args)
```
Redis command georadiusbymember.

Parameters:

args -

Returns:

fluent self

georadiusbymemberRo
```
public Maybe<Response> georadiusbymemberRo(List<String> args)
```
Redis command georadiusbymemberRo.

Parameters:

args -

Returns:

fluent self

rxGeoradiusbymemberRo
```
public Maybe<Response> rxGeoradiusbymemberRo(List<String> args)
```
Redis command georadiusbymemberRo.

Parameters:

args -

Returns:

fluent self

get
```
public Maybe<Response> get(String arg0)
```
Redis command get.

Parameters:

arg0 -

Returns:

fluent self

rxGet
```
public Maybe<Response> rxGet(String arg0)
```
Redis command get.

Parameters:

arg0 -

Returns:

fluent self

getbit

public Maybe<Response> getbit(String arg0,
                              String arg1)

Redis command getbit.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxGetbit

public Maybe<Response> rxGetbit(String arg0,
                                String arg1)

Redis command getbit.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

getrange

public Maybe<Response> getrange(String arg0,
                                String arg1,
                                String arg2)

Redis command getrange.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxGetrange

public Maybe<Response> rxGetrange(String arg0,
                                  String arg1,
                                  String arg2)

Redis command getrange.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

getset

public Maybe<Response> getset(String arg0,
                              String arg1)

Redis command getset.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxGetset

public Maybe<Response> rxGetset(String arg0,
                                String arg1)

Redis command getset.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

hdel
```
public Maybe<Response> hdel(List<String> args)
```
Redis command hdel.

Parameters:

args -

Returns:

fluent self

rxHdel
```
public Maybe<Response> rxHdel(List<String> args)
```
Redis command hdel.

Parameters:

args -

Returns:

fluent self

hello
```
public Maybe<Response> hello(List<String> args)
```
Redis command hello.

Parameters:

args -

Returns:

fluent self

rxHello
```
public Maybe<Response> rxHello(List<String> args)
```
Redis command hello.

Parameters:

args -

Returns:

fluent self

hexists

public Maybe<Response> hexists(String arg0,
                               String arg1)

Redis command hexists.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxHexists

public Maybe<Response> rxHexists(String arg0,
                                 String arg1)

Redis command hexists.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

hget

public Maybe<Response> hget(String arg0,
                            String arg1)

Redis command hget.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxHget

public Maybe<Response> rxHget(String arg0,
                              String arg1)

Redis command hget.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

hgetall
```
public Maybe<Response> hgetall(String arg0)
```
Redis command hgetall.

Parameters:

arg0 -

Returns:

fluent self

rxHgetall
```
public Maybe<Response> rxHgetall(String arg0)
```
Redis command hgetall.

Parameters:

arg0 -

Returns:

fluent self

hincrby

public Maybe<Response> hincrby(String arg0,
                               String arg1,
                               String arg2)

Redis command hincrby.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxHincrby

public Maybe<Response> rxHincrby(String arg0,
                                 String arg1,
                                 String arg2)

Redis command hincrby.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

hincrbyfloat

public Maybe<Response> hincrbyfloat(String arg0,
                                    String arg1,
                                    String arg2)

Redis command hincrbyfloat.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxHincrbyfloat

public Maybe<Response> rxHincrbyfloat(String arg0,
                                      String arg1,
                                      String arg2)

Redis command hincrbyfloat.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

hkeys
```
public Maybe<Response> hkeys(String arg0)
```
Redis command hkeys.

Parameters:

arg0 -

Returns:

fluent self

rxHkeys
```
public Maybe<Response> rxHkeys(String arg0)
```
Redis command hkeys.

Parameters:

arg0 -

Returns:

fluent self

hlen
```
public Maybe<Response> hlen(String arg0)
```
Redis command hlen.

Parameters:

arg0 -

Returns:

fluent self

rxHlen
```
public Maybe<Response> rxHlen(String arg0)
```
Redis command hlen.

Parameters:

arg0 -

Returns:

fluent self

hmget
```
public Maybe<Response> hmget(List<String> args)
```
Redis command hmget.

Parameters:

args -

Returns:

fluent self

rxHmget
```
public Maybe<Response> rxHmget(List<String> args)
```
Redis command hmget.

Parameters:

args -

Returns:

fluent self

hmset
```
public Maybe<Response> hmset(List<String> args)
```
Redis command hmset.

Parameters:

args -

Returns:

fluent self

rxHmset
```
public Maybe<Response> rxHmset(List<String> args)
```
Redis command hmset.

Parameters:

args -

Returns:

fluent self

host
```
public Maybe<Response> host(List<String> args)
```
Redis command host.

Parameters:

args -

Returns:

fluent self

rxHost
```
public Maybe<Response> rxHost(List<String> args)
```
Redis command host.

Parameters:

args -

Returns:

fluent self

hscan
```
public Maybe<Response> hscan(List<String> args)
```
Redis command hscan.

Parameters:

args -

Returns:

fluent self

rxHscan
```
public Maybe<Response> rxHscan(List<String> args)
```
Redis command hscan.

Parameters:

args -

Returns:

fluent self

hset
```
public Maybe<Response> hset(List<String> args)
```
Redis command hset.

Parameters:

args -

Returns:

fluent self

rxHset
```
public Maybe<Response> rxHset(List<String> args)
```
Redis command hset.

Parameters:

args -

Returns:

fluent self

hsetnx

public Maybe<Response> hsetnx(String arg0,
                              String arg1,
                              String arg2)

Redis command hsetnx.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxHsetnx

public Maybe<Response> rxHsetnx(String arg0,
                                String arg1,
                                String arg2)

Redis command hsetnx.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

hstrlen

public Maybe<Response> hstrlen(String arg0,
                               String arg1)

Redis command hstrlen.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxHstrlen

public Maybe<Response> rxHstrlen(String arg0,
                                 String arg1)

Redis command hstrlen.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

hvals
```
public Maybe<Response> hvals(String arg0)
```
Redis command hvals.

Parameters:

arg0 -

Returns:

fluent self

rxHvals
```
public Maybe<Response> rxHvals(String arg0)
```
Redis command hvals.

Parameters:

arg0 -

Returns:

fluent self

incr
```
public Maybe<Response> incr(String arg0)
```
Redis command incr.

Parameters:

arg0 -

Returns:

fluent self

rxIncr
```
public Maybe<Response> rxIncr(String arg0)
```
Redis command incr.

Parameters:

arg0 -

Returns:

fluent self

incrby

public Maybe<Response> incrby(String arg0,
                              String arg1)

Redis command incrby.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxIncrby

public Maybe<Response> rxIncrby(String arg0,
                                String arg1)

Redis command incrby.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

incrbyfloat

public Maybe<Response> incrbyfloat(String arg0,
                                   String arg1)

Redis command incrbyfloat.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxIncrbyfloat

public Maybe<Response> rxIncrbyfloat(String arg0,
                                     String arg1)

Redis command incrbyfloat.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

info
```
public Maybe<Response> info(List<String> args)
```
Redis command info.

Parameters:

args -

Returns:

fluent self

rxInfo
```
public Maybe<Response> rxInfo(List<String> args)
```
Redis command info.

Parameters:

args -

Returns:

fluent self

keys
```
public Maybe<Response> keys(String arg0)
```
Redis command keys.

Parameters:

arg0 -

Returns:

fluent self

rxKeys
```
public Maybe<Response> rxKeys(String arg0)
```
Redis command keys.

Parameters:

arg0 -

Returns:

fluent self

lastsave
```
public Maybe<Response> lastsave()
```
Redis command lastsave.

Returns:

fluent self

rxLastsave
```
public Maybe<Response> rxLastsave()
```
Redis command lastsave.

Returns:

fluent self

latency
```
public Maybe<Response> latency(List<String> args)
```
Redis command latency.

Parameters:

args -

Returns:

fluent self

rxLatency
```
public Maybe<Response> rxLatency(List<String> args)
```
Redis command latency.

Parameters:

args -

Returns:

fluent self

lindex

public Maybe<Response> lindex(String arg0,
                              String arg1)

Redis command lindex.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxLindex

public Maybe<Response> rxLindex(String arg0,
                                String arg1)

Redis command lindex.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

linsert

public Maybe<Response> linsert(String arg0,
                               String arg1,
                               String arg2,
                               String arg3)

Redis command linsert.

Parameters:: arg0 -; arg1 -; arg2 -; arg3 -
Returns:: fluent self

rxLinsert

public Maybe<Response> rxLinsert(String arg0,
                                 String arg1,
                                 String arg2,
                                 String arg3)

Redis command linsert.

Parameters:: arg0 -; arg1 -; arg2 -; arg3 -
Returns:: fluent self

llen
```
public Maybe<Response> llen(String arg0)
```
Redis command llen.

Parameters:

arg0 -

Returns:

fluent self

rxLlen
```
public Maybe<Response> rxLlen(String arg0)
```
Redis command llen.

Parameters:

arg0 -

Returns:

fluent self

lolwut
```
public Maybe<Response> lolwut(List<String> args)
```
Redis command lolwut.

Parameters:

args -

Returns:

fluent self

rxLolwut
```
public Maybe<Response> rxLolwut(List<String> args)
```
Redis command lolwut.

Parameters:

args -

Returns:

fluent self

lpop
```
public Maybe<Response> lpop(String arg0)
```
Redis command lpop.

Parameters:

arg0 -

Returns:

fluent self

rxLpop
```
public Maybe<Response> rxLpop(String arg0)
```
Redis command lpop.

Parameters:

arg0 -

Returns:

fluent self

lpush
```
public Maybe<Response> lpush(List<String> args)
```
Redis command lpush.

Parameters:

args -

Returns:

fluent self

rxLpush
```
public Maybe<Response> rxLpush(List<String> args)
```
Redis command lpush.

Parameters:

args -

Returns:

fluent self

lpushx
```
public Maybe<Response> lpushx(List<String> args)
```
Redis command lpushx.

Parameters:

args -

Returns:

fluent self

rxLpushx
```
public Maybe<Response> rxLpushx(List<String> args)
```
Redis command lpushx.

Parameters:

args -

Returns:

fluent self

lrange

public Maybe<Response> lrange(String arg0,
                              String arg1,
                              String arg2)

Redis command lrange.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxLrange

public Maybe<Response> rxLrange(String arg0,
                                String arg1,
                                String arg2)

Redis command lrange.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

lrem

public Maybe<Response> lrem(String arg0,
                            String arg1,
                            String arg2)

Redis command lrem.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxLrem

public Maybe<Response> rxLrem(String arg0,
                              String arg1,
                              String arg2)

Redis command lrem.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

lset

public Maybe<Response> lset(String arg0,
                            String arg1,
                            String arg2)

Redis command lset.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxLset

public Maybe<Response> rxLset(String arg0,
                              String arg1,
                              String arg2)

Redis command lset.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

ltrim

public Maybe<Response> ltrim(String arg0,
                             String arg1,
                             String arg2)

Redis command ltrim.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxLtrim

public Maybe<Response> rxLtrim(String arg0,
                               String arg1,
                               String arg2)

Redis command ltrim.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

memory
```
public Maybe<Response> memory(List<String> args)
```
Redis command memory.

Parameters:

args -

Returns:

fluent self

rxMemory
```
public Maybe<Response> rxMemory(List<String> args)
```
Redis command memory.

Parameters:

args -

Returns:

fluent self

mget
```
public Maybe<Response> mget(List<String> args)
```
Redis command mget.

Parameters:

args -

Returns:

fluent self

rxMget
```
public Maybe<Response> rxMget(List<String> args)
```
Redis command mget.

Parameters:

args -

Returns:

fluent self

migrate
```
public Maybe<Response> migrate(List<String> args)
```
Redis command migrate.

Parameters:

args -

Returns:

fluent self

rxMigrate
```
public Maybe<Response> rxMigrate(List<String> args)
```
Redis command migrate.

Parameters:

args -

Returns:

fluent self

module
```
public Maybe<Response> module(List<String> args)
```
Redis command module.

Parameters:

args -

Returns:

fluent self

rxModule
```
public Maybe<Response> rxModule(List<String> args)
```
Redis command module.

Parameters:

args -

Returns:

fluent self

monitor
```
public Maybe<Response> monitor()
```
Redis command monitor.

Returns:

fluent self

rxMonitor
```
public Maybe<Response> rxMonitor()
```
Redis command monitor.

Returns:

fluent self

move

public Maybe<Response> move(String arg0,
                            String arg1)

Redis command move.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxMove

public Maybe<Response> rxMove(String arg0,
                              String arg1)

Redis command move.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

mset
```
public Maybe<Response> mset(List<String> args)
```
Redis command mset.

Parameters:

args -

Returns:

fluent self

rxMset
```
public Maybe<Response> rxMset(List<String> args)
```
Redis command mset.

Parameters:

args -

Returns:

fluent self

msetnx
```
public Maybe<Response> msetnx(List<String> args)
```
Redis command msetnx.

Parameters:

args -

Returns:

fluent self

rxMsetnx
```
public Maybe<Response> rxMsetnx(List<String> args)
```
Redis command msetnx.

Parameters:

args -

Returns:

fluent self

multi
```
public Maybe<Response> multi()
```
Redis command multi.

Returns:

fluent self

rxMulti
```
public Maybe<Response> rxMulti()
```
Redis command multi.

Returns:

fluent self

object
```
public Maybe<Response> object(List<String> args)
```
Redis command object.

Parameters:

args -

Returns:

fluent self

rxObject
```
public Maybe<Response> rxObject(List<String> args)
```
Redis command object.

Parameters:

args -

Returns:

fluent self

persist
```
public Maybe<Response> persist(String arg0)
```
Redis command persist.

Parameters:

arg0 -

Returns:

fluent self

rxPersist
```
public Maybe<Response> rxPersist(String arg0)
```
Redis command persist.

Parameters:

arg0 -

Returns:

fluent self

pexpire

public Maybe<Response> pexpire(String arg0,
                               String arg1)

Redis command pexpire.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxPexpire

public Maybe<Response> rxPexpire(String arg0,
                                 String arg1)

Redis command pexpire.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

pexpireat

public Maybe<Response> pexpireat(String arg0,
                                 String arg1)

Redis command pexpireat.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxPexpireat

public Maybe<Response> rxPexpireat(String arg0,
                                   String arg1)

Redis command pexpireat.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

pfadd
```
public Maybe<Response> pfadd(List<String> args)
```
Redis command pfadd.

Parameters:

args -

Returns:

fluent self

rxPfadd
```
public Maybe<Response> rxPfadd(List<String> args)
```
Redis command pfadd.

Parameters:

args -

Returns:

fluent self

pfcount
```
public Maybe<Response> pfcount(List<String> args)
```
Redis command pfcount.

Parameters:

args -

Returns:

fluent self

rxPfcount
```
public Maybe<Response> rxPfcount(List<String> args)
```
Redis command pfcount.

Parameters:

args -

Returns:

fluent self

pfdebug
```
public Maybe<Response> pfdebug(List<String> args)
```
Redis command pfdebug.

Parameters:

args -

Returns:

fluent self

rxPfdebug
```
public Maybe<Response> rxPfdebug(List<String> args)
```
Redis command pfdebug.

Parameters:

args -

Returns:

fluent self

pfmerge
```
public Maybe<Response> pfmerge(List<String> args)
```
Redis command pfmerge.

Parameters:

args -

Returns:

fluent self

rxPfmerge
```
public Maybe<Response> rxPfmerge(List<String> args)
```
Redis command pfmerge.

Parameters:

args -

Returns:

fluent self

pfselftest
```
public Maybe<Response> pfselftest()
```
Redis command pfselftest.

Returns:

fluent self

rxPfselftest
```
public Maybe<Response> rxPfselftest()
```
Redis command pfselftest.

Returns:

fluent self

ping
```
public Maybe<Response> ping(List<String> args)
```
Redis command ping.

Parameters:

args -

Returns:

fluent self

rxPing
```
public Maybe<Response> rxPing(List<String> args)
```
Redis command ping.

Parameters:

args -

Returns:

fluent self

post
```
public Maybe<Response> post(List<String> args)
```
Redis command post.

Parameters:

args -

Returns:

fluent self

rxPost
```
public Maybe<Response> rxPost(List<String> args)
```
Redis command post.

Parameters:

args -

Returns:

fluent self

psetex

public Maybe<Response> psetex(String arg0,
                              String arg1,
                              String arg2)

Redis command psetex.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxPsetex

public Maybe<Response> rxPsetex(String arg0,
                                String arg1,
                                String arg2)

Redis command psetex.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

psubscribe
```
public Maybe<Response> psubscribe(List<String> args)
```
Redis command psubscribe.

Parameters:

args -

Returns:

fluent self

rxPsubscribe
```
public Maybe<Response> rxPsubscribe(List<String> args)
```
Redis command psubscribe.

Parameters:

args -

Returns:

fluent self

psync

public Maybe<Response> psync(String arg0,
                             String arg1)

Redis command psync.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxPsync

public Maybe<Response> rxPsync(String arg0,
                               String arg1)

Redis command psync.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

pttl
```
public Maybe<Response> pttl(String arg0)
```
Redis command pttl.

Parameters:

arg0 -

Returns:

fluent self

rxPttl
```
public Maybe<Response> rxPttl(String arg0)
```
Redis command pttl.

Parameters:

arg0 -

Returns:

fluent self

publish

public Maybe<Response> publish(String arg0,
                               String arg1)

Redis command publish.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxPublish

public Maybe<Response> rxPublish(String arg0,
                                 String arg1)

Redis command publish.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

pubsub
```
public Maybe<Response> pubsub(List<String> args)
```
Redis command pubsub.

Parameters:

args -

Returns:

fluent self

rxPubsub
```
public Maybe<Response> rxPubsub(List<String> args)
```
Redis command pubsub.

Parameters:

args -

Returns:

fluent self

punsubscribe
```
public Maybe<Response> punsubscribe(List<String> args)
```
Redis command punsubscribe.

Parameters:

args -

Returns:

fluent self

rxPunsubscribe
```
public Maybe<Response> rxPunsubscribe(List<String> args)
```
Redis command punsubscribe.

Parameters:

args -

Returns:

fluent self

randomkey
```
public Maybe<Response> randomkey()
```
Redis command randomkey.

Returns:

fluent self

rxRandomkey
```
public Maybe<Response> rxRandomkey()
```
Redis command randomkey.

Returns:

fluent self

readonly
```
public Maybe<Response> readonly()
```
Redis command readonly.

Returns:

fluent self

rxReadonly
```
public Maybe<Response> rxReadonly()
```
Redis command readonly.

Returns:

fluent self

readwrite
```
public Maybe<Response> readwrite()
```
Redis command readwrite.

Returns:

fluent self

rxReadwrite
```
public Maybe<Response> rxReadwrite()
```
Redis command readwrite.

Returns:

fluent self

rename

public Maybe<Response> rename(String arg0,
                              String arg1)

Redis command rename.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxRename

public Maybe<Response> rxRename(String arg0,
                                String arg1)

Redis command rename.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

renamenx

public Maybe<Response> renamenx(String arg0,
                                String arg1)

Redis command renamenx.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxRenamenx

public Maybe<Response> rxRenamenx(String arg0,
                                  String arg1)

Redis command renamenx.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

replconf
```
public Maybe<Response> replconf(List<String> args)
```
Redis command replconf.

Parameters:

args -

Returns:

fluent self

rxReplconf
```
public Maybe<Response> rxReplconf(List<String> args)
```
Redis command replconf.

Parameters:

args -

Returns:

fluent self

replicaof

public Maybe<Response> replicaof(String arg0,
                                 String arg1)

Redis command replicaof.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxReplicaof

public Maybe<Response> rxReplicaof(String arg0,
                                   String arg1)

Redis command replicaof.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

restore
```
public Maybe<Response> restore(List<String> args)
```
Redis command restore.

Parameters:

args -

Returns:

fluent self

rxRestore
```
public Maybe<Response> rxRestore(List<String> args)
```
Redis command restore.

Parameters:

args -

Returns:

fluent self

restoreAsking
```
public Maybe<Response> restoreAsking(List<String> args)
```
Redis command restoreAsking.

Parameters:

args -

Returns:

fluent self

rxRestoreAsking
```
public Maybe<Response> rxRestoreAsking(List<String> args)
```
Redis command restoreAsking.

Parameters:

args -

Returns:

fluent self

role
```
public Maybe<Response> role()
```
Redis command role.

Returns:

fluent self

rxRole
```
public Maybe<Response> rxRole()
```
Redis command role.

Returns:

fluent self

rpop
```
public Maybe<Response> rpop(String arg0)
```
Redis command rpop.

Parameters:

arg0 -

Returns:

fluent self

rxRpop
```
public Maybe<Response> rxRpop(String arg0)
```
Redis command rpop.

Parameters:

arg0 -

Returns:

fluent self

rpoplpush

public Maybe<Response> rpoplpush(String arg0,
                                 String arg1)

Redis command rpoplpush.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxRpoplpush

public Maybe<Response> rxRpoplpush(String arg0,
                                   String arg1)

Redis command rpoplpush.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rpush
```
public Maybe<Response> rpush(List<String> args)
```
Redis command rpush.

Parameters:

args -

Returns:

fluent self

rxRpush
```
public Maybe<Response> rxRpush(List<String> args)
```
Redis command rpush.

Parameters:

args -

Returns:

fluent self

rpushx
```
public Maybe<Response> rpushx(List<String> args)
```
Redis command rpushx.

Parameters:

args -

Returns:

fluent self

rxRpushx
```
public Maybe<Response> rxRpushx(List<String> args)
```
Redis command rpushx.

Parameters:

args -

Returns:

fluent self

sadd
```
public Maybe<Response> sadd(List<String> args)
```
Redis command sadd.

Parameters:

args -

Returns:

fluent self

rxSadd
```
public Maybe<Response> rxSadd(List<String> args)
```
Redis command sadd.

Parameters:

args -

Returns:

fluent self

save
```
public Maybe<Response> save()
```
Redis command save.

Returns:

fluent self

rxSave
```
public Maybe<Response> rxSave()
```
Redis command save.

Returns:

fluent self

scan
```
public Maybe<Response> scan(List<String> args)
```
Redis command scan.

Parameters:

args -

Returns:

fluent self

rxScan
```
public Maybe<Response> rxScan(List<String> args)
```
Redis command scan.

Parameters:

args -

Returns:

fluent self

scard
```
public Maybe<Response> scard(String arg0)
```
Redis command scard.

Parameters:

arg0 -

Returns:

fluent self

rxScard
```
public Maybe<Response> rxScard(String arg0)
```
Redis command scard.

Parameters:

arg0 -

Returns:

fluent self

script
```
public Maybe<Response> script(List<String> args)
```
Redis command script.

Parameters:

args -

Returns:

fluent self

rxScript
```
public Maybe<Response> rxScript(List<String> args)
```
Redis command script.

Parameters:

args -

Returns:

fluent self

sdiff
```
public Maybe<Response> sdiff(List<String> args)
```
Redis command sdiff.

Parameters:

args -

Returns:

fluent self

rxSdiff
```
public Maybe<Response> rxSdiff(List<String> args)
```
Redis command sdiff.

Parameters:

args -

Returns:

fluent self

sdiffstore
```
public Maybe<Response> sdiffstore(List<String> args)
```
Redis command sdiffstore.

Parameters:

args -

Returns:

fluent self

rxSdiffstore
```
public Maybe<Response> rxSdiffstore(List<String> args)
```
Redis command sdiffstore.

Parameters:

args -

Returns:

fluent self

select
```
public Maybe<Response> select(String arg0)
```
Redis command select.

Parameters:

arg0 -

Returns:

fluent self

rxSelect
```
public Maybe<Response> rxSelect(String arg0)
```
Redis command select.

Parameters:

arg0 -

Returns:

fluent self

set
```
public Maybe<Response> set(List<String> args)
```
Redis command set.

Parameters:

args -

Returns:

fluent self

rxSet
```
public Maybe<Response> rxSet(List<String> args)
```
Redis command set.

Parameters:

args -

Returns:

fluent self

setbit

public Maybe<Response> setbit(String arg0,
                              String arg1,
                              String arg2)

Redis command setbit.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxSetbit

public Maybe<Response> rxSetbit(String arg0,
                                String arg1,
                                String arg2)

Redis command setbit.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

setex

public Maybe<Response> setex(String arg0,
                             String arg1,
                             String arg2)

Redis command setex.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxSetex

public Maybe<Response> rxSetex(String arg0,
                               String arg1,
                               String arg2)

Redis command setex.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

setnx

public Maybe<Response> setnx(String arg0,
                             String arg1)

Redis command setnx.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxSetnx

public Maybe<Response> rxSetnx(String arg0,
                               String arg1)

Redis command setnx.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

setrange

public Maybe<Response> setrange(String arg0,
                                String arg1,
                                String arg2)

Redis command setrange.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxSetrange

public Maybe<Response> rxSetrange(String arg0,
                                  String arg1,
                                  String arg2)

Redis command setrange.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

shutdown
```
public Maybe<Response> shutdown(List<String> args)
```
Redis command shutdown.

Parameters:

args -

Returns:

fluent self

rxShutdown
```
public Maybe<Response> rxShutdown(List<String> args)
```
Redis command shutdown.

Parameters:

args -

Returns:

fluent self

sinter
```
public Maybe<Response> sinter(List<String> args)
```
Redis command sinter.

Parameters:

args -

Returns:

fluent self

rxSinter
```
public Maybe<Response> rxSinter(List<String> args)
```
Redis command sinter.

Parameters:

args -

Returns:

fluent self

sinterstore
```
public Maybe<Response> sinterstore(List<String> args)
```
Redis command sinterstore.

Parameters:

args -

Returns:

fluent self

rxSinterstore
```
public Maybe<Response> rxSinterstore(List<String> args)
```
Redis command sinterstore.

Parameters:

args -

Returns:

fluent self

sismember

public Maybe<Response> sismember(String arg0,
                                 String arg1)

Redis command sismember.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxSismember

public Maybe<Response> rxSismember(String arg0,
                                   String arg1)

Redis command sismember.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

slaveof

public Maybe<Response> slaveof(String arg0,
                               String arg1)

Redis command slaveof.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxSlaveof

public Maybe<Response> rxSlaveof(String arg0,
                                 String arg1)

Redis command slaveof.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

slowlog
```
public Maybe<Response> slowlog(List<String> args)
```
Redis command slowlog.

Parameters:

args -

Returns:

fluent self

rxSlowlog
```
public Maybe<Response> rxSlowlog(List<String> args)
```
Redis command slowlog.

Parameters:

args -

Returns:

fluent self

smembers
```
public Maybe<Response> smembers(String arg0)
```
Redis command smembers.

Parameters:

arg0 -

Returns:

fluent self

rxSmembers
```
public Maybe<Response> rxSmembers(String arg0)
```
Redis command smembers.

Parameters:

arg0 -

Returns:

fluent self

smove

public Maybe<Response> smove(String arg0,
                             String arg1,
                             String arg2)

Redis command smove.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxSmove

public Maybe<Response> rxSmove(String arg0,
                               String arg1,
                               String arg2)

Redis command smove.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

sort
```
public Maybe<Response> sort(List<String> args)
```
Redis command sort.

Parameters:

args -

Returns:

fluent self

rxSort
```
public Maybe<Response> rxSort(List<String> args)
```
Redis command sort.

Parameters:

args -

Returns:

fluent self

spop
```
public Maybe<Response> spop(List<String> args)
```
Redis command spop.

Parameters:

args -

Returns:

fluent self

rxSpop
```
public Maybe<Response> rxSpop(List<String> args)
```
Redis command spop.

Parameters:

args -

Returns:

fluent self

srandmember
```
public Maybe<Response> srandmember(List<String> args)
```
Redis command srandmember.

Parameters:

args -

Returns:

fluent self

rxSrandmember
```
public Maybe<Response> rxSrandmember(List<String> args)
```
Redis command srandmember.

Parameters:

args -

Returns:

fluent self

srem
```
public Maybe<Response> srem(List<String> args)
```
Redis command srem.

Parameters:

args -

Returns:

fluent self

rxSrem
```
public Maybe<Response> rxSrem(List<String> args)
```
Redis command srem.

Parameters:

args -

Returns:

fluent self

sscan
```
public Maybe<Response> sscan(List<String> args)
```
Redis command sscan.

Parameters:

args -

Returns:

fluent self

rxSscan
```
public Maybe<Response> rxSscan(List<String> args)
```
Redis command sscan.

Parameters:

args -

Returns:

fluent self

stralgo
```
public Maybe<Response> stralgo(List<String> args)
```
Redis command stralgo.

Parameters:

args -

Returns:

fluent self

rxStralgo
```
public Maybe<Response> rxStralgo(List<String> args)
```
Redis command stralgo.

Parameters:

args -

Returns:

fluent self

strlen
```
public Maybe<Response> strlen(String arg0)
```
Redis command strlen.

Parameters:

arg0 -

Returns:

fluent self

rxStrlen
```
public Maybe<Response> rxStrlen(String arg0)
```
Redis command strlen.

Parameters:

arg0 -

Returns:

fluent self

subscribe
```
public Maybe<Response> subscribe(List<String> args)
```
Redis command subscribe.

Parameters:

args -

Returns:

fluent self

rxSubscribe
```
public Maybe<Response> rxSubscribe(List<String> args)
```
Redis command subscribe.

Parameters:

args -

Returns:

fluent self

substr

public Maybe<Response> substr(String arg0,
                              String arg1,
                              String arg2)

Redis command substr.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxSubstr

public Maybe<Response> rxSubstr(String arg0,
                                String arg1,
                                String arg2)

Redis command substr.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

sunion
```
public Maybe<Response> sunion(List<String> args)
```
Redis command sunion.

Parameters:

args -

Returns:

fluent self

rxSunion
```
public Maybe<Response> rxSunion(List<String> args)
```
Redis command sunion.

Parameters:

args -

Returns:

fluent self

sunionstore
```
public Maybe<Response> sunionstore(List<String> args)
```
Redis command sunionstore.

Parameters:

args -

Returns:

fluent self

rxSunionstore
```
public Maybe<Response> rxSunionstore(List<String> args)
```
Redis command sunionstore.

Parameters:

args -

Returns:

fluent self

swapdb

public Maybe<Response> swapdb(String arg0,
                              String arg1)

Redis command swapdb.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxSwapdb

public Maybe<Response> rxSwapdb(String arg0,
                                String arg1)

Redis command swapdb.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

sync
```
public Maybe<Response> sync()
```
Redis command sync.

Returns:

fluent self

rxSync
```
public Maybe<Response> rxSync()
```
Redis command sync.

Returns:

fluent self

time
```
public Maybe<Response> time()
```
Redis command time.

Returns:

fluent self

rxTime
```
public Maybe<Response> rxTime()
```
Redis command time.

Returns:

fluent self

touch
```
public Maybe<Response> touch(List<String> args)
```
Redis command touch.

Parameters:

args -

Returns:

fluent self

rxTouch
```
public Maybe<Response> rxTouch(List<String> args)
```
Redis command touch.

Parameters:

args -

Returns:

fluent self

ttl
```
public Maybe<Response> ttl(String arg0)
```
Redis command ttl.

Parameters:

arg0 -

Returns:

fluent self

rxTtl
```
public Maybe<Response> rxTtl(String arg0)
```
Redis command ttl.

Parameters:

arg0 -

Returns:

fluent self

type
```
public Maybe<Response> type(String arg0)
```
Redis command type.

Parameters:

arg0 -

Returns:

fluent self

rxType
```
public Maybe<Response> rxType(String arg0)
```
Redis command type.

Parameters:

arg0 -

Returns:

fluent self

unlink
```
public Maybe<Response> unlink(List<String> args)
```
Redis command unlink.

Parameters:

args -

Returns:

fluent self

rxUnlink
```
public Maybe<Response> rxUnlink(List<String> args)
```
Redis command unlink.

Parameters:

args -

Returns:

fluent self

unsubscribe
```
public Maybe<Response> unsubscribe(List<String> args)
```
Redis command unsubscribe.

Parameters:

args -

Returns:

fluent self

rxUnsubscribe
```
public Maybe<Response> rxUnsubscribe(List<String> args)
```
Redis command unsubscribe.

Parameters:

args -

Returns:

fluent self

unwatch
```
public Maybe<Response> unwatch()
```
Redis command unwatch.

Returns:

fluent self

rxUnwatch
```
public Maybe<Response> rxUnwatch()
```
Redis command unwatch.

Returns:

fluent self

wait

public Maybe<Response> wait(String arg0,
                            String arg1)

Redis command wait.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxWait

public Maybe<Response> rxWait(String arg0,
                              String arg1)

Redis command wait.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

watch
```
public Maybe<Response> watch(List<String> args)
```
Redis command watch.

Parameters:

args -

Returns:

fluent self

rxWatch
```
public Maybe<Response> rxWatch(List<String> args)
```
Redis command watch.

Parameters:

args -

Returns:

fluent self

xack
```
public Maybe<Response> xack(List<String> args)
```
Redis command xack.

Parameters:

args -

Returns:

fluent self

rxXack
```
public Maybe<Response> rxXack(List<String> args)
```
Redis command xack.

Parameters:

args -

Returns:

fluent self

xadd
```
public Maybe<Response> xadd(List<String> args)
```
Redis command xadd.

Parameters:

args -

Returns:

fluent self

rxXadd
```
public Maybe<Response> rxXadd(List<String> args)
```
Redis command xadd.

Parameters:

args -

Returns:

fluent self

xclaim
```
public Maybe<Response> xclaim(List<String> args)
```
Redis command xclaim.

Parameters:

args -

Returns:

fluent self

rxXclaim
```
public Maybe<Response> rxXclaim(List<String> args)
```
Redis command xclaim.

Parameters:

args -

Returns:

fluent self

xdel
```
public Maybe<Response> xdel(List<String> args)
```
Redis command xdel.

Parameters:

args -

Returns:

fluent self

rxXdel
```
public Maybe<Response> rxXdel(List<String> args)
```
Redis command xdel.

Parameters:

args -

Returns:

fluent self

xgroup
```
public Maybe<Response> xgroup(List<String> args)
```
Redis command xgroup.

Parameters:

args -

Returns:

fluent self

rxXgroup
```
public Maybe<Response> rxXgroup(List<String> args)
```
Redis command xgroup.

Parameters:

args -

Returns:

fluent self

xinfo
```
public Maybe<Response> xinfo(List<String> args)
```
Redis command xinfo.

Parameters:

args -

Returns:

fluent self

rxXinfo
```
public Maybe<Response> rxXinfo(List<String> args)
```
Redis command xinfo.

Parameters:

args -

Returns:

fluent self

xlen
```
public Maybe<Response> xlen(String arg0)
```
Redis command xlen.

Parameters:

arg0 -

Returns:

fluent self

rxXlen
```
public Maybe<Response> rxXlen(String arg0)
```
Redis command xlen.

Parameters:

arg0 -

Returns:

fluent self

xpending
```
public Maybe<Response> xpending(List<String> args)
```
Redis command xpending.

Parameters:

args -

Returns:

fluent self

rxXpending
```
public Maybe<Response> rxXpending(List<String> args)
```
Redis command xpending.

Parameters:

args -

Returns:

fluent self

xrange
```
public Maybe<Response> xrange(List<String> args)
```
Redis command xrange.

Parameters:

args -

Returns:

fluent self

rxXrange
```
public Maybe<Response> rxXrange(List<String> args)
```
Redis command xrange.

Parameters:

args -

Returns:

fluent self

xread
```
public Maybe<Response> xread(List<String> args)
```
Redis command xread.

Parameters:

args -

Returns:

fluent self

rxXread
```
public Maybe<Response> rxXread(List<String> args)
```
Redis command xread.

Parameters:

args -

Returns:

fluent self

xreadgroup
```
public Maybe<Response> xreadgroup(List<String> args)
```
Redis command xreadgroup.

Parameters:

args -

Returns:

fluent self

rxXreadgroup
```
public Maybe<Response> rxXreadgroup(List<String> args)
```
Redis command xreadgroup.

Parameters:

args -

Returns:

fluent self

xrevrange
```
public Maybe<Response> xrevrange(List<String> args)
```
Redis command xrevrange.

Parameters:

args -

Returns:

fluent self

rxXrevrange
```
public Maybe<Response> rxXrevrange(List<String> args)
```
Redis command xrevrange.

Parameters:

args -

Returns:

fluent self

xsetid

public Maybe<Response> xsetid(String arg0,
                              String arg1)

Redis command xsetid.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxXsetid

public Maybe<Response> rxXsetid(String arg0,
                                String arg1)

Redis command xsetid.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

xtrim
```
public Maybe<Response> xtrim(List<String> args)
```
Redis command xtrim.

Parameters:

args -

Returns:

fluent self

rxXtrim
```
public Maybe<Response> rxXtrim(List<String> args)
```
Redis command xtrim.

Parameters:

args -

Returns:

fluent self

zadd
```
public Maybe<Response> zadd(List<String> args)
```
Redis command zadd.

Parameters:

args -

Returns:

fluent self

rxZadd
```
public Maybe<Response> rxZadd(List<String> args)
```
Redis command zadd.

Parameters:

args -

Returns:

fluent self

zcard
```
public Maybe<Response> zcard(String arg0)
```
Redis command zcard.

Parameters:

arg0 -

Returns:

fluent self

rxZcard
```
public Maybe<Response> rxZcard(String arg0)
```
Redis command zcard.

Parameters:

arg0 -

Returns:

fluent self

zcount

public Maybe<Response> zcount(String arg0,
                              String arg1,
                              String arg2)

Redis command zcount.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxZcount

public Maybe<Response> rxZcount(String arg0,
                                String arg1,
                                String arg2)

Redis command zcount.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

zincrby

public Maybe<Response> zincrby(String arg0,
                               String arg1,
                               String arg2)

Redis command zincrby.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxZincrby

public Maybe<Response> rxZincrby(String arg0,
                                 String arg1,
                                 String arg2)

Redis command zincrby.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

zinterstore
```
public Maybe<Response> zinterstore(List<String> args)
```
Redis command zinterstore.

Parameters:

args -

Returns:

fluent self

rxZinterstore
```
public Maybe<Response> rxZinterstore(List<String> args)
```
Redis command zinterstore.

Parameters:

args -

Returns:

fluent self

zlexcount

public Maybe<Response> zlexcount(String arg0,
                                 String arg1,
                                 String arg2)

Redis command zlexcount.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxZlexcount

public Maybe<Response> rxZlexcount(String arg0,
                                   String arg1,
                                   String arg2)

Redis command zlexcount.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

zpopmax
```
public Maybe<Response> zpopmax(List<String> args)
```
Redis command zpopmax.

Parameters:

args -

Returns:

fluent self

rxZpopmax
```
public Maybe<Response> rxZpopmax(List<String> args)
```
Redis command zpopmax.

Parameters:

args -

Returns:

fluent self

zpopmin
```
public Maybe<Response> zpopmin(List<String> args)
```
Redis command zpopmin.

Parameters:

args -

Returns:

fluent self

rxZpopmin
```
public Maybe<Response> rxZpopmin(List<String> args)
```
Redis command zpopmin.

Parameters:

args -

Returns:

fluent self

zrange
```
public Maybe<Response> zrange(List<String> args)
```
Redis command zrange.

Parameters:

args -

Returns:

fluent self

rxZrange
```
public Maybe<Response> rxZrange(List<String> args)
```
Redis command zrange.

Parameters:

args -

Returns:

fluent self

zrangebylex
```
public Maybe<Response> zrangebylex(List<String> args)
```
Redis command zrangebylex.

Parameters:

args -

Returns:

fluent self

rxZrangebylex
```
public Maybe<Response> rxZrangebylex(List<String> args)
```
Redis command zrangebylex.

Parameters:

args -

Returns:

fluent self

zrangebyscore
```
public Maybe<Response> zrangebyscore(List<String> args)
```
Redis command zrangebyscore.

Parameters:

args -

Returns:

fluent self

rxZrangebyscore
```
public Maybe<Response> rxZrangebyscore(List<String> args)
```
Redis command zrangebyscore.

Parameters:

args -

Returns:

fluent self

zrank

public Maybe<Response> zrank(String arg0,
                             String arg1)

Redis command zrank.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxZrank

public Maybe<Response> rxZrank(String arg0,
                               String arg1)

Redis command zrank.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

zrem
```
public Maybe<Response> zrem(List<String> args)
```
Redis command zrem.

Parameters:

args -

Returns:

fluent self

rxZrem
```
public Maybe<Response> rxZrem(List<String> args)
```
Redis command zrem.

Parameters:

args -

Returns:

fluent self

zremrangebylex

public Maybe<Response> zremrangebylex(String arg0,
                                      String arg1,
                                      String arg2)

Redis command zremrangebylex.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxZremrangebylex

public Maybe<Response> rxZremrangebylex(String arg0,
                                        String arg1,
                                        String arg2)

Redis command zremrangebylex.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

zremrangebyrank

public Maybe<Response> zremrangebyrank(String arg0,
                                       String arg1,
                                       String arg2)

Redis command zremrangebyrank.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxZremrangebyrank

public Maybe<Response> rxZremrangebyrank(String arg0,
                                         String arg1,
                                         String arg2)

Redis command zremrangebyrank.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

zremrangebyscore

public Maybe<Response> zremrangebyscore(String arg0,
                                        String arg1,
                                        String arg2)

Redis command zremrangebyscore.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

rxZremrangebyscore

public Maybe<Response> rxZremrangebyscore(String arg0,
                                          String arg1,
                                          String arg2)

Redis command zremrangebyscore.

Parameters:: arg0 -; arg1 -; arg2 -
Returns:: fluent self

zrevrange
```
public Maybe<Response> zrevrange(List<String> args)
```
Redis command zrevrange.

Parameters:

args -

Returns:

fluent self

rxZrevrange
```
public Maybe<Response> rxZrevrange(List<String> args)
```
Redis command zrevrange.

Parameters:

args -

Returns:

fluent self

zrevrangebylex
```
public Maybe<Response> zrevrangebylex(List<String> args)
```
Redis command zrevrangebylex.

Parameters:

args -

Returns:

fluent self

rxZrevrangebylex
```
public Maybe<Response> rxZrevrangebylex(List<String> args)
```
Redis command zrevrangebylex.

Parameters:

args -

Returns:

fluent self

zrevrangebyscore
```
public Maybe<Response> zrevrangebyscore(List<String> args)
```
Redis command zrevrangebyscore.

Parameters:

args -

Returns:

fluent self

rxZrevrangebyscore
```
public Maybe<Response> rxZrevrangebyscore(List<String> args)
```
Redis command zrevrangebyscore.

Parameters:

args -

Returns:

fluent self

zrevrank

public Maybe<Response> zrevrank(String arg0,
                                String arg1)

Redis command zrevrank.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxZrevrank

public Maybe<Response> rxZrevrank(String arg0,
                                  String arg1)

Redis command zrevrank.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

zscan
```
public Maybe<Response> zscan(List<String> args)
```
Redis command zscan.

Parameters:

args -

Returns:

fluent self

rxZscan
```
public Maybe<Response> rxZscan(List<String> args)
```
Redis command zscan.

Parameters:

args -

Returns:

fluent self

zscore

public Maybe<Response> zscore(String arg0,
                              String arg1)

Redis command zscore.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

rxZscore

public Maybe<Response> rxZscore(String arg0,
                                String arg1)

Redis command zscore.

Parameters:: arg0 -; arg1 -
Returns:: fluent self

zunionstore
```
public Maybe<Response> zunionstore(List<String> args)
```
Redis command zunionstore.

Parameters:

args -

Returns:

fluent self

rxZunionstore
```
public Maybe<Response> rxZunionstore(List<String> args)
```
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

acl

rxAcl

append

rxAppend

asking

rxAsking

auth

rxAuth

bgrewriteaof

rxBgrewriteaof

bgsave

rxBgsave

bitcount

rxBitcount

bitfield

rxBitfield

bitfieldRo

rxBitfieldRo

bitop

rxBitop

bitpos

rxBitpos

blpop

rxBlpop

brpop

rxBrpop

brpoplpush

rxBrpoplpush

bzpopmax

rxBzpopmax

bzpopmin

rxBzpopmin

client

rxClient

cluster

rxCluster

command

rxCommand

config

rxConfig

dbsize

rxDbsize

debug

rxDebug

decr

rxDecr

decrby

rxDecrby

del

rxDel

discard

rxDiscard

dump

rxDump

echo

rxEcho

eval

rxEval

evalsha

rxEvalsha

exec

rxExec

exists

rxExists