io.vertx.rxjava.redis.client

## Class RedisAPI

- java.lang.Object
- - io.vertx.rxjava.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`

  - ### Constructor Summary

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

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `static RedisAPI` | `api(Redis client)`
    `static RedisAPI` | `api(RedisConnection connection)`
    `RedisAPI` | `append(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command append.
    `Observable<Response>` | `appendObservable(String arg0, String arg1)` Deprecated. use `rxAppend(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `asking(Handler<AsyncResult<Response>> handler)` Redis command asking.
    `Observable<Response>` | `askingObservable()` Deprecated. use `rxAsking()` instead
    `RedisAPI` | `auth(String arg0, Handler<AsyncResult<Response>> handler)` Redis command auth.
    `Observable<Response>` | `authObservable(String arg0)` Deprecated. use `rxAuth(java.lang.String)` instead
    `RedisAPI` | `bgrewriteaof(Handler<AsyncResult<Response>> handler)` Redis command bgrewriteaof.
    `Observable<Response>` | `bgrewriteaofObservable()` Deprecated. use `rxBgrewriteaof()` instead
    `RedisAPI` | `bgsave(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bgsave.
    `Observable<Response>` | `bgsaveObservable(List<String> args)` Deprecated. use `rxBgsave(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `bitcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitcount.
    `Observable<Response>` | `bitcountObservable(List<String> args)` Deprecated. use `rxBitcount(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `bitfield(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitfield.
    `Observable<Response>` | `bitfieldObservable(List<String> args)` Deprecated. use `rxBitfield(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `bitop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitop.
    `Observable<Response>` | `bitopObservable(List<String> args)` Deprecated. use `rxBitop(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `bitpos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bitpos.
    `Observable<Response>` | `bitposObservable(List<String> args)` Deprecated. use `rxBitpos(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `blpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command blpop.
    `Observable<Response>` | `blpopObservable(List<String> args)` Deprecated. use `rxBlpop(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `brpop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command brpop.
    `RedisAPI` | `brpoplpush(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command brpoplpush.
    `Observable<Response>` | `brpoplpushObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxBrpoplpush(java.lang.String, java.lang.String, java.lang.String)` instead
    `Observable<Response>` | `brpopObservable(List<String> args)` Deprecated. use `rxBrpop(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `bzpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bzpopmax.
    `Observable<Response>` | `bzpopmaxObservable(List<String> args)` Deprecated. use `rxBzpopmax(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `bzpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command bzpopmin.
    `Observable<Response>` | `bzpopminObservable(List<String> args)` Deprecated. use `rxBzpopmin(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `client(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command client.
    `Observable<Response>` | `clientObservable(List<String> args)` Deprecated. use `rxClient(java.util.List<java.lang.String>)` instead
    `void` | `close()`
    `RedisAPI` | `cluster(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command cluster.
    `Observable<Response>` | `clusterObservable(List<String> args)` Deprecated. use `rxCluster(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `command(Handler<AsyncResult<Response>> handler)` Redis command command.
    `Observable<Response>` | `commandObservable()` Deprecated. use `rxCommand()` instead
    `RedisAPI` | `config(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command config.
    `Observable<Response>` | `configObservable(List<String> args)` Deprecated. use `rxConfig(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `dbsize(Handler<AsyncResult<Response>> handler)` Redis command dbsize.
    `Observable<Response>` | `dbsizeObservable()` Deprecated. use `rxDbsize()` instead
    `RedisAPI` | `debug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command debug.
    `Observable<Response>` | `debugObservable(List<String> args)` Deprecated. use `rxDebug(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `decr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command decr.
    `RedisAPI` | `decrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command decrby.
    `Observable<Response>` | `decrbyObservable(String arg0, String arg1)` Deprecated. use `rxDecrby(java.lang.String, java.lang.String)` instead
    `Observable<Response>` | `decrObservable(String arg0)` Deprecated. use `rxDecr(java.lang.String)` instead
    `RedisAPI` | `del(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command del.
    `Observable<Response>` | `delObservable(List<String> args)` Deprecated. use `rxDel(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `discard(Handler<AsyncResult<Response>> handler)` Redis command discard.
    `Observable<Response>` | `discardObservable()` Deprecated. use `rxDiscard()` instead
    `RedisAPI` | `dump(String arg0, Handler<AsyncResult<Response>> handler)` Redis command dump.
    `Observable<Response>` | `dumpObservable(String arg0)` Deprecated. use `rxDump(java.lang.String)` instead
    `RedisAPI` | `echo(String arg0, Handler<AsyncResult<Response>> handler)` Redis command echo.
    `Observable<Response>` | `echoObservable(String arg0)` Deprecated. use `rxEcho(java.lang.String)` instead
    `boolean` | `equals(Object o)`
    `RedisAPI` | `eval(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command eval.
    `Observable<Response>` | `evalObservable(List<String> args)` Deprecated. use `rxEval(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `evalsha(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command evalsha.
    `Observable<Response>` | `evalshaObservable(List<String> args)` Deprecated. use `rxEvalsha(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `exec(Handler<AsyncResult<Response>> handler)` Redis command exec.
    `Observable<Response>` | `execObservable()` Deprecated. use `rxExec()` instead
    `RedisAPI` | `exists(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command exists.
    `Observable<Response>` | `existsObservable(List<String> args)` Deprecated. use `rxExists(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `expire(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command expire.
    `RedisAPI` | `expireat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command expireat.
    `Observable<Response>` | `expireatObservable(String arg0, String arg1)` Deprecated. use `rxExpireat(java.lang.String, java.lang.String)` instead
    `Observable<Response>` | `expireObservable(String arg0, String arg1)` Deprecated. use `rxExpire(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `flushall(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command flushall.
    `Observable<Response>` | `flushallObservable(List<String> args)` Deprecated. use `rxFlushall(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `flushdb(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command flushdb.
    `Observable<Response>` | `flushdbObservable(List<String> args)` Deprecated. use `rxFlushdb(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `geoadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geoadd.
    `Observable<Response>` | `geoaddObservable(List<String> args)` Deprecated. use `rxGeoadd(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `geodist(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geodist.
    `Observable<Response>` | `geodistObservable(List<String> args)` Deprecated. use `rxGeodist(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `geohash(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geohash.
    `Observable<Response>` | `geohashObservable(List<String> args)` Deprecated. use `rxGeohash(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `geopos(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command geopos.
    `Observable<Response>` | `geoposObservable(List<String> args)` Deprecated. use `rxGeopos(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `georadius(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadius.
    `RedisAPI` | `georadiusbymember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusbymember.
    `Observable<Response>` | `georadiusbymemberObservable(List<String> args)` Deprecated. use `rxGeoradiusbymember(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `georadiusbymemberRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusbymemberRo.
    `Observable<Response>` | `georadiusbymemberRoObservable(List<String> args)` Deprecated. use `rxGeoradiusbymemberRo(java.util.List<java.lang.String>)` instead
    `Observable<Response>` | `georadiusObservable(List<String> args)` Deprecated. use `rxGeoradius(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `georadiusRo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command georadiusRo.
    `Observable<Response>` | `georadiusRoObservable(List<String> args)` Deprecated. use `rxGeoradiusRo(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `get(String arg0, Handler<AsyncResult<Response>> handler)` Redis command get.
    `RedisAPI` | `getbit(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command getbit.
    `Observable<Response>` | `getbitObservable(String arg0, String arg1)` Deprecated. use `rxGetbit(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `getDelegate()`
    `Observable<Response>` | `getObservable(String arg0)` Deprecated. use `rxGet(java.lang.String)` instead
    `RedisAPI` | `getrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command getrange.
    `Observable<Response>` | `getrangeObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxGetrange(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `getset(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command getset.
    `Observable<Response>` | `getsetObservable(String arg0, String arg1)` Deprecated. use `rxGetset(java.lang.String, java.lang.String)` instead
    `int` | `hashCode()`
    `RedisAPI` | `hdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hdel.
    `Observable<Response>` | `hdelObservable(List<String> args)` Deprecated. use `rxHdel(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `hexists(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hexists.
    `Observable<Response>` | `hexistsObservable(String arg0, String arg1)` Deprecated. use `rxHexists(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `hget(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hget.
    `RedisAPI` | `hgetall(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hgetall.
    `Observable<Response>` | `hgetallObservable(String arg0)` Deprecated. use `rxHgetall(java.lang.String)` instead
    `Observable<Response>` | `hgetObservable(String arg0, String arg1)` Deprecated. use `rxHget(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `hincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hincrby.
    `RedisAPI` | `hincrbyfloat(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hincrbyfloat.
    `Observable<Response>` | `hincrbyfloatObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxHincrbyfloat(java.lang.String, java.lang.String, java.lang.String)` instead
    `Observable<Response>` | `hincrbyObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxHincrby(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `hkeys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hkeys.
    `Observable<Response>` | `hkeysObservable(String arg0)` Deprecated. use `rxHkeys(java.lang.String)` instead
    `RedisAPI` | `hlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hlen.
    `Observable<Response>` | `hlenObservable(String arg0)` Deprecated. use `rxHlen(java.lang.String)` instead
    `RedisAPI` | `hmget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hmget.
    `Observable<Response>` | `hmgetObservable(List<String> args)` Deprecated. use `rxHmget(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `hmset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hmset.
    `Observable<Response>` | `hmsetObservable(List<String> args)` Deprecated. use `rxHmset(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `host(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command host.
    `Observable<Response>` | `hostObservable(List<String> args)` Deprecated. use `rxHost(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `hscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hscan.
    `Observable<Response>` | `hscanObservable(List<String> args)` Deprecated. use `rxHscan(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `hset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command hset.
    `RedisAPI` | `hsetnx(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command hsetnx.
    `Observable<Response>` | `hsetnxObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxHsetnx(java.lang.String, java.lang.String, java.lang.String)` instead
    `Observable<Response>` | `hsetObservable(List<String> args)` Deprecated. use `rxHset(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `hstrlen(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command hstrlen.
    `Observable<Response>` | `hstrlenObservable(String arg0, String arg1)` Deprecated. use `rxHstrlen(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `hvals(String arg0, Handler<AsyncResult<Response>> handler)` Redis command hvals.
    `Observable<Response>` | `hvalsObservable(String arg0)` Deprecated. use `rxHvals(java.lang.String)` instead
    `RedisAPI` | `incr(String arg0, Handler<AsyncResult<Response>> handler)` Redis command incr.
    `RedisAPI` | `incrby(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command incrby.
    `RedisAPI` | `incrbyfloat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command incrbyfloat.
    `Observable<Response>` | `incrbyfloatObservable(String arg0, String arg1)` Deprecated. use `rxIncrbyfloat(java.lang.String, java.lang.String)` instead
    `Observable<Response>` | `incrbyObservable(String arg0, String arg1)` Deprecated. use `rxIncrby(java.lang.String, java.lang.String)` instead
    `Observable<Response>` | `incrObservable(String arg0)` Deprecated. use `rxIncr(java.lang.String)` instead
    `RedisAPI` | `info(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command info.
    `Observable<Response>` | `infoObservable(List<String> args)` Deprecated. use `rxInfo(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `keys(String arg0, Handler<AsyncResult<Response>> handler)` Redis command keys.
    `Observable<Response>` | `keysObservable(String arg0)` Deprecated. use `rxKeys(java.lang.String)` instead
    `RedisAPI` | `lastsave(Handler<AsyncResult<Response>> handler)` Redis command lastsave.
    `Observable<Response>` | `lastsaveObservable()` Deprecated. use `rxLastsave()` instead
    `RedisAPI` | `latency(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command latency.
    `Observable<Response>` | `latencyObservable(List<String> args)` Deprecated. use `rxLatency(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `lindex(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command lindex.
    `Observable<Response>` | `lindexObservable(String arg0, String arg1)` Deprecated. use `rxLindex(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `linsert(String arg0, String arg1, String arg2, String arg3, Handler<AsyncResult<Response>> handler)` Redis command linsert.
    `Observable<Response>` | `linsertObservable(String arg0, String arg1, String arg2, String arg3)` Deprecated. use `rxLinsert(java.lang.String, java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `llen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command llen.
    `Observable<Response>` | `llenObservable(String arg0)` Deprecated. use `rxLlen(java.lang.String)` instead
    `RedisAPI` | `lolwut(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lolwut.
    `Observable<Response>` | `lolwutObservable(List<String> args)` Deprecated. use `rxLolwut(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `lpop(String arg0, Handler<AsyncResult<Response>> handler)` Redis command lpop.
    `Observable<Response>` | `lpopObservable(String arg0)` Deprecated. use `rxLpop(java.lang.String)` instead
    `RedisAPI` | `lpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lpush.
    `Observable<Response>` | `lpushObservable(List<String> args)` Deprecated. use `rxLpush(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `lpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command lpushx.
    `Observable<Response>` | `lpushxObservable(List<String> args)` Deprecated. use `rxLpushx(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `lrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lrange.
    `Observable<Response>` | `lrangeObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxLrange(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `lrem(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lrem.
    `Observable<Response>` | `lremObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxLrem(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `lset(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command lset.
    `Observable<Response>` | `lsetObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxLset(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `ltrim(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command ltrim.
    `Observable<Response>` | `ltrimObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxLtrim(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `memory(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command memory.
    `Observable<Response>` | `memoryObservable(List<String> args)` Deprecated. use `rxMemory(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `mget(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command mget.
    `Observable<Response>` | `mgetObservable(List<String> args)` Deprecated. use `rxMget(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `migrate(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command migrate.
    `Observable<Response>` | `migrateObservable(List<String> args)` Deprecated. use `rxMigrate(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `module(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command module.
    `Observable<Response>` | `moduleObservable(List<String> args)` Deprecated. use `rxModule(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `monitor(Handler<AsyncResult<Response>> handler)` Redis command monitor.
    `Observable<Response>` | `monitorObservable()` Deprecated. use `rxMonitor()` instead
    `RedisAPI` | `move(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command move.
    `Observable<Response>` | `moveObservable(String arg0, String arg1)` Deprecated. use `rxMove(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `mset(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command mset.
    `RedisAPI` | `msetnx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command msetnx.
    `Observable<Response>` | `msetnxObservable(List<String> args)` Deprecated. use `rxMsetnx(java.util.List<java.lang.String>)` instead
    `Observable<Response>` | `msetObservable(List<String> args)` Deprecated. use `rxMset(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `multi(Handler<AsyncResult<Response>> handler)` Redis command multi.
    `Observable<Response>` | `multiObservable()` Deprecated. use `rxMulti()` instead
    `static RedisAPI` | `newInstance(RedisAPI arg)`
    `RedisAPI` | `object(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command object.
    `Observable<Response>` | `objectObservable(List<String> args)` Deprecated. use `rxObject(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `persist(String arg0, Handler<AsyncResult<Response>> handler)` Redis command persist.
    `Observable<Response>` | `persistObservable(String arg0)` Deprecated. use `rxPersist(java.lang.String)` instead
    `RedisAPI` | `pexpire(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command pexpire.
    `RedisAPI` | `pexpireat(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command pexpireat.
    `Observable<Response>` | `pexpireatObservable(String arg0, String arg1)` Deprecated. use `rxPexpireat(java.lang.String, java.lang.String)` instead
    `Observable<Response>` | `pexpireObservable(String arg0, String arg1)` Deprecated. use `rxPexpire(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `pfadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfadd.
    `Observable<Response>` | `pfaddObservable(List<String> args)` Deprecated. use `rxPfadd(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `pfcount(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfcount.
    `Observable<Response>` | `pfcountObservable(List<String> args)` Deprecated. use `rxPfcount(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `pfdebug(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfdebug.
    `Observable<Response>` | `pfdebugObservable(List<String> args)` Deprecated. use `rxPfdebug(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `pfmerge(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pfmerge.
    `Observable<Response>` | `pfmergeObservable(List<String> args)` Deprecated. use `rxPfmerge(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `pfselftest(Handler<AsyncResult<Response>> handler)` Redis command pfselftest.
    `Observable<Response>` | `pfselftestObservable()` Deprecated. use `rxPfselftest()` instead
    `RedisAPI` | `ping(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command ping.
    `Observable<Response>` | `pingObservable(List<String> args)` Deprecated. use `rxPing(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `post(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command post.
    `Observable<Response>` | `postObservable(List<String> args)` Deprecated. use `rxPost(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `psetex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command psetex.
    `Observable<Response>` | `psetexObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxPsetex(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `psubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command psubscribe.
    `Observable<Response>` | `psubscribeObservable(List<String> args)` Deprecated. use `rxPsubscribe(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `psync(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command psync.
    `Observable<Response>` | `psyncObservable(String arg0, String arg1)` Deprecated. use `rxPsync(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `pttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command pttl.
    `Observable<Response>` | `pttlObservable(String arg0)` Deprecated. use `rxPttl(java.lang.String)` instead
    `RedisAPI` | `publish(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command publish.
    `Observable<Response>` | `publishObservable(String arg0, String arg1)` Deprecated. use `rxPublish(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `pubsub(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command pubsub.
    `Observable<Response>` | `pubsubObservable(List<String> args)` Deprecated. use `rxPubsub(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `punsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command punsubscribe.
    `Observable<Response>` | `punsubscribeObservable(List<String> args)` Deprecated. use `rxPunsubscribe(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `randomkey(Handler<AsyncResult<Response>> handler)` Redis command randomkey.
    `Observable<Response>` | `randomkeyObservable()` Deprecated. use `rxRandomkey()` instead
    `RedisAPI` | `readonly(Handler<AsyncResult<Response>> handler)` Redis command readonly.
    `Observable<Response>` | `readonlyObservable()` Deprecated. use `rxReadonly()` instead
    `RedisAPI` | `readwrite(Handler<AsyncResult<Response>> handler)` Redis command readwrite.
    `Observable<Response>` | `readwriteObservable()` Deprecated. use `rxReadwrite()` instead
    `RedisAPI` | `rename(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command rename.
    `RedisAPI` | `renamenx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command renamenx.
    `Observable<Response>` | `renamenxObservable(String arg0, String arg1)` Deprecated. use `rxRenamenx(java.lang.String, java.lang.String)` instead
    `Observable<Response>` | `renameObservable(String arg0, String arg1)` Deprecated. use `rxRename(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `replconf(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command replconf.
    `Observable<Response>` | `replconfObservable(List<String> args)` Deprecated. use `rxReplconf(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `replicaof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command replicaof.
    `Observable<Response>` | `replicaofObservable(String arg0, String arg1)` Deprecated. use `rxReplicaof(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `restore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command restore.
    `RedisAPI` | `restoreAsking(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command restoreAsking.
    `Observable<Response>` | `restoreAskingObservable(List<String> args)` Deprecated. use `rxRestoreAsking(java.util.List<java.lang.String>)` instead
    `Observable<Response>` | `restoreObservable(List<String> args)` Deprecated. use `rxRestore(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `role(Handler<AsyncResult<Response>> handler)` Redis command role.
    `Observable<Response>` | `roleObservable()` Deprecated. use `rxRole()` instead
    `RedisAPI` | `rpop(String arg0, Handler<AsyncResult<Response>> handler)` Redis command rpop.
    `RedisAPI` | `rpoplpush(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command rpoplpush.
    `Observable<Response>` | `rpoplpushObservable(String arg0, String arg1)` Deprecated. use `rxRpoplpush(java.lang.String, java.lang.String)` instead
    `Observable<Response>` | `rpopObservable(String arg0)` Deprecated. use `rxRpop(java.lang.String)` instead
    `RedisAPI` | `rpush(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command rpush.
    `Observable<Response>` | `rpushObservable(List<String> args)` Deprecated. use `rxRpush(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `rpushx(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command rpushx.
    `Observable<Response>` | `rpushxObservable(List<String> args)` Deprecated. use `rxRpushx(java.util.List<java.lang.String>)` instead
    `Single<Response>` | `rxAppend(String arg0, String arg1)` Redis command append.
    `Single<Response>` | `rxAsking()` Redis command asking.
    `Single<Response>` | `rxAuth(String arg0)` Redis command auth.
    `Single<Response>` | `rxBgrewriteaof()` Redis command bgrewriteaof.
    `Single<Response>` | `rxBgsave(List<String> args)` Redis command bgsave.
    `Single<Response>` | `rxBitcount(List<String> args)` Redis command bitcount.
    `Single<Response>` | `rxBitfield(List<String> args)` Redis command bitfield.
    `Single<Response>` | `rxBitop(List<String> args)` Redis command bitop.
    `Single<Response>` | `rxBitpos(List<String> args)` Redis command bitpos.
    `Single<Response>` | `rxBlpop(List<String> args)` Redis command blpop.
    `Single<Response>` | `rxBrpop(List<String> args)` Redis command brpop.
    `Single<Response>` | `rxBrpoplpush(String arg0, String arg1, String arg2)` Redis command brpoplpush.
    `Single<Response>` | `rxBzpopmax(List<String> args)` Redis command bzpopmax.
    `Single<Response>` | `rxBzpopmin(List<String> args)` Redis command bzpopmin.
    `Single<Response>` | `rxClient(List<String> args)` Redis command client.
    `Single<Response>` | `rxCluster(List<String> args)` Redis command cluster.
    `Single<Response>` | `rxCommand()` Redis command command.
    `Single<Response>` | `rxConfig(List<String> args)` Redis command config.
    `Single<Response>` | `rxDbsize()` Redis command dbsize.
    `Single<Response>` | `rxDebug(List<String> args)` Redis command debug.
    `Single<Response>` | `rxDecr(String arg0)` Redis command decr.
    `Single<Response>` | `rxDecrby(String arg0, String arg1)` Redis command decrby.
    `Single<Response>` | `rxDel(List<String> args)` Redis command del.
    `Single<Response>` | `rxDiscard()` Redis command discard.
    `Single<Response>` | `rxDump(String arg0)` Redis command dump.
    `Single<Response>` | `rxEcho(String arg0)` Redis command echo.
    `Single<Response>` | `rxEval(List<String> args)` Redis command eval.
    `Single<Response>` | `rxEvalsha(List<String> args)` Redis command evalsha.
    `Single<Response>` | `rxExec()` Redis command exec.
    `Single<Response>` | `rxExists(List<String> args)` Redis command exists.
    `Single<Response>` | `rxExpire(String arg0, String arg1)` Redis command expire.
    `Single<Response>` | `rxExpireat(String arg0, String arg1)` Redis command expireat.
    `Single<Response>` | `rxFlushall(List<String> args)` Redis command flushall.
    `Single<Response>` | `rxFlushdb(List<String> args)` Redis command flushdb.
    `Single<Response>` | `rxGeoadd(List<String> args)` Redis command geoadd.
    `Single<Response>` | `rxGeodist(List<String> args)` Redis command geodist.
    `Single<Response>` | `rxGeohash(List<String> args)` Redis command geohash.
    `Single<Response>` | `rxGeopos(List<String> args)` Redis command geopos.
    `Single<Response>` | `rxGeoradius(List<String> args)` Redis command georadius.
    `Single<Response>` | `rxGeoradiusbymember(List<String> args)` Redis command georadiusbymember.
    `Single<Response>` | `rxGeoradiusbymemberRo(List<String> args)` Redis command georadiusbymemberRo.
    `Single<Response>` | `rxGeoradiusRo(List<String> args)` Redis command georadiusRo.
    `Single<Response>` | `rxGet(String arg0)` Redis command get.
    `Single<Response>` | `rxGetbit(String arg0, String arg1)` Redis command getbit.
    `Single<Response>` | `rxGetrange(String arg0, String arg1, String arg2)` Redis command getrange.
    `Single<Response>` | `rxGetset(String arg0, String arg1)` Redis command getset.
    `Single<Response>` | `rxHdel(List<String> args)` Redis command hdel.
    `Single<Response>` | `rxHexists(String arg0, String arg1)` Redis command hexists.
    `Single<Response>` | `rxHget(String arg0, String arg1)` Redis command hget.
    `Single<Response>` | `rxHgetall(String arg0)` Redis command hgetall.
    `Single<Response>` | `rxHincrby(String arg0, String arg1, String arg2)` Redis command hincrby.
    `Single<Response>` | `rxHincrbyfloat(String arg0, String arg1, String arg2)` Redis command hincrbyfloat.
    `Single<Response>` | `rxHkeys(String arg0)` Redis command hkeys.
    `Single<Response>` | `rxHlen(String arg0)` Redis command hlen.
    `Single<Response>` | `rxHmget(List<String> args)` Redis command hmget.
    `Single<Response>` | `rxHmset(List<String> args)` Redis command hmset.
    `Single<Response>` | `rxHost(List<String> args)` Redis command host.
    `Single<Response>` | `rxHscan(List<String> args)` Redis command hscan.
    `Single<Response>` | `rxHset(List<String> args)` Redis command hset.
    `Single<Response>` | `rxHsetnx(String arg0, String arg1, String arg2)` Redis command hsetnx.
    `Single<Response>` | `rxHstrlen(String arg0, String arg1)` Redis command hstrlen.
    `Single<Response>` | `rxHvals(String arg0)` Redis command hvals.
    `Single<Response>` | `rxIncr(String arg0)` Redis command incr.
    `Single<Response>` | `rxIncrby(String arg0, String arg1)` Redis command incrby.
    `Single<Response>` | `rxIncrbyfloat(String arg0, String arg1)` Redis command incrbyfloat.
    `Single<Response>` | `rxInfo(List<String> args)` Redis command info.
    `Single<Response>` | `rxKeys(String arg0)` Redis command keys.
    `Single<Response>` | `rxLastsave()` Redis command lastsave.
    `Single<Response>` | `rxLatency(List<String> args)` Redis command latency.
    `Single<Response>` | `rxLindex(String arg0, String arg1)` Redis command lindex.
    `Single<Response>` | `rxLinsert(String arg0, String arg1, String arg2, String arg3)` Redis command linsert.
    `Single<Response>` | `rxLlen(String arg0)` Redis command llen.
    `Single<Response>` | `rxLolwut(List<String> args)` Redis command lolwut.
    `Single<Response>` | `rxLpop(String arg0)` Redis command lpop.
    `Single<Response>` | `rxLpush(List<String> args)` Redis command lpush.
    `Single<Response>` | `rxLpushx(List<String> args)` Redis command lpushx.
    `Single<Response>` | `rxLrange(String arg0, String arg1, String arg2)` Redis command lrange.
    `Single<Response>` | `rxLrem(String arg0, String arg1, String arg2)` Redis command lrem.
    `Single<Response>` | `rxLset(String arg0, String arg1, String arg2)` Redis command lset.
    `Single<Response>` | `rxLtrim(String arg0, String arg1, String arg2)` Redis command ltrim.
    `Single<Response>` | `rxMemory(List<String> args)` Redis command memory.
    `Single<Response>` | `rxMget(List<String> args)` Redis command mget.
    `Single<Response>` | `rxMigrate(List<String> args)` Redis command migrate.
    `Single<Response>` | `rxModule(List<String> args)` Redis command module.
    `Single<Response>` | `rxMonitor()` Redis command monitor.
    `Single<Response>` | `rxMove(String arg0, String arg1)` Redis command move.
    `Single<Response>` | `rxMset(List<String> args)` Redis command mset.
    `Single<Response>` | `rxMsetnx(List<String> args)` Redis command msetnx.
    `Single<Response>` | `rxMulti()` Redis command multi.
    `Single<Response>` | `rxObject(List<String> args)` Redis command object.
    `Single<Response>` | `rxPersist(String arg0)` Redis command persist.
    `Single<Response>` | `rxPexpire(String arg0, String arg1)` Redis command pexpire.
    `Single<Response>` | `rxPexpireat(String arg0, String arg1)` Redis command pexpireat.
    `Single<Response>` | `rxPfadd(List<String> args)` Redis command pfadd.
    `Single<Response>` | `rxPfcount(List<String> args)` Redis command pfcount.
    `Single<Response>` | `rxPfdebug(List<String> args)` Redis command pfdebug.
    `Single<Response>` | `rxPfmerge(List<String> args)` Redis command pfmerge.
    `Single<Response>` | `rxPfselftest()` Redis command pfselftest.
    `Single<Response>` | `rxPing(List<String> args)` Redis command ping.
    `Single<Response>` | `rxPost(List<String> args)` Redis command post.
    `Single<Response>` | `rxPsetex(String arg0, String arg1, String arg2)` Redis command psetex.
    `Single<Response>` | `rxPsubscribe(List<String> args)` Redis command psubscribe.
    `Single<Response>` | `rxPsync(String arg0, String arg1)` Redis command psync.
    `Single<Response>` | `rxPttl(String arg0)` Redis command pttl.
    `Single<Response>` | `rxPublish(String arg0, String arg1)` Redis command publish.
    `Single<Response>` | `rxPubsub(List<String> args)` Redis command pubsub.
    `Single<Response>` | `rxPunsubscribe(List<String> args)` Redis command punsubscribe.
    `Single<Response>` | `rxRandomkey()` Redis command randomkey.
    `Single<Response>` | `rxReadonly()` Redis command readonly.
    `Single<Response>` | `rxReadwrite()` Redis command readwrite.
    `Single<Response>` | `rxRename(String arg0, String arg1)` Redis command rename.
    `Single<Response>` | `rxRenamenx(String arg0, String arg1)` Redis command renamenx.
    `Single<Response>` | `rxReplconf(List<String> args)` Redis command replconf.
    `Single<Response>` | `rxReplicaof(String arg0, String arg1)` Redis command replicaof.
    `Single<Response>` | `rxRestore(List<String> args)` Redis command restore.
    `Single<Response>` | `rxRestoreAsking(List<String> args)` Redis command restoreAsking.
    `Single<Response>` | `rxRole()` Redis command role.
    `Single<Response>` | `rxRpop(String arg0)` Redis command rpop.
    `Single<Response>` | `rxRpoplpush(String arg0, String arg1)` Redis command rpoplpush.
    `Single<Response>` | `rxRpush(List<String> args)` Redis command rpush.
    `Single<Response>` | `rxRpushx(List<String> args)` Redis command rpushx.
    `Single<Response>` | `rxSadd(List<String> args)` Redis command sadd.
    `Single<Response>` | `rxSave()` Redis command save.
    `Single<Response>` | `rxScan(List<String> args)` Redis command scan.
    `Single<Response>` | `rxScard(String arg0)` Redis command scard.
    `Single<Response>` | `rxScript(List<String> args)` Redis command script.
    `Single<Response>` | `rxSdiff(List<String> args)` Redis command sdiff.
    `Single<Response>` | `rxSdiffstore(List<String> args)` Redis command sdiffstore.
    `Single<Response>` | `rxSelect(String arg0)` Redis command select.
    `Single<Response>` | `rxSet(List<String> args)` Redis command set.
    `Single<Response>` | `rxSetbit(String arg0, String arg1, String arg2)` Redis command setbit.
    `Single<Response>` | `rxSetex(String arg0, String arg1, String arg2)` Redis command setex.
    `Single<Response>` | `rxSetnx(String arg0, String arg1)` Redis command setnx.
    `Single<Response>` | `rxSetrange(String arg0, String arg1, String arg2)` Redis command setrange.
    `Single<Response>` | `rxShutdown(List<String> args)` Redis command shutdown.
    `Single<Response>` | `rxSinter(List<String> args)` Redis command sinter.
    `Single<Response>` | `rxSinterstore(List<String> args)` Redis command sinterstore.
    `Single<Response>` | `rxSismember(String arg0, String arg1)` Redis command sismember.
    `Single<Response>` | `rxSlaveof(String arg0, String arg1)` Redis command slaveof.
    `Single<Response>` | `rxSlowlog(List<String> args)` Redis command slowlog.
    `Single<Response>` | `rxSmembers(String arg0)` Redis command smembers.
    `Single<Response>` | `rxSmove(String arg0, String arg1, String arg2)` Redis command smove.
    `Single<Response>` | `rxSort(List<String> args)` Redis command sort.
    `Single<Response>` | `rxSpop(List<String> args)` Redis command spop.
    `Single<Response>` | `rxSrandmember(List<String> args)` Redis command srandmember.
    `Single<Response>` | `rxSrem(List<String> args)` Redis command srem.
    `Single<Response>` | `rxSscan(List<String> args)` Redis command sscan.
    `Single<Response>` | `rxStrlen(String arg0)` Redis command strlen.
    `Single<Response>` | `rxSubscribe(List<String> args)` Redis command subscribe.
    `Single<Response>` | `rxSubstr(String arg0, String arg1, String arg2)` Redis command substr.
    `Single<Response>` | `rxSunion(List<String> args)` Redis command sunion.
    `Single<Response>` | `rxSunionstore(List<String> args)` Redis command sunionstore.
    `Single<Response>` | `rxSwapdb(String arg0, String arg1)` Redis command swapdb.
    `Single<Response>` | `rxSync()` Redis command sync.
    `Single<Response>` | `rxTime()` Redis command time.
    `Single<Response>` | `rxTouch(List<String> args)` Redis command touch.
    `Single<Response>` | `rxTtl(String arg0)` Redis command ttl.
    `Single<Response>` | `rxType(String arg0)` Redis command type.
    `Single<Response>` | `rxUnlink(List<String> args)` Redis command unlink.
    `Single<Response>` | `rxUnsubscribe(List<String> args)` Redis command unsubscribe.
    `Single<Response>` | `rxUnwatch()` Redis command unwatch.
    `Single<Response>` | `rxWait(String arg0, String arg1)` Redis command wait.
    `Single<Response>` | `rxWatch(List<String> args)` Redis command watch.
    `Single<Response>` | `rxXack(List<String> args)` Redis command xack.
    `Single<Response>` | `rxXadd(List<String> args)` Redis command xadd.
    `Single<Response>` | `rxXclaim(List<String> args)` Redis command xclaim.
    `Single<Response>` | `rxXdel(List<String> args)` Redis command xdel.
    `Single<Response>` | `rxXgroup(List<String> args)` Redis command xgroup.
    `Single<Response>` | `rxXinfo(List<String> args)` Redis command xinfo.
    `Single<Response>` | `rxXlen(String arg0)` Redis command xlen.
    `Single<Response>` | `rxXpending(List<String> args)` Redis command xpending.
    `Single<Response>` | `rxXrange(List<String> args)` Redis command xrange.
    `Single<Response>` | `rxXread(List<String> args)` Redis command xread.
    `Single<Response>` | `rxXreadgroup(List<String> args)` Redis command xreadgroup.
    `Single<Response>` | `rxXrevrange(List<String> args)` Redis command xrevrange.
    `Single<Response>` | `rxXsetid(String arg0, String arg1)` Redis command xsetid.
    `Single<Response>` | `rxXtrim(List<String> args)` Redis command xtrim.
    `Single<Response>` | `rxZadd(List<String> args)` Redis command zadd.
    `Single<Response>` | `rxZcard(String arg0)` Redis command zcard.
    `Single<Response>` | `rxZcount(String arg0, String arg1, String arg2)` Redis command zcount.
    `Single<Response>` | `rxZincrby(String arg0, String arg1, String arg2)` Redis command zincrby.
    `Single<Response>` | `rxZinterstore(List<String> args)` Redis command zinterstore.
    `Single<Response>` | `rxZlexcount(String arg0, String arg1, String arg2)` Redis command zlexcount.
    `Single<Response>` | `rxZpopmax(List<String> args)` Redis command zpopmax.
    `Single<Response>` | `rxZpopmin(List<String> args)` Redis command zpopmin.
    `Single<Response>` | `rxZrange(List<String> args)` Redis command zrange.
    `Single<Response>` | `rxZrangebylex(List<String> args)` Redis command zrangebylex.
    `Single<Response>` | `rxZrangebyscore(List<String> args)` Redis command zrangebyscore.
    `Single<Response>` | `rxZrank(String arg0, String arg1)` Redis command zrank.
    `Single<Response>` | `rxZrem(List<String> args)` Redis command zrem.
    `Single<Response>` | `rxZremrangebylex(String arg0, String arg1, String arg2)` Redis command zremrangebylex.
    `Single<Response>` | `rxZremrangebyrank(String arg0, String arg1, String arg2)` Redis command zremrangebyrank.
    `Single<Response>` | `rxZremrangebyscore(String arg0, String arg1, String arg2)` Redis command zremrangebyscore.
    `Single<Response>` | `rxZrevrange(List<String> args)` Redis command zrevrange.
    `Single<Response>` | `rxZrevrangebylex(List<String> args)` Redis command zrevrangebylex.
    `Single<Response>` | `rxZrevrangebyscore(List<String> args)` Redis command zrevrangebyscore.
    `Single<Response>` | `rxZrevrank(String arg0, String arg1)` Redis command zrevrank.
    `Single<Response>` | `rxZscan(List<String> args)` Redis command zscan.
    `Single<Response>` | `rxZscore(String arg0, String arg1)` Redis command zscore.
    `Single<Response>` | `rxZunionstore(List<String> args)` Redis command zunionstore.
    `RedisAPI` | `sadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sadd.
    `Observable<Response>` | `saddObservable(List<String> args)` Deprecated. use `rxSadd(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `save(Handler<AsyncResult<Response>> handler)` Redis command save.
    `Observable<Response>` | `saveObservable()` Deprecated. use `rxSave()` instead
    `RedisAPI` | `scan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command scan.
    `Observable<Response>` | `scanObservable(List<String> args)` Deprecated. use `rxScan(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `scard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command scard.
    `Observable<Response>` | `scardObservable(String arg0)` Deprecated. use `rxScard(java.lang.String)` instead
    `RedisAPI` | `script(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command script.
    `Observable<Response>` | `scriptObservable(List<String> args)` Deprecated. use `rxScript(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `sdiff(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sdiff.
    `Observable<Response>` | `sdiffObservable(List<String> args)` Deprecated. use `rxSdiff(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `sdiffstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sdiffstore.
    `Observable<Response>` | `sdiffstoreObservable(List<String> args)` Deprecated. use `rxSdiffstore(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `select(String arg0, Handler<AsyncResult<Response>> handler)` Redis command select.
    `Observable<Response>` | `selectObservable(String arg0)` Deprecated. use `rxSelect(java.lang.String)` instead
    `RedisAPI` | `set(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command set.
    `RedisAPI` | `setbit(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setbit.
    `Observable<Response>` | `setbitObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxSetbit(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `setex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setex.
    `Observable<Response>` | `setexObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxSetex(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `setnx(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command setnx.
    `Observable<Response>` | `setnxObservable(String arg0, String arg1)` Deprecated. use `rxSetnx(java.lang.String, java.lang.String)` instead
    `Observable<Response>` | `setObservable(List<String> args)` Deprecated. use `rxSet(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `setrange(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command setrange.
    `Observable<Response>` | `setrangeObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxSetrange(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `shutdown(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command shutdown.
    `Observable<Response>` | `shutdownObservable(List<String> args)` Deprecated. use `rxShutdown(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `sinter(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sinter.
    `Observable<Response>` | `sinterObservable(List<String> args)` Deprecated. use `rxSinter(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `sinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sinterstore.
    `Observable<Response>` | `sinterstoreObservable(List<String> args)` Deprecated. use `rxSinterstore(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `sismember(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command sismember.
    `Observable<Response>` | `sismemberObservable(String arg0, String arg1)` Deprecated. use `rxSismember(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `slaveof(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command slaveof.
    `Observable<Response>` | `slaveofObservable(String arg0, String arg1)` Deprecated. use `rxSlaveof(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `slowlog(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command slowlog.
    `Observable<Response>` | `slowlogObservable(List<String> args)` Deprecated. use `rxSlowlog(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `smembers(String arg0, Handler<AsyncResult<Response>> handler)` Redis command smembers.
    `Observable<Response>` | `smembersObservable(String arg0)` Deprecated. use `rxSmembers(java.lang.String)` instead
    `RedisAPI` | `smove(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command smove.
    `Observable<Response>` | `smoveObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxSmove(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `sort(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sort.
    `Observable<Response>` | `sortObservable(List<String> args)` Deprecated. use `rxSort(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `spop(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command spop.
    `Observable<Response>` | `spopObservable(List<String> args)` Deprecated. use `rxSpop(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `srandmember(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command srandmember.
    `Observable<Response>` | `srandmemberObservable(List<String> args)` Deprecated. use `rxSrandmember(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `srem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command srem.
    `Observable<Response>` | `sremObservable(List<String> args)` Deprecated. use `rxSrem(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `sscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sscan.
    `Observable<Response>` | `sscanObservable(List<String> args)` Deprecated. use `rxSscan(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `strlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command strlen.
    `Observable<Response>` | `strlenObservable(String arg0)` Deprecated. use `rxStrlen(java.lang.String)` instead
    `RedisAPI` | `subscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command subscribe.
    `Observable<Response>` | `subscribeObservable(List<String> args)` Deprecated. use `rxSubscribe(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `substr(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command substr.
    `Observable<Response>` | `substrObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxSubstr(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `sunion(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sunion.
    `Observable<Response>` | `sunionObservable(List<String> args)` Deprecated. use `rxSunion(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `sunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command sunionstore.
    `Observable<Response>` | `sunionstoreObservable(List<String> args)` Deprecated. use `rxSunionstore(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `swapdb(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command swapdb.
    `Observable<Response>` | `swapdbObservable(String arg0, String arg1)` Deprecated. use `rxSwapdb(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `sync(Handler<AsyncResult<Response>> handler)` Redis command sync.
    `Observable<Response>` | `syncObservable()` Deprecated. use `rxSync()` instead
    `RedisAPI` | `time(Handler<AsyncResult<Response>> handler)` Redis command time.
    `Observable<Response>` | `timeObservable()` Deprecated. use `rxTime()` instead
    `String` | `toString()`
    `RedisAPI` | `touch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command touch.
    `Observable<Response>` | `touchObservable(List<String> args)` Deprecated. use `rxTouch(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `ttl(String arg0, Handler<AsyncResult<Response>> handler)` Redis command ttl.
    `Observable<Response>` | `ttlObservable(String arg0)` Deprecated. use `rxTtl(java.lang.String)` instead
    `RedisAPI` | `type(String arg0, Handler<AsyncResult<Response>> handler)` Redis command type.
    `Observable<Response>` | `typeObservable(String arg0)` Deprecated. use `rxType(java.lang.String)` instead
    `RedisAPI` | `unlink(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command unlink.
    `Observable<Response>` | `unlinkObservable(List<String> args)` Deprecated. use `rxUnlink(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `unsubscribe(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command unsubscribe.
    `Observable<Response>` | `unsubscribeObservable(List<String> args)` Deprecated. use `rxUnsubscribe(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `unwatch(Handler<AsyncResult<Response>> handler)` Redis command unwatch.
    `Observable<Response>` | `unwatchObservable()` Deprecated. use `rxUnwatch()` instead
    `RedisAPI` | `wait(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command wait.
    `Observable<Response>` | `waitObservable(String arg0, String arg1)` Deprecated. use `rxWait(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `watch(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command watch.
    `Observable<Response>` | `watchObservable(List<String> args)` Deprecated. use `rxWatch(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `xack(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xack.
    `Observable<Response>` | `xackObservable(List<String> args)` Deprecated. use `rxXack(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `xadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xadd.
    `Observable<Response>` | `xaddObservable(List<String> args)` Deprecated. use `rxXadd(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `xclaim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xclaim.
    `Observable<Response>` | `xclaimObservable(List<String> args)` Deprecated. use `rxXclaim(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `xdel(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xdel.
    `Observable<Response>` | `xdelObservable(List<String> args)` Deprecated. use `rxXdel(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `xgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xgroup.
    `Observable<Response>` | `xgroupObservable(List<String> args)` Deprecated. use `rxXgroup(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `xinfo(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xinfo.
    `Observable<Response>` | `xinfoObservable(List<String> args)` Deprecated. use `rxXinfo(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `xlen(String arg0, Handler<AsyncResult<Response>> handler)` Redis command xlen.
    `Observable<Response>` | `xlenObservable(String arg0)` Deprecated. use `rxXlen(java.lang.String)` instead
    `RedisAPI` | `xpending(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xpending.
    `Observable<Response>` | `xpendingObservable(List<String> args)` Deprecated. use `rxXpending(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `xrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xrange.
    `Observable<Response>` | `xrangeObservable(List<String> args)` Deprecated. use `rxXrange(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `xread(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xread.
    `RedisAPI` | `xreadgroup(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xreadgroup.
    `Observable<Response>` | `xreadgroupObservable(List<String> args)` Deprecated. use `rxXreadgroup(java.util.List<java.lang.String>)` instead
    `Observable<Response>` | `xreadObservable(List<String> args)` Deprecated. use `rxXread(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `xrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xrevrange.
    `Observable<Response>` | `xrevrangeObservable(List<String> args)` Deprecated. use `rxXrevrange(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `xsetid(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command xsetid.
    `Observable<Response>` | `xsetidObservable(String arg0, String arg1)` Deprecated. use `rxXsetid(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `xtrim(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command xtrim.
    `Observable<Response>` | `xtrimObservable(List<String> args)` Deprecated. use `rxXtrim(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `zadd(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zadd.
    `Observable<Response>` | `zaddObservable(List<String> args)` Deprecated. use `rxZadd(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `zcard(String arg0, Handler<AsyncResult<Response>> handler)` Redis command zcard.
    `Observable<Response>` | `zcardObservable(String arg0)` Deprecated. use `rxZcard(java.lang.String)` instead
    `RedisAPI` | `zcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zcount.
    `Observable<Response>` | `zcountObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxZcount(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `zincrby(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zincrby.
    `Observable<Response>` | `zincrbyObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxZincrby(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `zinterstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zinterstore.
    `Observable<Response>` | `zinterstoreObservable(List<String> args)` Deprecated. use `rxZinterstore(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `zlexcount(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zlexcount.
    `Observable<Response>` | `zlexcountObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxZlexcount(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `zpopmax(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zpopmax.
    `Observable<Response>` | `zpopmaxObservable(List<String> args)` Deprecated. use `rxZpopmax(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `zpopmin(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zpopmin.
    `Observable<Response>` | `zpopminObservable(List<String> args)` Deprecated. use `rxZpopmin(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `zrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrange.
    `RedisAPI` | `zrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrangebylex.
    `Observable<Response>` | `zrangebylexObservable(List<String> args)` Deprecated. use `rxZrangebylex(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `zrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrangebyscore.
    `Observable<Response>` | `zrangebyscoreObservable(List<String> args)` Deprecated. use `rxZrangebyscore(java.util.List<java.lang.String>)` instead
    `Observable<Response>` | `zrangeObservable(List<String> args)` Deprecated. use `rxZrange(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `zrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zrank.
    `Observable<Response>` | `zrankObservable(String arg0, String arg1)` Deprecated. use `rxZrank(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `zrem(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrem.
    `Observable<Response>` | `zremObservable(List<String> args)` Deprecated. use `rxZrem(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `zremrangebylex(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebylex.
    `Observable<Response>` | `zremrangebylexObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxZremrangebylex(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `zremrangebyrank(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebyrank.
    `Observable<Response>` | `zremrangebyrankObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxZremrangebyrank(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `zremrangebyscore(String arg0, String arg1, String arg2, Handler<AsyncResult<Response>> handler)` Redis command zremrangebyscore.
    `Observable<Response>` | `zremrangebyscoreObservable(String arg0, String arg1, String arg2)` Deprecated. use `rxZremrangebyscore(java.lang.String, java.lang.String, java.lang.String)` instead
    `RedisAPI` | `zrevrange(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrange.
    `RedisAPI` | `zrevrangebylex(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrangebylex.
    `Observable<Response>` | `zrevrangebylexObservable(List<String> args)` Deprecated. use `rxZrevrangebylex(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `zrevrangebyscore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zrevrangebyscore.
    `Observable<Response>` | `zrevrangebyscoreObservable(List<String> args)` Deprecated. use `rxZrevrangebyscore(java.util.List<java.lang.String>)` instead
    `Observable<Response>` | `zrevrangeObservable(List<String> args)` Deprecated. use `rxZrevrange(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `zrevrank(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zrevrank.
    `Observable<Response>` | `zrevrankObservable(String arg0, String arg1)` Deprecated. use `rxZrevrank(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `zscan(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zscan.
    `Observable<Response>` | `zscanObservable(List<String> args)` Deprecated. use `rxZscan(java.util.List<java.lang.String>)` instead
    `RedisAPI` | `zscore(String arg0, String arg1, Handler<AsyncResult<Response>> handler)` Redis command zscore.
    `Observable<Response>` | `zscoreObservable(String arg0, String arg1)` Deprecated. use `rxZscore(java.lang.String, java.lang.String)` instead
    `RedisAPI` | `zunionstore(List<String> args, Handler<AsyncResult<Response>> handler)` Redis command zunionstore.
    `Observable<Response>` | `zunionstoreObservable(List<String> args)` Deprecated. use `rxZunionstore(java.util.List<java.lang.String>)` instead

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

    - #### append

          public RedisAPI append(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Redis command append.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### appendObservable

          @Deprecated
          public Observable<Response> appendObservable(String arg0,
                                                                   String arg1)

      Deprecated. use `rxAppend(java.lang.String, java.lang.String)` instead
      Redis command append.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxAppend

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

      Redis command append.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### asking

          public RedisAPI asking(Handler<AsyncResult<Response>> handler)

      Redis command asking.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### askingObservable

          @Deprecated
          public Observable<Response> askingObservable()

      Deprecated. use `rxAsking()` instead
      Redis command asking.
      Returns:
        fluent self

    - #### rxAsking

          public Single<Response> rxAsking()

      Redis command asking.
      Returns:
        fluent self

    - #### auth

          public RedisAPI auth(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command auth.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### authObservable

          @Deprecated
          public Observable<Response> authObservable(String arg0)

      Deprecated. use `rxAuth(java.lang.String)` instead
      Redis command auth.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxAuth

          public Single<Response> rxAuth(String arg0)

      Redis command auth.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### bgrewriteaof

          public RedisAPI bgrewriteaof(Handler<AsyncResult<Response>> handler)

      Redis command bgrewriteaof.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### bgrewriteaofObservable

          @Deprecated
          public Observable<Response> bgrewriteaofObservable()

      Deprecated. use `rxBgrewriteaof()` instead
      Redis command bgrewriteaof.
      Returns:
        fluent self

    - #### rxBgrewriteaof

          public Single<Response> rxBgrewriteaof()

      Redis command bgrewriteaof.
      Returns:
        fluent self

    - #### bgsave

          public RedisAPI bgsave(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command bgsave.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bgsaveObservable

          @Deprecated
          public Observable<Response> bgsaveObservable(List<String> args)

      Deprecated. use `rxBgsave(java.util.List<java.lang.String>)` instead
      Redis command bgsave.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBgsave

          public Single<Response> rxBgsave(List<String> args)

      Redis command bgsave.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitcount

          public RedisAPI bitcount(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command bitcount.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bitcountObservable

          @Deprecated
          public Observable<Response> bitcountObservable(List<String> args)

      Deprecated. use `rxBitcount(java.util.List<java.lang.String>)` instead
      Redis command bitcount.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitcount

          public Single<Response> rxBitcount(List<String> args)

      Redis command bitcount.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitfield

          public RedisAPI bitfield(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command bitfield.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bitfieldObservable

          @Deprecated
          public Observable<Response> bitfieldObservable(List<String> args)

      Deprecated. use `rxBitfield(java.util.List<java.lang.String>)` instead
      Redis command bitfield.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitfield

          public Single<Response> rxBitfield(List<String> args)

      Redis command bitfield.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitop

          public RedisAPI bitop(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command bitop.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bitopObservable

          @Deprecated
          public Observable<Response> bitopObservable(List<String> args)

      Deprecated. use `rxBitop(java.util.List<java.lang.String>)` instead
      Redis command bitop.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitop

          public Single<Response> rxBitop(List<String> args)

      Redis command bitop.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bitpos

          public RedisAPI bitpos(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command bitpos.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bitposObservable

          @Deprecated
          public Observable<Response> bitposObservable(List<String> args)

      Deprecated. use `rxBitpos(java.util.List<java.lang.String>)` instead
      Redis command bitpos.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBitpos

          public Single<Response> rxBitpos(List<String> args)

      Redis command bitpos.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### blpop

          public RedisAPI blpop(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command blpop.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### blpopObservable

          @Deprecated
          public Observable<Response> blpopObservable(List<String> args)

      Deprecated. use `rxBlpop(java.util.List<java.lang.String>)` instead
      Redis command blpop.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBlpop

          public Single<Response> rxBlpop(List<String> args)

      Redis command blpop.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### brpop

          public RedisAPI brpop(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command brpop.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### brpopObservable

          @Deprecated
          public Observable<Response> brpopObservable(List<String> args)

      Deprecated. use `rxBrpop(java.util.List<java.lang.String>)` instead
      Redis command brpop.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBrpop

          public Single<Response> rxBrpop(List<String> args)

      Redis command brpop.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### brpoplpush

          public RedisAPI brpoplpush(String arg0,
                                     String arg1,
                                     String arg2,
                                     Handler<AsyncResult<Response>> handler)

      Redis command brpoplpush.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### brpoplpushObservable

          @Deprecated
          public Observable<Response> brpoplpushObservable(String arg0,
                                                                       String arg1,
                                                                       String arg2)

      Deprecated. use `rxBrpoplpush(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command brpoplpush.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxBrpoplpush

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

      Redis command brpoplpush.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### bzpopmax

          public RedisAPI bzpopmax(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command bzpopmax.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bzpopmaxObservable

          @Deprecated
          public Observable<Response> bzpopmaxObservable(List<String> args)

      Deprecated. use `rxBzpopmax(java.util.List<java.lang.String>)` instead
      Redis command bzpopmax.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBzpopmax

          public Single<Response> rxBzpopmax(List<String> args)

      Redis command bzpopmax.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### bzpopmin

          public RedisAPI bzpopmin(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command bzpopmin.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### bzpopminObservable

          @Deprecated
          public Observable<Response> bzpopminObservable(List<String> args)

      Deprecated. use `rxBzpopmin(java.util.List<java.lang.String>)` instead
      Redis command bzpopmin.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxBzpopmin

          public Single<Response> rxBzpopmin(List<String> args)

      Redis command bzpopmin.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### client

          public RedisAPI client(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command client.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### clientObservable

          @Deprecated
          public Observable<Response> clientObservable(List<String> args)

      Deprecated. use `rxClient(java.util.List<java.lang.String>)` instead
      Redis command client.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxClient

          public Single<Response> rxClient(List<String> args)

      Redis command client.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### cluster

          public RedisAPI cluster(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command cluster.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### clusterObservable

          @Deprecated
          public Observable<Response> clusterObservable(List<String> args)

      Deprecated. use `rxCluster(java.util.List<java.lang.String>)` instead
      Redis command cluster.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxCluster

          public Single<Response> rxCluster(List<String> args)

      Redis command cluster.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### command

          public RedisAPI command(Handler<AsyncResult<Response>> handler)

      Redis command command.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### commandObservable

          @Deprecated
          public Observable<Response> commandObservable()

      Deprecated. use `rxCommand()` instead
      Redis command command.
      Returns:
        fluent self

    - #### rxCommand

          public Single<Response> rxCommand()

      Redis command command.
      Returns:
        fluent self

    - #### config

          public RedisAPI config(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command config.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### configObservable

          @Deprecated
          public Observable<Response> configObservable(List<String> args)

      Deprecated. use `rxConfig(java.util.List<java.lang.String>)` instead
      Redis command config.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxConfig

          public Single<Response> rxConfig(List<String> args)

      Redis command config.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### dbsize

          public RedisAPI dbsize(Handler<AsyncResult<Response>> handler)

      Redis command dbsize.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### dbsizeObservable

          @Deprecated
          public Observable<Response> dbsizeObservable()

      Deprecated. use `rxDbsize()` instead
      Redis command dbsize.
      Returns:
        fluent self

    - #### rxDbsize

          public Single<Response> rxDbsize()

      Redis command dbsize.
      Returns:
        fluent self

    - #### debug

          public RedisAPI debug(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command debug.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### debugObservable

          @Deprecated
          public Observable<Response> debugObservable(List<String> args)

      Deprecated. use `rxDebug(java.util.List<java.lang.String>)` instead
      Redis command debug.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxDebug

          public Single<Response> rxDebug(List<String> args)

      Redis command debug.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### decr

          public RedisAPI decr(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command decr.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### decrObservable

          @Deprecated
          public Observable<Response> decrObservable(String arg0)

      Deprecated. use `rxDecr(java.lang.String)` instead
      Redis command decr.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxDecr

          public Single<Response> rxDecr(String arg0)

      Redis command decr.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### decrby

          public RedisAPI decrby(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Redis command decrby.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### decrbyObservable

          @Deprecated
          public Observable<Response> decrbyObservable(String arg0,
                                                                   String arg1)

      Deprecated. use `rxDecrby(java.lang.String, java.lang.String)` instead
      Redis command decrby.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxDecrby

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

      Redis command decrby.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### del

          public RedisAPI del(List<String> args,
                              Handler<AsyncResult<Response>> handler)

      Redis command del.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### delObservable

          @Deprecated
          public Observable<Response> delObservable(List<String> args)

      Deprecated. use `rxDel(java.util.List<java.lang.String>)` instead
      Redis command del.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxDel

          public Single<Response> rxDel(List<String> args)

      Redis command del.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### discard

          public RedisAPI discard(Handler<AsyncResult<Response>> handler)

      Redis command discard.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### discardObservable

          @Deprecated
          public Observable<Response> discardObservable()

      Deprecated. use `rxDiscard()` instead
      Redis command discard.
      Returns:
        fluent self

    - #### rxDiscard

          public Single<Response> rxDiscard()

      Redis command discard.
      Returns:
        fluent self

    - #### dump

          public RedisAPI dump(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command dump.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### dumpObservable

          @Deprecated
          public Observable<Response> dumpObservable(String arg0)

      Deprecated. use `rxDump(java.lang.String)` instead
      Redis command dump.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxDump

          public Single<Response> rxDump(String arg0)

      Redis command dump.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### echo

          public RedisAPI echo(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command echo.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### echoObservable

          @Deprecated
          public Observable<Response> echoObservable(String arg0)

      Deprecated. use `rxEcho(java.lang.String)` instead
      Redis command echo.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxEcho

          public Single<Response> rxEcho(String arg0)

      Redis command echo.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### eval

          public RedisAPI eval(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command eval.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### evalObservable

          @Deprecated
          public Observable<Response> evalObservable(List<String> args)

      Deprecated. use `rxEval(java.util.List<java.lang.String>)` instead
      Redis command eval.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxEval

          public Single<Response> rxEval(List<String> args)

      Redis command eval.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### evalsha

          public RedisAPI evalsha(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command evalsha.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### evalshaObservable

          @Deprecated
          public Observable<Response> evalshaObservable(List<String> args)

      Deprecated. use `rxEvalsha(java.util.List<java.lang.String>)` instead
      Redis command evalsha.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxEvalsha

          public Single<Response> rxEvalsha(List<String> args)

      Redis command evalsha.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### exec

          public RedisAPI exec(Handler<AsyncResult<Response>> handler)

      Redis command exec.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### execObservable

          @Deprecated
          public Observable<Response> execObservable()

      Deprecated. use `rxExec()` instead
      Redis command exec.
      Returns:
        fluent self

    - #### rxExec

          public Single<Response> rxExec()

      Redis command exec.
      Returns:
        fluent self

    - #### exists

          public RedisAPI exists(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command exists.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### existsObservable

          @Deprecated
          public Observable<Response> existsObservable(List<String> args)

      Deprecated. use `rxExists(java.util.List<java.lang.String>)` instead
      Redis command exists.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxExists

          public Single<Response> rxExists(List<String> args)

      Redis command exists.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### expire

          public RedisAPI expire(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Redis command expire.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### expireObservable

          @Deprecated
          public Observable<Response> expireObservable(String arg0,
                                                                   String arg1)

      Deprecated. use `rxExpire(java.lang.String, java.lang.String)` instead
      Redis command expire.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxExpire

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

      Redis command expire.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### expireat

          public RedisAPI expireat(String arg0,
                                   String arg1,
                                   Handler<AsyncResult<Response>> handler)

      Redis command expireat.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### expireatObservable

          @Deprecated
          public Observable<Response> expireatObservable(String arg0,
                                                                     String arg1)

      Deprecated. use `rxExpireat(java.lang.String, java.lang.String)` instead
      Redis command expireat.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxExpireat

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

      Redis command expireat.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### flushall

          public RedisAPI flushall(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command flushall.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### flushallObservable

          @Deprecated
          public Observable<Response> flushallObservable(List<String> args)

      Deprecated. use `rxFlushall(java.util.List<java.lang.String>)` instead
      Redis command flushall.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFlushall

          public Single<Response> rxFlushall(List<String> args)

      Redis command flushall.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### flushdb

          public RedisAPI flushdb(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command flushdb.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### flushdbObservable

          @Deprecated
          public Observable<Response> flushdbObservable(List<String> args)

      Deprecated. use `rxFlushdb(java.util.List<java.lang.String>)` instead
      Redis command flushdb.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxFlushdb

          public Single<Response> rxFlushdb(List<String> args)

      Redis command flushdb.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geoadd

          public RedisAPI geoadd(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command geoadd.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### geoaddObservable

          @Deprecated
          public Observable<Response> geoaddObservable(List<String> args)

      Deprecated. use `rxGeoadd(java.util.List<java.lang.String>)` instead
      Redis command geoadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoadd

          public Single<Response> rxGeoadd(List<String> args)

      Redis command geoadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geodist

          public RedisAPI geodist(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command geodist.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### geodistObservable

          @Deprecated
          public Observable<Response> geodistObservable(List<String> args)

      Deprecated. use `rxGeodist(java.util.List<java.lang.String>)` instead
      Redis command geodist.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeodist

          public Single<Response> rxGeodist(List<String> args)

      Redis command geodist.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geohash

          public RedisAPI geohash(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command geohash.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### geohashObservable

          @Deprecated
          public Observable<Response> geohashObservable(List<String> args)

      Deprecated. use `rxGeohash(java.util.List<java.lang.String>)` instead
      Redis command geohash.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeohash

          public Single<Response> rxGeohash(List<String> args)

      Redis command geohash.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### geopos

          public RedisAPI geopos(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command geopos.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### geoposObservable

          @Deprecated
          public Observable<Response> geoposObservable(List<String> args)

      Deprecated. use `rxGeopos(java.util.List<java.lang.String>)` instead
      Redis command geopos.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeopos

          public Single<Response> rxGeopos(List<String> args)

      Redis command geopos.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadius

          public RedisAPI georadius(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command georadius.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### georadiusObservable

          @Deprecated
          public Observable<Response> georadiusObservable(List<String> args)

      Deprecated. use `rxGeoradius(java.util.List<java.lang.String>)` instead
      Redis command georadius.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradius

          public Single<Response> rxGeoradius(List<String> args)

      Redis command georadius.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadiusRo

          public RedisAPI georadiusRo(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command georadiusRo.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### georadiusRoObservable

          @Deprecated
          public Observable<Response> georadiusRoObservable(List<String> args)

      Deprecated. use `rxGeoradiusRo(java.util.List<java.lang.String>)` instead
      Redis command georadiusRo.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradiusRo

          public Single<Response> rxGeoradiusRo(List<String> args)

      Redis command georadiusRo.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadiusbymember

          public RedisAPI georadiusbymember(List<String> args,
                                            Handler<AsyncResult<Response>> handler)

      Redis command georadiusbymember.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### georadiusbymemberObservable

          @Deprecated
          public Observable<Response> georadiusbymemberObservable(List<String> args)

      Deprecated. use `rxGeoradiusbymember(java.util.List<java.lang.String>)` instead
      Redis command georadiusbymember.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradiusbymember

          public Single<Response> rxGeoradiusbymember(List<String> args)

      Redis command georadiusbymember.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### georadiusbymemberRo

          public RedisAPI georadiusbymemberRo(List<String> args,
                                              Handler<AsyncResult<Response>> handler)

      Redis command georadiusbymemberRo.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### georadiusbymemberRoObservable

          @Deprecated
          public Observable<Response> georadiusbymemberRoObservable(List<String> args)

      Deprecated. use `rxGeoradiusbymemberRo(java.util.List<java.lang.String>)` instead
      Redis command georadiusbymemberRo.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxGeoradiusbymemberRo

          public Single<Response> rxGeoradiusbymemberRo(List<String> args)

      Redis command georadiusbymemberRo.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### get

          public RedisAPI get(String arg0,
                              Handler<AsyncResult<Response>> handler)

      Redis command get.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### getObservable

          @Deprecated
          public Observable<Response> getObservable(String arg0)

      Deprecated. use `rxGet(java.lang.String)` instead
      Redis command get.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxGet

          public Single<Response> rxGet(String arg0)

      Redis command get.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### getbit

          public RedisAPI getbit(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Redis command getbit.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### getbitObservable

          @Deprecated
          public Observable<Response> getbitObservable(String arg0,
                                                                   String arg1)

      Deprecated. use `rxGetbit(java.lang.String, java.lang.String)` instead
      Redis command getbit.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxGetbit

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

      Redis command getbit.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### getrange

          public RedisAPI getrange(String arg0,
                                   String arg1,
                                   String arg2,
                                   Handler<AsyncResult<Response>> handler)

      Redis command getrange.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### getrangeObservable

          @Deprecated
          public Observable<Response> getrangeObservable(String arg0,
                                                                     String arg1,
                                                                     String arg2)

      Deprecated. use `rxGetrange(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command getrange.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxGetrange

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

      Redis command getrange.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### getset

          public RedisAPI getset(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Redis command getset.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### getsetObservable

          @Deprecated
          public Observable<Response> getsetObservable(String arg0,
                                                                   String arg1)

      Deprecated. use `rxGetset(java.lang.String, java.lang.String)` instead
      Redis command getset.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxGetset

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

      Redis command getset.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### hdel

          public RedisAPI hdel(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command hdel.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hdelObservable

          @Deprecated
          public Observable<Response> hdelObservable(List<String> args)

      Deprecated. use `rxHdel(java.util.List<java.lang.String>)` instead
      Redis command hdel.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHdel

          public Single<Response> rxHdel(List<String> args)

      Redis command hdel.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hexists

          public RedisAPI hexists(String arg0,
                                  String arg1,
                                  Handler<AsyncResult<Response>> handler)

      Redis command hexists.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### hexistsObservable

          @Deprecated
          public Observable<Response> hexistsObservable(String arg0,
                                                                    String arg1)

      Deprecated. use `rxHexists(java.lang.String, java.lang.String)` instead
      Redis command hexists.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxHexists

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

      Redis command hexists.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### hget

          public RedisAPI hget(String arg0,
                               String arg1,
                               Handler<AsyncResult<Response>> handler)

      Redis command hget.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### hgetObservable

          @Deprecated
          public Observable<Response> hgetObservable(String arg0,
                                                                 String arg1)

      Deprecated. use `rxHget(java.lang.String, java.lang.String)` instead
      Redis command hget.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxHget

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

      Redis command hget.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### hgetall

          public RedisAPI hgetall(String arg0,
                                  Handler<AsyncResult<Response>> handler)

      Redis command hgetall.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hgetallObservable

          @Deprecated
          public Observable<Response> hgetallObservable(String arg0)

      Deprecated. use `rxHgetall(java.lang.String)` instead
      Redis command hgetall.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHgetall

          public Single<Response> rxHgetall(String arg0)

      Redis command hgetall.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### hincrby

          public RedisAPI hincrby(String arg0,
                                  String arg1,
                                  String arg2,
                                  Handler<AsyncResult<Response>> handler)

      Redis command hincrby.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### hincrbyObservable

          @Deprecated
          public Observable<Response> hincrbyObservable(String arg0,
                                                                    String arg1,
                                                                    String arg2)

      Deprecated. use `rxHincrby(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command hincrby.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxHincrby

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

      Redis command hincrby.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### hincrbyfloat

          public RedisAPI hincrbyfloat(String arg0,
                                       String arg1,
                                       String arg2,
                                       Handler<AsyncResult<Response>> handler)

      Redis command hincrbyfloat.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### hincrbyfloatObservable

          @Deprecated
          public Observable<Response> hincrbyfloatObservable(String arg0,
                                                                         String arg1,
                                                                         String arg2)

      Deprecated. use `rxHincrbyfloat(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command hincrbyfloat.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxHincrbyfloat

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

      Redis command hincrbyfloat.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### hkeys

          public RedisAPI hkeys(String arg0,
                                Handler<AsyncResult<Response>> handler)

      Redis command hkeys.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hkeysObservable

          @Deprecated
          public Observable<Response> hkeysObservable(String arg0)

      Deprecated. use `rxHkeys(java.lang.String)` instead
      Redis command hkeys.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHkeys

          public Single<Response> rxHkeys(String arg0)

      Redis command hkeys.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### hlen

          public RedisAPI hlen(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command hlen.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hlenObservable

          @Deprecated
          public Observable<Response> hlenObservable(String arg0)

      Deprecated. use `rxHlen(java.lang.String)` instead
      Redis command hlen.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHlen

          public Single<Response> rxHlen(String arg0)

      Redis command hlen.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### hmget

          public RedisAPI hmget(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command hmget.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hmgetObservable

          @Deprecated
          public Observable<Response> hmgetObservable(List<String> args)

      Deprecated. use `rxHmget(java.util.List<java.lang.String>)` instead
      Redis command hmget.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHmget

          public Single<Response> rxHmget(List<String> args)

      Redis command hmget.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hmset

          public RedisAPI hmset(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command hmset.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hmsetObservable

          @Deprecated
          public Observable<Response> hmsetObservable(List<String> args)

      Deprecated. use `rxHmset(java.util.List<java.lang.String>)` instead
      Redis command hmset.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHmset

          public Single<Response> rxHmset(List<String> args)

      Redis command hmset.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### host

          public RedisAPI host(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command host.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hostObservable

          @Deprecated
          public Observable<Response> hostObservable(List<String> args)

      Deprecated. use `rxHost(java.util.List<java.lang.String>)` instead
      Redis command host.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHost

          public Single<Response> rxHost(List<String> args)

      Redis command host.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hscan

          public RedisAPI hscan(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command hscan.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hscanObservable

          @Deprecated
          public Observable<Response> hscanObservable(List<String> args)

      Deprecated. use `rxHscan(java.util.List<java.lang.String>)` instead
      Redis command hscan.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHscan

          public Single<Response> rxHscan(List<String> args)

      Redis command hscan.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hset

          public RedisAPI hset(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command hset.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### hsetObservable

          @Deprecated
          public Observable<Response> hsetObservable(List<String> args)

      Deprecated. use `rxHset(java.util.List<java.lang.String>)` instead
      Redis command hset.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxHset

          public Single<Response> rxHset(List<String> args)

      Redis command hset.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### hsetnx

          public RedisAPI hsetnx(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

      Redis command hsetnx.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### hsetnxObservable

          @Deprecated
          public Observable<Response> hsetnxObservable(String arg0,
                                                                   String arg1,
                                                                   String arg2)

      Deprecated. use `rxHsetnx(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command hsetnx.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxHsetnx

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

      Redis command hsetnx.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### hstrlen

          public RedisAPI hstrlen(String arg0,
                                  String arg1,
                                  Handler<AsyncResult<Response>> handler)

      Redis command hstrlen.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### hstrlenObservable

          @Deprecated
          public Observable<Response> hstrlenObservable(String arg0,
                                                                    String arg1)

      Deprecated. use `rxHstrlen(java.lang.String, java.lang.String)` instead
      Redis command hstrlen.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxHstrlen

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

      Redis command hstrlen.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### hvals

          public RedisAPI hvals(String arg0,
                                Handler<AsyncResult<Response>> handler)

      Redis command hvals.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### hvalsObservable

          @Deprecated
          public Observable<Response> hvalsObservable(String arg0)

      Deprecated. use `rxHvals(java.lang.String)` instead
      Redis command hvals.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxHvals

          public Single<Response> rxHvals(String arg0)

      Redis command hvals.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### incr

          public RedisAPI incr(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command incr.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### incrObservable

          @Deprecated
          public Observable<Response> incrObservable(String arg0)

      Deprecated. use `rxIncr(java.lang.String)` instead
      Redis command incr.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxIncr

          public Single<Response> rxIncr(String arg0)

      Redis command incr.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### incrby

          public RedisAPI incrby(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Redis command incrby.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### incrbyObservable

          @Deprecated
          public Observable<Response> incrbyObservable(String arg0,
                                                                   String arg1)

      Deprecated. use `rxIncrby(java.lang.String, java.lang.String)` instead
      Redis command incrby.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxIncrby

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

      Redis command incrby.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### incrbyfloat

          public RedisAPI incrbyfloat(String arg0,
                                      String arg1,
                                      Handler<AsyncResult<Response>> handler)

      Redis command incrbyfloat.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### incrbyfloatObservable

          @Deprecated
          public Observable<Response> incrbyfloatObservable(String arg0,
                                                                        String arg1)

      Deprecated. use `rxIncrbyfloat(java.lang.String, java.lang.String)` instead
      Redis command incrbyfloat.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxIncrbyfloat

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

      Redis command incrbyfloat.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### info

          public RedisAPI info(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command info.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### infoObservable

          @Deprecated
          public Observable<Response> infoObservable(List<String> args)

      Deprecated. use `rxInfo(java.util.List<java.lang.String>)` instead
      Redis command info.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxInfo

          public Single<Response> rxInfo(List<String> args)

      Redis command info.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### keys

          public RedisAPI keys(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command keys.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### keysObservable

          @Deprecated
          public Observable<Response> keysObservable(String arg0)

      Deprecated. use `rxKeys(java.lang.String)` instead
      Redis command keys.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxKeys

          public Single<Response> rxKeys(String arg0)

      Redis command keys.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### lastsave

          public RedisAPI lastsave(Handler<AsyncResult<Response>> handler)

      Redis command lastsave.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### lastsaveObservable

          @Deprecated
          public Observable<Response> lastsaveObservable()

      Deprecated. use `rxLastsave()` instead
      Redis command lastsave.
      Returns:
        fluent self

    - #### rxLastsave

          public Single<Response> rxLastsave()

      Redis command lastsave.
      Returns:
        fluent self

    - #### latency

          public RedisAPI latency(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command latency.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### latencyObservable

          @Deprecated
          public Observable<Response> latencyObservable(List<String> args)

      Deprecated. use `rxLatency(java.util.List<java.lang.String>)` instead
      Redis command latency.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLatency

          public Single<Response> rxLatency(List<String> args)

      Redis command latency.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lindex

          public RedisAPI lindex(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Redis command lindex.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### lindexObservable

          @Deprecated
          public Observable<Response> lindexObservable(String arg0,
                                                                   String arg1)

      Deprecated. use `rxLindex(java.lang.String, java.lang.String)` instead
      Redis command lindex.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxLindex

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

      Redis command lindex.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### linsert

          public RedisAPI linsert(String arg0,
                                  String arg1,
                                  String arg2,
                                  String arg3,
                                  Handler<AsyncResult<Response>> handler)

      Redis command linsert.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
        `handler` -
      Returns:
        fluent self

    - #### linsertObservable

          @Deprecated
          public Observable<Response> linsertObservable(String arg0,
                                                                    String arg1,
                                                                    String arg2,
                                                                    String arg3)

      Deprecated. use `rxLinsert(java.lang.String, java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command linsert.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
      Returns:
        fluent self

    - #### rxLinsert

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

      Redis command linsert.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `arg3` -
      Returns:
        fluent self

    - #### llen

          public RedisAPI llen(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command llen.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### llenObservable

          @Deprecated
          public Observable<Response> llenObservable(String arg0)

      Deprecated. use `rxLlen(java.lang.String)` instead
      Redis command llen.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxLlen

          public Single<Response> rxLlen(String arg0)

      Redis command llen.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### lolwut

          public RedisAPI lolwut(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command lolwut.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### lolwutObservable

          @Deprecated
          public Observable<Response> lolwutObservable(List<String> args)

      Deprecated. use `rxLolwut(java.util.List<java.lang.String>)` instead
      Redis command lolwut.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLolwut

          public Single<Response> rxLolwut(List<String> args)

      Redis command lolwut.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lpop

          public RedisAPI lpop(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command lpop.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### lpopObservable

          @Deprecated
          public Observable<Response> lpopObservable(String arg0)

      Deprecated. use `rxLpop(java.lang.String)` instead
      Redis command lpop.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxLpop

          public Single<Response> rxLpop(String arg0)

      Redis command lpop.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### lpush

          public RedisAPI lpush(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command lpush.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### lpushObservable

          @Deprecated
          public Observable<Response> lpushObservable(List<String> args)

      Deprecated. use `rxLpush(java.util.List<java.lang.String>)` instead
      Redis command lpush.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLpush

          public Single<Response> rxLpush(List<String> args)

      Redis command lpush.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lpushx

          public RedisAPI lpushx(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command lpushx.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### lpushxObservable

          @Deprecated
          public Observable<Response> lpushxObservable(List<String> args)

      Deprecated. use `rxLpushx(java.util.List<java.lang.String>)` instead
      Redis command lpushx.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxLpushx

          public Single<Response> rxLpushx(List<String> args)

      Redis command lpushx.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### lrange

          public RedisAPI lrange(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

      Redis command lrange.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### lrangeObservable

          @Deprecated
          public Observable<Response> lrangeObservable(String arg0,
                                                                   String arg1,
                                                                   String arg2)

      Deprecated. use `rxLrange(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command lrange.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLrange

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

      Redis command lrange.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### lrem

          public RedisAPI lrem(String arg0,
                               String arg1,
                               String arg2,
                               Handler<AsyncResult<Response>> handler)

      Redis command lrem.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### lremObservable

          @Deprecated
          public Observable<Response> lremObservable(String arg0,
                                                                 String arg1,
                                                                 String arg2)

      Deprecated. use `rxLrem(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command lrem.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLrem

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

      Redis command lrem.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### lset

          public RedisAPI lset(String arg0,
                               String arg1,
                               String arg2,
                               Handler<AsyncResult<Response>> handler)

      Redis command lset.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### lsetObservable

          @Deprecated
          public Observable<Response> lsetObservable(String arg0,
                                                                 String arg1,
                                                                 String arg2)

      Deprecated. use `rxLset(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command lset.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLset

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

      Redis command lset.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### ltrim

          public RedisAPI ltrim(String arg0,
                                String arg1,
                                String arg2,
                                Handler<AsyncResult<Response>> handler)

      Redis command ltrim.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### ltrimObservable

          @Deprecated
          public Observable<Response> ltrimObservable(String arg0,
                                                                  String arg1,
                                                                  String arg2)

      Deprecated. use `rxLtrim(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command ltrim.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxLtrim

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

      Redis command ltrim.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### memory

          public RedisAPI memory(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command memory.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### memoryObservable

          @Deprecated
          public Observable<Response> memoryObservable(List<String> args)

      Deprecated. use `rxMemory(java.util.List<java.lang.String>)` instead
      Redis command memory.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMemory

          public Single<Response> rxMemory(List<String> args)

      Redis command memory.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### mget

          public RedisAPI mget(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command mget.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### mgetObservable

          @Deprecated
          public Observable<Response> mgetObservable(List<String> args)

      Deprecated. use `rxMget(java.util.List<java.lang.String>)` instead
      Redis command mget.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMget

          public Single<Response> rxMget(List<String> args)

      Redis command mget.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### migrate

          public RedisAPI migrate(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command migrate.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### migrateObservable

          @Deprecated
          public Observable<Response> migrateObservable(List<String> args)

      Deprecated. use `rxMigrate(java.util.List<java.lang.String>)` instead
      Redis command migrate.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMigrate

          public Single<Response> rxMigrate(List<String> args)

      Redis command migrate.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### module

          public RedisAPI module(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command module.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### moduleObservable

          @Deprecated
          public Observable<Response> moduleObservable(List<String> args)

      Deprecated. use `rxModule(java.util.List<java.lang.String>)` instead
      Redis command module.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxModule

          public Single<Response> rxModule(List<String> args)

      Redis command module.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### monitor

          public RedisAPI monitor(Handler<AsyncResult<Response>> handler)

      Redis command monitor.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### monitorObservable

          @Deprecated
          public Observable<Response> monitorObservable()

      Deprecated. use `rxMonitor()` instead
      Redis command monitor.
      Returns:
        fluent self

    - #### rxMonitor

          public Single<Response> rxMonitor()

      Redis command monitor.
      Returns:
        fluent self

    - #### move

          public RedisAPI move(String arg0,
                               String arg1,
                               Handler<AsyncResult<Response>> handler)

      Redis command move.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### moveObservable

          @Deprecated
          public Observable<Response> moveObservable(String arg0,
                                                                 String arg1)

      Deprecated. use `rxMove(java.lang.String, java.lang.String)` instead
      Redis command move.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxMove

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

      Redis command move.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### mset

          public RedisAPI mset(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command mset.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### msetObservable

          @Deprecated
          public Observable<Response> msetObservable(List<String> args)

      Deprecated. use `rxMset(java.util.List<java.lang.String>)` instead
      Redis command mset.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMset

          public Single<Response> rxMset(List<String> args)

      Redis command mset.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### msetnx

          public RedisAPI msetnx(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command msetnx.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### msetnxObservable

          @Deprecated
          public Observable<Response> msetnxObservable(List<String> args)

      Deprecated. use `rxMsetnx(java.util.List<java.lang.String>)` instead
      Redis command msetnx.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxMsetnx

          public Single<Response> rxMsetnx(List<String> args)

      Redis command msetnx.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### multi

          public RedisAPI multi(Handler<AsyncResult<Response>> handler)

      Redis command multi.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### multiObservable

          @Deprecated
          public Observable<Response> multiObservable()

      Deprecated. use `rxMulti()` instead
      Redis command multi.
      Returns:
        fluent self

    - #### rxMulti

          public Single<Response> rxMulti()

      Redis command multi.
      Returns:
        fluent self

    - #### object

          public RedisAPI object(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command object.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### objectObservable

          @Deprecated
          public Observable<Response> objectObservable(List<String> args)

      Deprecated. use `rxObject(java.util.List<java.lang.String>)` instead
      Redis command object.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxObject

          public Single<Response> rxObject(List<String> args)

      Redis command object.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### persist

          public RedisAPI persist(String arg0,
                                  Handler<AsyncResult<Response>> handler)

      Redis command persist.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### persistObservable

          @Deprecated
          public Observable<Response> persistObservable(String arg0)

      Deprecated. use `rxPersist(java.lang.String)` instead
      Redis command persist.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxPersist

          public Single<Response> rxPersist(String arg0)

      Redis command persist.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### pexpire

          public RedisAPI pexpire(String arg0,
                                  String arg1,
                                  Handler<AsyncResult<Response>> handler)

      Redis command pexpire.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### pexpireObservable

          @Deprecated
          public Observable<Response> pexpireObservable(String arg0,
                                                                    String arg1)

      Deprecated. use `rxPexpire(java.lang.String, java.lang.String)` instead
      Redis command pexpire.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxPexpire

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

      Redis command pexpire.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### pexpireat

          public RedisAPI pexpireat(String arg0,
                                    String arg1,
                                    Handler<AsyncResult<Response>> handler)

      Redis command pexpireat.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### pexpireatObservable

          @Deprecated
          public Observable<Response> pexpireatObservable(String arg0,
                                                                      String arg1)

      Deprecated. use `rxPexpireat(java.lang.String, java.lang.String)` instead
      Redis command pexpireat.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxPexpireat

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

      Redis command pexpireat.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### pfadd

          public RedisAPI pfadd(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command pfadd.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pfaddObservable

          @Deprecated
          public Observable<Response> pfaddObservable(List<String> args)

      Deprecated. use `rxPfadd(java.util.List<java.lang.String>)` instead
      Redis command pfadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPfadd

          public Single<Response> rxPfadd(List<String> args)

      Redis command pfadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pfcount

          public RedisAPI pfcount(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command pfcount.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pfcountObservable

          @Deprecated
          public Observable<Response> pfcountObservable(List<String> args)

      Deprecated. use `rxPfcount(java.util.List<java.lang.String>)` instead
      Redis command pfcount.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPfcount

          public Single<Response> rxPfcount(List<String> args)

      Redis command pfcount.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pfdebug

          public RedisAPI pfdebug(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command pfdebug.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pfdebugObservable

          @Deprecated
          public Observable<Response> pfdebugObservable(List<String> args)

      Deprecated. use `rxPfdebug(java.util.List<java.lang.String>)` instead
      Redis command pfdebug.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPfdebug

          public Single<Response> rxPfdebug(List<String> args)

      Redis command pfdebug.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pfmerge

          public RedisAPI pfmerge(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command pfmerge.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pfmergeObservable

          @Deprecated
          public Observable<Response> pfmergeObservable(List<String> args)

      Deprecated. use `rxPfmerge(java.util.List<java.lang.String>)` instead
      Redis command pfmerge.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPfmerge

          public Single<Response> rxPfmerge(List<String> args)

      Redis command pfmerge.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### pfselftest

          public RedisAPI pfselftest(Handler<AsyncResult<Response>> handler)

      Redis command pfselftest.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### pfselftestObservable

          @Deprecated
          public Observable<Response> pfselftestObservable()

      Deprecated. use `rxPfselftest()` instead
      Redis command pfselftest.
      Returns:
        fluent self

    - #### rxPfselftest

          public Single<Response> rxPfselftest()

      Redis command pfselftest.
      Returns:
        fluent self

    - #### ping

          public RedisAPI ping(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command ping.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pingObservable

          @Deprecated
          public Observable<Response> pingObservable(List<String> args)

      Deprecated. use `rxPing(java.util.List<java.lang.String>)` instead
      Redis command ping.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPing

          public Single<Response> rxPing(List<String> args)

      Redis command ping.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### post

          public RedisAPI post(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command post.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### postObservable

          @Deprecated
          public Observable<Response> postObservable(List<String> args)

      Deprecated. use `rxPost(java.util.List<java.lang.String>)` instead
      Redis command post.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPost

          public Single<Response> rxPost(List<String> args)

      Redis command post.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### psetex

          public RedisAPI psetex(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

      Redis command psetex.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### psetexObservable

          @Deprecated
          public Observable<Response> psetexObservable(String arg0,
                                                                   String arg1,
                                                                   String arg2)

      Deprecated. use `rxPsetex(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command psetex.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxPsetex

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

      Redis command psetex.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### psubscribe

          public RedisAPI psubscribe(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command psubscribe.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### psubscribeObservable

          @Deprecated
          public Observable<Response> psubscribeObservable(List<String> args)

      Deprecated. use `rxPsubscribe(java.util.List<java.lang.String>)` instead
      Redis command psubscribe.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPsubscribe

          public Single<Response> rxPsubscribe(List<String> args)

      Redis command psubscribe.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### psync

          public RedisAPI psync(String arg0,
                                String arg1,
                                Handler<AsyncResult<Response>> handler)

      Redis command psync.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### psyncObservable

          @Deprecated
          public Observable<Response> psyncObservable(String arg0,
                                                                  String arg1)

      Deprecated. use `rxPsync(java.lang.String, java.lang.String)` instead
      Redis command psync.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxPsync

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

      Redis command psync.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### pttl

          public RedisAPI pttl(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command pttl.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### pttlObservable

          @Deprecated
          public Observable<Response> pttlObservable(String arg0)

      Deprecated. use `rxPttl(java.lang.String)` instead
      Redis command pttl.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxPttl

          public Single<Response> rxPttl(String arg0)

      Redis command pttl.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### publish

          public RedisAPI publish(String arg0,
                                  String arg1,
                                  Handler<AsyncResult<Response>> handler)

      Redis command publish.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### publishObservable

          @Deprecated
          public Observable<Response> publishObservable(String arg0,
                                                                    String arg1)

      Deprecated. use `rxPublish(java.lang.String, java.lang.String)` instead
      Redis command publish.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxPublish

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

      Redis command publish.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### pubsub

          public RedisAPI pubsub(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command pubsub.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### pubsubObservable

          @Deprecated
          public Observable<Response> pubsubObservable(List<String> args)

      Deprecated. use `rxPubsub(java.util.List<java.lang.String>)` instead
      Redis command pubsub.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPubsub

          public Single<Response> rxPubsub(List<String> args)

      Redis command pubsub.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### punsubscribe

          public RedisAPI punsubscribe(List<String> args,
                                       Handler<AsyncResult<Response>> handler)

      Redis command punsubscribe.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### punsubscribeObservable

          @Deprecated
          public Observable<Response> punsubscribeObservable(List<String> args)

      Deprecated. use `rxPunsubscribe(java.util.List<java.lang.String>)` instead
      Redis command punsubscribe.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxPunsubscribe

          public Single<Response> rxPunsubscribe(List<String> args)

      Redis command punsubscribe.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### randomkey

          public RedisAPI randomkey(Handler<AsyncResult<Response>> handler)

      Redis command randomkey.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### randomkeyObservable

          @Deprecated
          public Observable<Response> randomkeyObservable()

      Deprecated. use `rxRandomkey()` instead
      Redis command randomkey.
      Returns:
        fluent self

    - #### rxRandomkey

          public Single<Response> rxRandomkey()

      Redis command randomkey.
      Returns:
        fluent self

    - #### readonly

          public RedisAPI readonly(Handler<AsyncResult<Response>> handler)

      Redis command readonly.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### readonlyObservable

          @Deprecated
          public Observable<Response> readonlyObservable()

      Deprecated. use `rxReadonly()` instead
      Redis command readonly.
      Returns:
        fluent self

    - #### rxReadonly

          public Single<Response> rxReadonly()

      Redis command readonly.
      Returns:
        fluent self

    - #### readwrite

          public RedisAPI readwrite(Handler<AsyncResult<Response>> handler)

      Redis command readwrite.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### readwriteObservable

          @Deprecated
          public Observable<Response> readwriteObservable()

      Deprecated. use `rxReadwrite()` instead
      Redis command readwrite.
      Returns:
        fluent self

    - #### rxReadwrite

          public Single<Response> rxReadwrite()

      Redis command readwrite.
      Returns:
        fluent self

    - #### rename

          public RedisAPI rename(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Redis command rename.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### renameObservable

          @Deprecated
          public Observable<Response> renameObservable(String arg0,
                                                                   String arg1)

      Deprecated. use `rxRename(java.lang.String, java.lang.String)` instead
      Redis command rename.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxRename

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

      Redis command rename.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### renamenx

          public RedisAPI renamenx(String arg0,
                                   String arg1,
                                   Handler<AsyncResult<Response>> handler)

      Redis command renamenx.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### renamenxObservable

          @Deprecated
          public Observable<Response> renamenxObservable(String arg0,
                                                                     String arg1)

      Deprecated. use `rxRenamenx(java.lang.String, java.lang.String)` instead
      Redis command renamenx.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxRenamenx

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

      Redis command renamenx.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### replconf

          public RedisAPI replconf(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command replconf.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### replconfObservable

          @Deprecated
          public Observable<Response> replconfObservable(List<String> args)

      Deprecated. use `rxReplconf(java.util.List<java.lang.String>)` instead
      Redis command replconf.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxReplconf

          public Single<Response> rxReplconf(List<String> args)

      Redis command replconf.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### replicaof

          public RedisAPI replicaof(String arg0,
                                    String arg1,
                                    Handler<AsyncResult<Response>> handler)

      Redis command replicaof.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### replicaofObservable

          @Deprecated
          public Observable<Response> replicaofObservable(String arg0,
                                                                      String arg1)

      Deprecated. use `rxReplicaof(java.lang.String, java.lang.String)` instead
      Redis command replicaof.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxReplicaof

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

      Redis command replicaof.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### restore

          public RedisAPI restore(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command restore.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### restoreObservable

          @Deprecated
          public Observable<Response> restoreObservable(List<String> args)

      Deprecated. use `rxRestore(java.util.List<java.lang.String>)` instead
      Redis command restore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRestore

          public Single<Response> rxRestore(List<String> args)

      Redis command restore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### restoreAsking

          public RedisAPI restoreAsking(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command restoreAsking.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### restoreAskingObservable

          @Deprecated
          public Observable<Response> restoreAskingObservable(List<String> args)

      Deprecated. use `rxRestoreAsking(java.util.List<java.lang.String>)` instead
      Redis command restoreAsking.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRestoreAsking

          public Single<Response> rxRestoreAsking(List<String> args)

      Redis command restoreAsking.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### role

          public RedisAPI role(Handler<AsyncResult<Response>> handler)

      Redis command role.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### roleObservable

          @Deprecated
          public Observable<Response> roleObservable()

      Deprecated. use `rxRole()` instead
      Redis command role.
      Returns:
        fluent self

    - #### rxRole

          public Single<Response> rxRole()

      Redis command role.
      Returns:
        fluent self

    - #### rpop

          public RedisAPI rpop(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command rpop.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### rpopObservable

          @Deprecated
          public Observable<Response> rpopObservable(String arg0)

      Deprecated. use `rxRpop(java.lang.String)` instead
      Redis command rpop.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxRpop

          public Single<Response> rxRpop(String arg0)

      Redis command rpop.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rpoplpush

          public RedisAPI rpoplpush(String arg0,
                                    String arg1,
                                    Handler<AsyncResult<Response>> handler)

      Redis command rpoplpush.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### rpoplpushObservable

          @Deprecated
          public Observable<Response> rpoplpushObservable(String arg0,
                                                                      String arg1)

      Deprecated. use `rxRpoplpush(java.lang.String, java.lang.String)` instead
      Redis command rpoplpush.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxRpoplpush

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

      Redis command rpoplpush.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rpush

          public RedisAPI rpush(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command rpush.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### rpushObservable

          @Deprecated
          public Observable<Response> rpushObservable(List<String> args)

      Deprecated. use `rxRpush(java.util.List<java.lang.String>)` instead
      Redis command rpush.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRpush

          public Single<Response> rxRpush(List<String> args)

      Redis command rpush.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rpushx

          public RedisAPI rpushx(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command rpushx.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### rpushxObservable

          @Deprecated
          public Observable<Response> rpushxObservable(List<String> args)

      Deprecated. use `rxRpushx(java.util.List<java.lang.String>)` instead
      Redis command rpushx.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxRpushx

          public Single<Response> rxRpushx(List<String> args)

      Redis command rpushx.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sadd

          public RedisAPI sadd(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command sadd.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### saddObservable

          @Deprecated
          public Observable<Response> saddObservable(List<String> args)

      Deprecated. use `rxSadd(java.util.List<java.lang.String>)` instead
      Redis command sadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSadd

          public Single<Response> rxSadd(List<String> args)

      Redis command sadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### save

          public RedisAPI save(Handler<AsyncResult<Response>> handler)

      Redis command save.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### saveObservable

          @Deprecated
          public Observable<Response> saveObservable()

      Deprecated. use `rxSave()` instead
      Redis command save.
      Returns:
        fluent self

    - #### rxSave

          public Single<Response> rxSave()

      Redis command save.
      Returns:
        fluent self

    - #### scan

          public RedisAPI scan(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command scan.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### scanObservable

          @Deprecated
          public Observable<Response> scanObservable(List<String> args)

      Deprecated. use `rxScan(java.util.List<java.lang.String>)` instead
      Redis command scan.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxScan

          public Single<Response> rxScan(List<String> args)

      Redis command scan.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### scard

          public RedisAPI scard(String arg0,
                                Handler<AsyncResult<Response>> handler)

      Redis command scard.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### scardObservable

          @Deprecated
          public Observable<Response> scardObservable(String arg0)

      Deprecated. use `rxScard(java.lang.String)` instead
      Redis command scard.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxScard

          public Single<Response> rxScard(String arg0)

      Redis command scard.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### script

          public RedisAPI script(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command script.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### scriptObservable

          @Deprecated
          public Observable<Response> scriptObservable(List<String> args)

      Deprecated. use `rxScript(java.util.List<java.lang.String>)` instead
      Redis command script.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxScript

          public Single<Response> rxScript(List<String> args)

      Redis command script.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sdiff

          public RedisAPI sdiff(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command sdiff.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sdiffObservable

          @Deprecated
          public Observable<Response> sdiffObservable(List<String> args)

      Deprecated. use `rxSdiff(java.util.List<java.lang.String>)` instead
      Redis command sdiff.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSdiff

          public Single<Response> rxSdiff(List<String> args)

      Redis command sdiff.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sdiffstore

          public RedisAPI sdiffstore(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command sdiffstore.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sdiffstoreObservable

          @Deprecated
          public Observable<Response> sdiffstoreObservable(List<String> args)

      Deprecated. use `rxSdiffstore(java.util.List<java.lang.String>)` instead
      Redis command sdiffstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSdiffstore

          public Single<Response> rxSdiffstore(List<String> args)

      Redis command sdiffstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### select

          public RedisAPI select(String arg0,
                                 Handler<AsyncResult<Response>> handler)

      Redis command select.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### selectObservable

          @Deprecated
          public Observable<Response> selectObservable(String arg0)

      Deprecated. use `rxSelect(java.lang.String)` instead
      Redis command select.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxSelect

          public Single<Response> rxSelect(String arg0)

      Redis command select.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### set

          public RedisAPI set(List<String> args,
                              Handler<AsyncResult<Response>> handler)

      Redis command set.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### setObservable

          @Deprecated
          public Observable<Response> setObservable(List<String> args)

      Deprecated. use `rxSet(java.util.List<java.lang.String>)` instead
      Redis command set.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSet

          public Single<Response> rxSet(List<String> args)

      Redis command set.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### setbit

          public RedisAPI setbit(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

      Redis command setbit.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### setbitObservable

          @Deprecated
          public Observable<Response> setbitObservable(String arg0,
                                                                   String arg1,
                                                                   String arg2)

      Deprecated. use `rxSetbit(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command setbit.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSetbit

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

      Redis command setbit.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### setex

          public RedisAPI setex(String arg0,
                                String arg1,
                                String arg2,
                                Handler<AsyncResult<Response>> handler)

      Redis command setex.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### setexObservable

          @Deprecated
          public Observable<Response> setexObservable(String arg0,
                                                                  String arg1,
                                                                  String arg2)

      Deprecated. use `rxSetex(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command setex.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSetex

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

      Redis command setex.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### setnx

          public RedisAPI setnx(String arg0,
                                String arg1,
                                Handler<AsyncResult<Response>> handler)

      Redis command setnx.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### setnxObservable

          @Deprecated
          public Observable<Response> setnxObservable(String arg0,
                                                                  String arg1)

      Deprecated. use `rxSetnx(java.lang.String, java.lang.String)` instead
      Redis command setnx.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSetnx

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

      Redis command setnx.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### setrange

          public RedisAPI setrange(String arg0,
                                   String arg1,
                                   String arg2,
                                   Handler<AsyncResult<Response>> handler)

      Redis command setrange.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### setrangeObservable

          @Deprecated
          public Observable<Response> setrangeObservable(String arg0,
                                                                     String arg1,
                                                                     String arg2)

      Deprecated. use `rxSetrange(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command setrange.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSetrange

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

      Redis command setrange.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### shutdown

          public RedisAPI shutdown(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command shutdown.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### shutdownObservable

          @Deprecated
          public Observable<Response> shutdownObservable(List<String> args)

      Deprecated. use `rxShutdown(java.util.List<java.lang.String>)` instead
      Redis command shutdown.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxShutdown

          public Single<Response> rxShutdown(List<String> args)

      Redis command shutdown.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sinter

          public RedisAPI sinter(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command sinter.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sinterObservable

          @Deprecated
          public Observable<Response> sinterObservable(List<String> args)

      Deprecated. use `rxSinter(java.util.List<java.lang.String>)` instead
      Redis command sinter.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSinter

          public Single<Response> rxSinter(List<String> args)

      Redis command sinter.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sinterstore

          public RedisAPI sinterstore(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command sinterstore.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sinterstoreObservable

          @Deprecated
          public Observable<Response> sinterstoreObservable(List<String> args)

      Deprecated. use `rxSinterstore(java.util.List<java.lang.String>)` instead
      Redis command sinterstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSinterstore

          public Single<Response> rxSinterstore(List<String> args)

      Redis command sinterstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sismember

          public RedisAPI sismember(String arg0,
                                    String arg1,
                                    Handler<AsyncResult<Response>> handler)

      Redis command sismember.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### sismemberObservable

          @Deprecated
          public Observable<Response> sismemberObservable(String arg0,
                                                                      String arg1)

      Deprecated. use `rxSismember(java.lang.String, java.lang.String)` instead
      Redis command sismember.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSismember

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

      Redis command sismember.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### slaveof

          public RedisAPI slaveof(String arg0,
                                  String arg1,
                                  Handler<AsyncResult<Response>> handler)

      Redis command slaveof.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### slaveofObservable

          @Deprecated
          public Observable<Response> slaveofObservable(String arg0,
                                                                    String arg1)

      Deprecated. use `rxSlaveof(java.lang.String, java.lang.String)` instead
      Redis command slaveof.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSlaveof

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

      Redis command slaveof.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### slowlog

          public RedisAPI slowlog(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command slowlog.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### slowlogObservable

          @Deprecated
          public Observable<Response> slowlogObservable(List<String> args)

      Deprecated. use `rxSlowlog(java.util.List<java.lang.String>)` instead
      Redis command slowlog.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSlowlog

          public Single<Response> rxSlowlog(List<String> args)

      Redis command slowlog.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### smembers

          public RedisAPI smembers(String arg0,
                                   Handler<AsyncResult<Response>> handler)

      Redis command smembers.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### smembersObservable

          @Deprecated
          public Observable<Response> smembersObservable(String arg0)

      Deprecated. use `rxSmembers(java.lang.String)` instead
      Redis command smembers.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxSmembers

          public Single<Response> rxSmembers(String arg0)

      Redis command smembers.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### smove

          public RedisAPI smove(String arg0,
                                String arg1,
                                String arg2,
                                Handler<AsyncResult<Response>> handler)

      Redis command smove.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### smoveObservable

          @Deprecated
          public Observable<Response> smoveObservable(String arg0,
                                                                  String arg1,
                                                                  String arg2)

      Deprecated. use `rxSmove(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command smove.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSmove

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

      Redis command smove.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### sort

          public RedisAPI sort(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command sort.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sortObservable

          @Deprecated
          public Observable<Response> sortObservable(List<String> args)

      Deprecated. use `rxSort(java.util.List<java.lang.String>)` instead
      Redis command sort.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSort

          public Single<Response> rxSort(List<String> args)

      Redis command sort.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### spop

          public RedisAPI spop(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command spop.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### spopObservable

          @Deprecated
          public Observable<Response> spopObservable(List<String> args)

      Deprecated. use `rxSpop(java.util.List<java.lang.String>)` instead
      Redis command spop.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSpop

          public Single<Response> rxSpop(List<String> args)

      Redis command spop.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### srandmember

          public RedisAPI srandmember(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command srandmember.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### srandmemberObservable

          @Deprecated
          public Observable<Response> srandmemberObservable(List<String> args)

      Deprecated. use `rxSrandmember(java.util.List<java.lang.String>)` instead
      Redis command srandmember.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSrandmember

          public Single<Response> rxSrandmember(List<String> args)

      Redis command srandmember.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### srem

          public RedisAPI srem(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command srem.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sremObservable

          @Deprecated
          public Observable<Response> sremObservable(List<String> args)

      Deprecated. use `rxSrem(java.util.List<java.lang.String>)` instead
      Redis command srem.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSrem

          public Single<Response> rxSrem(List<String> args)

      Redis command srem.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sscan

          public RedisAPI sscan(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command sscan.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sscanObservable

          @Deprecated
          public Observable<Response> sscanObservable(List<String> args)

      Deprecated. use `rxSscan(java.util.List<java.lang.String>)` instead
      Redis command sscan.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSscan

          public Single<Response> rxSscan(List<String> args)

      Redis command sscan.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### strlen

          public RedisAPI strlen(String arg0,
                                 Handler<AsyncResult<Response>> handler)

      Redis command strlen.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### strlenObservable

          @Deprecated
          public Observable<Response> strlenObservable(String arg0)

      Deprecated. use `rxStrlen(java.lang.String)` instead
      Redis command strlen.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxStrlen

          public Single<Response> rxStrlen(String arg0)

      Redis command strlen.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### subscribe

          public RedisAPI subscribe(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command subscribe.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### subscribeObservable

          @Deprecated
          public Observable<Response> subscribeObservable(List<String> args)

      Deprecated. use `rxSubscribe(java.util.List<java.lang.String>)` instead
      Redis command subscribe.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSubscribe

          public Single<Response> rxSubscribe(List<String> args)

      Redis command subscribe.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### substr

          public RedisAPI substr(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

      Redis command substr.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### substrObservable

          @Deprecated
          public Observable<Response> substrObservable(String arg0,
                                                                   String arg1,
                                                                   String arg2)

      Deprecated. use `rxSubstr(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command substr.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxSubstr

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

      Redis command substr.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### sunion

          public RedisAPI sunion(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command sunion.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sunionObservable

          @Deprecated
          public Observable<Response> sunionObservable(List<String> args)

      Deprecated. use `rxSunion(java.util.List<java.lang.String>)` instead
      Redis command sunion.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSunion

          public Single<Response> rxSunion(List<String> args)

      Redis command sunion.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### sunionstore

          public RedisAPI sunionstore(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command sunionstore.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### sunionstoreObservable

          @Deprecated
          public Observable<Response> sunionstoreObservable(List<String> args)

      Deprecated. use `rxSunionstore(java.util.List<java.lang.String>)` instead
      Redis command sunionstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxSunionstore

          public Single<Response> rxSunionstore(List<String> args)

      Redis command sunionstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### swapdb

          public RedisAPI swapdb(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Redis command swapdb.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### swapdbObservable

          @Deprecated
          public Observable<Response> swapdbObservable(String arg0,
                                                                   String arg1)

      Deprecated. use `rxSwapdb(java.lang.String, java.lang.String)` instead
      Redis command swapdb.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxSwapdb

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

      Redis command swapdb.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### sync

          public RedisAPI sync(Handler<AsyncResult<Response>> handler)

      Redis command sync.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### syncObservable

          @Deprecated
          public Observable<Response> syncObservable()

      Deprecated. use `rxSync()` instead
      Redis command sync.
      Returns:
        fluent self

    - #### rxSync

          public Single<Response> rxSync()

      Redis command sync.
      Returns:
        fluent self

    - #### time

          public RedisAPI time(Handler<AsyncResult<Response>> handler)

      Redis command time.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### timeObservable

          @Deprecated
          public Observable<Response> timeObservable()

      Deprecated. use `rxTime()` instead
      Redis command time.
      Returns:
        fluent self

    - #### rxTime

          public Single<Response> rxTime()

      Redis command time.
      Returns:
        fluent self

    - #### touch

          public RedisAPI touch(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command touch.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### touchObservable

          @Deprecated
          public Observable<Response> touchObservable(List<String> args)

      Deprecated. use `rxTouch(java.util.List<java.lang.String>)` instead
      Redis command touch.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxTouch

          public Single<Response> rxTouch(List<String> args)

      Redis command touch.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### ttl

          public RedisAPI ttl(String arg0,
                              Handler<AsyncResult<Response>> handler)

      Redis command ttl.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### ttlObservable

          @Deprecated
          public Observable<Response> ttlObservable(String arg0)

      Deprecated. use `rxTtl(java.lang.String)` instead
      Redis command ttl.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxTtl

          public Single<Response> rxTtl(String arg0)

      Redis command ttl.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### type

          public RedisAPI type(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command type.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### typeObservable

          @Deprecated
          public Observable<Response> typeObservable(String arg0)

      Deprecated. use `rxType(java.lang.String)` instead
      Redis command type.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxType

          public Single<Response> rxType(String arg0)

      Redis command type.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### unlink

          public RedisAPI unlink(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command unlink.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### unlinkObservable

          @Deprecated
          public Observable<Response> unlinkObservable(List<String> args)

      Deprecated. use `rxUnlink(java.util.List<java.lang.String>)` instead
      Redis command unlink.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxUnlink

          public Single<Response> rxUnlink(List<String> args)

      Redis command unlink.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### unsubscribe

          public RedisAPI unsubscribe(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command unsubscribe.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### unsubscribeObservable

          @Deprecated
          public Observable<Response> unsubscribeObservable(List<String> args)

      Deprecated. use `rxUnsubscribe(java.util.List<java.lang.String>)` instead
      Redis command unsubscribe.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxUnsubscribe

          public Single<Response> rxUnsubscribe(List<String> args)

      Redis command unsubscribe.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### unwatch

          public RedisAPI unwatch(Handler<AsyncResult<Response>> handler)

      Redis command unwatch.
      Parameters:
        `handler` -
      Returns:
        fluent self

    - #### unwatchObservable

          @Deprecated
          public Observable<Response> unwatchObservable()

      Deprecated. use `rxUnwatch()` instead
      Redis command unwatch.
      Returns:
        fluent self

    - #### rxUnwatch

          public Single<Response> rxUnwatch()

      Redis command unwatch.
      Returns:
        fluent self

    - #### wait

          public RedisAPI wait(String arg0,
                               String arg1,
                               Handler<AsyncResult<Response>> handler)

      Redis command wait.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### waitObservable

          @Deprecated
          public Observable<Response> waitObservable(String arg0,
                                                                 String arg1)

      Deprecated. use `rxWait(java.lang.String, java.lang.String)` instead
      Redis command wait.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxWait

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

      Redis command wait.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### watch

          public RedisAPI watch(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command watch.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### watchObservable

          @Deprecated
          public Observable<Response> watchObservable(List<String> args)

      Deprecated. use `rxWatch(java.util.List<java.lang.String>)` instead
      Redis command watch.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxWatch

          public Single<Response> rxWatch(List<String> args)

      Redis command watch.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xack

          public RedisAPI xack(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command xack.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xackObservable

          @Deprecated
          public Observable<Response> xackObservable(List<String> args)

      Deprecated. use `rxXack(java.util.List<java.lang.String>)` instead
      Redis command xack.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXack

          public Single<Response> rxXack(List<String> args)

      Redis command xack.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xadd

          public RedisAPI xadd(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command xadd.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xaddObservable

          @Deprecated
          public Observable<Response> xaddObservable(List<String> args)

      Deprecated. use `rxXadd(java.util.List<java.lang.String>)` instead
      Redis command xadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXadd

          public Single<Response> rxXadd(List<String> args)

      Redis command xadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xclaim

          public RedisAPI xclaim(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command xclaim.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xclaimObservable

          @Deprecated
          public Observable<Response> xclaimObservable(List<String> args)

      Deprecated. use `rxXclaim(java.util.List<java.lang.String>)` instead
      Redis command xclaim.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXclaim

          public Single<Response> rxXclaim(List<String> args)

      Redis command xclaim.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xdel

          public RedisAPI xdel(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command xdel.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xdelObservable

          @Deprecated
          public Observable<Response> xdelObservable(List<String> args)

      Deprecated. use `rxXdel(java.util.List<java.lang.String>)` instead
      Redis command xdel.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXdel

          public Single<Response> rxXdel(List<String> args)

      Redis command xdel.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xgroup

          public RedisAPI xgroup(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command xgroup.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xgroupObservable

          @Deprecated
          public Observable<Response> xgroupObservable(List<String> args)

      Deprecated. use `rxXgroup(java.util.List<java.lang.String>)` instead
      Redis command xgroup.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXgroup

          public Single<Response> rxXgroup(List<String> args)

      Redis command xgroup.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xinfo

          public RedisAPI xinfo(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command xinfo.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xinfoObservable

          @Deprecated
          public Observable<Response> xinfoObservable(List<String> args)

      Deprecated. use `rxXinfo(java.util.List<java.lang.String>)` instead
      Redis command xinfo.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXinfo

          public Single<Response> rxXinfo(List<String> args)

      Redis command xinfo.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xlen

          public RedisAPI xlen(String arg0,
                               Handler<AsyncResult<Response>> handler)

      Redis command xlen.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### xlenObservable

          @Deprecated
          public Observable<Response> xlenObservable(String arg0)

      Deprecated. use `rxXlen(java.lang.String)` instead
      Redis command xlen.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxXlen

          public Single<Response> rxXlen(String arg0)

      Redis command xlen.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### xpending

          public RedisAPI xpending(List<String> args,
                                   Handler<AsyncResult<Response>> handler)

      Redis command xpending.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xpendingObservable

          @Deprecated
          public Observable<Response> xpendingObservable(List<String> args)

      Deprecated. use `rxXpending(java.util.List<java.lang.String>)` instead
      Redis command xpending.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXpending

          public Single<Response> rxXpending(List<String> args)

      Redis command xpending.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xrange

          public RedisAPI xrange(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command xrange.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xrangeObservable

          @Deprecated
          public Observable<Response> xrangeObservable(List<String> args)

      Deprecated. use `rxXrange(java.util.List<java.lang.String>)` instead
      Redis command xrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXrange

          public Single<Response> rxXrange(List<String> args)

      Redis command xrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xread

          public RedisAPI xread(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command xread.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xreadObservable

          @Deprecated
          public Observable<Response> xreadObservable(List<String> args)

      Deprecated. use `rxXread(java.util.List<java.lang.String>)` instead
      Redis command xread.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXread

          public Single<Response> rxXread(List<String> args)

      Redis command xread.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xreadgroup

          public RedisAPI xreadgroup(List<String> args,
                                     Handler<AsyncResult<Response>> handler)

      Redis command xreadgroup.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xreadgroupObservable

          @Deprecated
          public Observable<Response> xreadgroupObservable(List<String> args)

      Deprecated. use `rxXreadgroup(java.util.List<java.lang.String>)` instead
      Redis command xreadgroup.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXreadgroup

          public Single<Response> rxXreadgroup(List<String> args)

      Redis command xreadgroup.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xrevrange

          public RedisAPI xrevrange(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command xrevrange.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xrevrangeObservable

          @Deprecated
          public Observable<Response> xrevrangeObservable(List<String> args)

      Deprecated. use `rxXrevrange(java.util.List<java.lang.String>)` instead
      Redis command xrevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXrevrange

          public Single<Response> rxXrevrange(List<String> args)

      Redis command xrevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### xsetid

          public RedisAPI xsetid(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Redis command xsetid.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### xsetidObservable

          @Deprecated
          public Observable<Response> xsetidObservable(String arg0,
                                                                   String arg1)

      Deprecated. use `rxXsetid(java.lang.String, java.lang.String)` instead
      Redis command xsetid.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxXsetid

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

      Redis command xsetid.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### xtrim

          public RedisAPI xtrim(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command xtrim.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### xtrimObservable

          @Deprecated
          public Observable<Response> xtrimObservable(List<String> args)

      Deprecated. use `rxXtrim(java.util.List<java.lang.String>)` instead
      Redis command xtrim.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxXtrim

          public Single<Response> rxXtrim(List<String> args)

      Redis command xtrim.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zadd

          public RedisAPI zadd(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command zadd.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zaddObservable

          @Deprecated
          public Observable<Response> zaddObservable(List<String> args)

      Deprecated. use `rxZadd(java.util.List<java.lang.String>)` instead
      Redis command zadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZadd

          public Single<Response> rxZadd(List<String> args)

      Redis command zadd.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zcard

          public RedisAPI zcard(String arg0,
                                Handler<AsyncResult<Response>> handler)

      Redis command zcard.
      Parameters:
        `arg0` -
        `handler` -
      Returns:
        fluent self

    - #### zcardObservable

          @Deprecated
          public Observable<Response> zcardObservable(String arg0)

      Deprecated. use `rxZcard(java.lang.String)` instead
      Redis command zcard.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### rxZcard

          public Single<Response> rxZcard(String arg0)

      Redis command zcard.
      Parameters:
        `arg0` -
      Returns:
        fluent self

    - #### zcount

          public RedisAPI zcount(String arg0,
                                 String arg1,
                                 String arg2,
                                 Handler<AsyncResult<Response>> handler)

      Redis command zcount.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zcountObservable

          @Deprecated
          public Observable<Response> zcountObservable(String arg0,
                                                                   String arg1,
                                                                   String arg2)

      Deprecated. use `rxZcount(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command zcount.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZcount

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

      Redis command zcount.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zincrby

          public RedisAPI zincrby(String arg0,
                                  String arg1,
                                  String arg2,
                                  Handler<AsyncResult<Response>> handler)

      Redis command zincrby.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zincrbyObservable

          @Deprecated
          public Observable<Response> zincrbyObservable(String arg0,
                                                                    String arg1,
                                                                    String arg2)

      Deprecated. use `rxZincrby(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command zincrby.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZincrby

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

      Redis command zincrby.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zinterstore

          public RedisAPI zinterstore(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command zinterstore.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zinterstoreObservable

          @Deprecated
          public Observable<Response> zinterstoreObservable(List<String> args)

      Deprecated. use `rxZinterstore(java.util.List<java.lang.String>)` instead
      Redis command zinterstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZinterstore

          public Single<Response> rxZinterstore(List<String> args)

      Redis command zinterstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zlexcount

          public RedisAPI zlexcount(String arg0,
                                    String arg1,
                                    String arg2,
                                    Handler<AsyncResult<Response>> handler)

      Redis command zlexcount.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zlexcountObservable

          @Deprecated
          public Observable<Response> zlexcountObservable(String arg0,
                                                                      String arg1,
                                                                      String arg2)

      Deprecated. use `rxZlexcount(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command zlexcount.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZlexcount

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

      Redis command zlexcount.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zpopmax

          public RedisAPI zpopmax(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command zpopmax.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zpopmaxObservable

          @Deprecated
          public Observable<Response> zpopmaxObservable(List<String> args)

      Deprecated. use `rxZpopmax(java.util.List<java.lang.String>)` instead
      Redis command zpopmax.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZpopmax

          public Single<Response> rxZpopmax(List<String> args)

      Redis command zpopmax.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zpopmin

          public RedisAPI zpopmin(List<String> args,
                                  Handler<AsyncResult<Response>> handler)

      Redis command zpopmin.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zpopminObservable

          @Deprecated
          public Observable<Response> zpopminObservable(List<String> args)

      Deprecated. use `rxZpopmin(java.util.List<java.lang.String>)` instead
      Redis command zpopmin.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZpopmin

          public Single<Response> rxZpopmin(List<String> args)

      Redis command zpopmin.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrange

          public RedisAPI zrange(List<String> args,
                                 Handler<AsyncResult<Response>> handler)

      Redis command zrange.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrangeObservable

          @Deprecated
          public Observable<Response> zrangeObservable(List<String> args)

      Deprecated. use `rxZrange(java.util.List<java.lang.String>)` instead
      Redis command zrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrange

          public Single<Response> rxZrange(List<String> args)

      Redis command zrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrangebylex

          public RedisAPI zrangebylex(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command zrangebylex.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrangebylexObservable

          @Deprecated
          public Observable<Response> zrangebylexObservable(List<String> args)

      Deprecated. use `rxZrangebylex(java.util.List<java.lang.String>)` instead
      Redis command zrangebylex.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrangebylex

          public Single<Response> rxZrangebylex(List<String> args)

      Redis command zrangebylex.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrangebyscore

          public RedisAPI zrangebyscore(List<String> args,
                                        Handler<AsyncResult<Response>> handler)

      Redis command zrangebyscore.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrangebyscoreObservable

          @Deprecated
          public Observable<Response> zrangebyscoreObservable(List<String> args)

      Deprecated. use `rxZrangebyscore(java.util.List<java.lang.String>)` instead
      Redis command zrangebyscore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrangebyscore

          public Single<Response> rxZrangebyscore(List<String> args)

      Redis command zrangebyscore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrank

          public RedisAPI zrank(String arg0,
                                String arg1,
                                Handler<AsyncResult<Response>> handler)

      Redis command zrank.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### zrankObservable

          @Deprecated
          public Observable<Response> zrankObservable(String arg0,
                                                                  String arg1)

      Deprecated. use `rxZrank(java.lang.String, java.lang.String)` instead
      Redis command zrank.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZrank

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

      Redis command zrank.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zrem

          public RedisAPI zrem(List<String> args,
                               Handler<AsyncResult<Response>> handler)

      Redis command zrem.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zremObservable

          @Deprecated
          public Observable<Response> zremObservable(List<String> args)

      Deprecated. use `rxZrem(java.util.List<java.lang.String>)` instead
      Redis command zrem.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrem

          public Single<Response> rxZrem(List<String> args)

      Redis command zrem.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zremrangebylex

          public RedisAPI zremrangebylex(String arg0,
                                         String arg1,
                                         String arg2,
                                         Handler<AsyncResult<Response>> handler)

      Redis command zremrangebylex.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zremrangebylexObservable

          @Deprecated
          public Observable<Response> zremrangebylexObservable(String arg0,
                                                                           String arg1,
                                                                           String arg2)

      Deprecated. use `rxZremrangebylex(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command zremrangebylex.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebylex

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

      Redis command zremrangebylex.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zremrangebyrank

          public RedisAPI zremrangebyrank(String arg0,
                                          String arg1,
                                          String arg2,
                                          Handler<AsyncResult<Response>> handler)

      Redis command zremrangebyrank.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zremrangebyrankObservable

          @Deprecated
          public Observable<Response> zremrangebyrankObservable(String arg0,
                                                                            String arg1,
                                                                            String arg2)

      Deprecated. use `rxZremrangebyrank(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command zremrangebyrank.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebyrank

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

      Redis command zremrangebyrank.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zremrangebyscore

          public RedisAPI zremrangebyscore(String arg0,
                                           String arg1,
                                           String arg2,
                                           Handler<AsyncResult<Response>> handler)

      Redis command zremrangebyscore.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
        `handler` -
      Returns:
        fluent self

    - #### zremrangebyscoreObservable

          @Deprecated
          public Observable<Response> zremrangebyscoreObservable(String arg0,
                                                                             String arg1,
                                                                             String arg2)

      Deprecated. use `rxZremrangebyscore(java.lang.String, java.lang.String, java.lang.String)` instead
      Redis command zremrangebyscore.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### rxZremrangebyscore

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

      Redis command zremrangebyscore.
      Parameters:
        `arg0` -
        `arg1` -
        `arg2` -
      Returns:
        fluent self

    - #### zrevrange

          public RedisAPI zrevrange(List<String> args,
                                    Handler<AsyncResult<Response>> handler)

      Redis command zrevrange.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrevrangeObservable

          @Deprecated
          public Observable<Response> zrevrangeObservable(List<String> args)

      Deprecated. use `rxZrevrange(java.util.List<java.lang.String>)` instead
      Redis command zrevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrange

          public Single<Response> rxZrevrange(List<String> args)

      Redis command zrevrange.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrangebylex

          public RedisAPI zrevrangebylex(List<String> args,
                                         Handler<AsyncResult<Response>> handler)

      Redis command zrevrangebylex.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrevrangebylexObservable

          @Deprecated
          public Observable<Response> zrevrangebylexObservable(List<String> args)

      Deprecated. use `rxZrevrangebylex(java.util.List<java.lang.String>)` instead
      Redis command zrevrangebylex.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrangebylex

          public Single<Response> rxZrevrangebylex(List<String> args)

      Redis command zrevrangebylex.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrangebyscore

          public RedisAPI zrevrangebyscore(List<String> args,
                                           Handler<AsyncResult<Response>> handler)

      Redis command zrevrangebyscore.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zrevrangebyscoreObservable

          @Deprecated
          public Observable<Response> zrevrangebyscoreObservable(List<String> args)

      Deprecated. use `rxZrevrangebyscore(java.util.List<java.lang.String>)` instead
      Redis command zrevrangebyscore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZrevrangebyscore

          public Single<Response> rxZrevrangebyscore(List<String> args)

      Redis command zrevrangebyscore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zrevrank

          public RedisAPI zrevrank(String arg0,
                                   String arg1,
                                   Handler<AsyncResult<Response>> handler)

      Redis command zrevrank.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### zrevrankObservable

          @Deprecated
          public Observable<Response> zrevrankObservable(String arg0,
                                                                     String arg1)

      Deprecated. use `rxZrevrank(java.lang.String, java.lang.String)` instead
      Redis command zrevrank.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZrevrank

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

      Redis command zrevrank.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zscan

          public RedisAPI zscan(List<String> args,
                                Handler<AsyncResult<Response>> handler)

      Redis command zscan.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zscanObservable

          @Deprecated
          public Observable<Response> zscanObservable(List<String> args)

      Deprecated. use `rxZscan(java.util.List<java.lang.String>)` instead
      Redis command zscan.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZscan

          public Single<Response> rxZscan(List<String> args)

      Redis command zscan.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### zscore

          public RedisAPI zscore(String arg0,
                                 String arg1,
                                 Handler<AsyncResult<Response>> handler)

      Redis command zscore.
      Parameters:
        `arg0` -
        `arg1` -
        `handler` -
      Returns:
        fluent self

    - #### zscoreObservable

          @Deprecated
          public Observable<Response> zscoreObservable(String arg0,
                                                                   String arg1)

      Deprecated. use `rxZscore(java.lang.String, java.lang.String)` instead
      Redis command zscore.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### rxZscore

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

      Redis command zscore.
      Parameters:
        `arg0` -
        `arg1` -
      Returns:
        fluent self

    - #### zunionstore

          public RedisAPI zunionstore(List<String> args,
                                      Handler<AsyncResult<Response>> handler)

      Redis command zunionstore.
      Parameters:
        `args` -
        `handler` -
      Returns:
        fluent self

    - #### zunionstoreObservable

          @Deprecated
          public Observable<Response> zunionstoreObservable(List<String> args)

      Deprecated. use `rxZunionstore(java.util.List<java.lang.String>)` instead
      Redis command zunionstore.
      Parameters:
        `args` -
      Returns:
        fluent self

    - #### rxZunionstore

          public Single<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)

Copyright © 2020 Eclipse. All rights reserved.