RedisAPI (Vert.x RxJava API 3.9.14 API)

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 TypeArg<RedisAPI> __TYPE_ARG

Fields
Modifier and Type	Field and Description
`static TypeArg<RedisAPI>`	`__TYPE_ARG`

Constructor Summary

Constructors
Constructor and Description

RedisAPI(Object delegate)

RedisAPI(io.vertx.redis.client.RedisAPI delegate)

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

Constructor Detail

RedisAPI

public RedisAPI(io.vertx.redis.client.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 io.vertx.redis.client.RedisAPI getDelegate()

close
```
public void close()
```

append

public RedisAPI append(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command append.

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

appendObservable

@Deprecated
public rx.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 rx.Single<Response> rxAppend(String arg0,
                                    String arg1)

Redis command append.

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

asking

public RedisAPI asking(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command asking.

Parameters:: handler -
Returns:: fluent self

askingObservable
```
@Deprecated
public rx.Observable<Response> askingObservable()
```
Deprecated. use rxAsking() instead

Redis command asking.

Returns:

fluent self

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

Returns:

fluent self

auth

public RedisAPI auth(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command auth.

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

authObservable
```
@Deprecated
public rx.Observable<Response> authObservable(String arg0)
```
Deprecated. use rxAuth(java.lang.String) instead

Redis command auth.

Parameters:

arg0 -

Returns:

fluent self

rxAuth
```
public rx.Single<Response> rxAuth(String arg0)
```
Redis command auth.

Parameters:

arg0 -

Returns:

fluent self

bgrewriteaof

public RedisAPI bgrewriteaof(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command bgrewriteaof.

Parameters:: handler -
Returns:: fluent self

bgrewriteaofObservable
```
@Deprecated
public rx.Observable<Response> bgrewriteaofObservable()
```
Deprecated. use rxBgrewriteaof() instead

Redis command bgrewriteaof.

Returns:

fluent self

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

Returns:

fluent self

bgsave

public RedisAPI bgsave(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command bgsave.

Parameters:: args -; handler -
Returns:: fluent self

bgsaveObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxBgsave(List<String> args)
```
Redis command bgsave.

Parameters:

args -

Returns:

fluent self

bitcount

public RedisAPI bitcount(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command bitcount.

Parameters:: args -; handler -
Returns:: fluent self

bitcountObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxBitcount(List<String> args)
```
Redis command bitcount.

Parameters:

args -

Returns:

fluent self

bitfield

public RedisAPI bitfield(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command bitfield.

Parameters:: args -; handler -
Returns:: fluent self

bitfieldObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxBitfield(List<String> args)
```
Redis command bitfield.

Parameters:

args -

Returns:

fluent self

bitop

public RedisAPI bitop(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command bitop.

Parameters:: args -; handler -
Returns:: fluent self

bitopObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxBitop(List<String> args)
```
Redis command bitop.

Parameters:

args -

Returns:

fluent self

bitpos

public RedisAPI bitpos(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command bitpos.

Parameters:: args -; handler -
Returns:: fluent self

bitposObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxBitpos(List<String> args)
```
Redis command bitpos.

Parameters:

args -

Returns:

fluent self

blpop

public RedisAPI blpop(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command blpop.

Parameters:: args -; handler -
Returns:: fluent self

blpopObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxBlpop(List<String> args)
```
Redis command blpop.

Parameters:

args -

Returns:

fluent self

brpop

public RedisAPI brpop(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command brpop.

Parameters:: args -; handler -
Returns:: fluent self

brpopObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxBrpop(List<String> args)
```
Redis command brpop.

Parameters:

args -

Returns:

fluent self

brpoplpush

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

Redis command brpoplpush.

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

brpoplpushObservable

@Deprecated
public rx.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 rx.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,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command bzpopmax.

Parameters:: args -; handler -
Returns:: fluent self

bzpopmaxObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxBzpopmax(List<String> args)
```
Redis command bzpopmax.

Parameters:

args -

Returns:

fluent self

bzpopmin

public RedisAPI bzpopmin(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command bzpopmin.

Parameters:: args -; handler -
Returns:: fluent self

bzpopminObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxBzpopmin(List<String> args)
```
Redis command bzpopmin.

Parameters:

args -

Returns:

fluent self

client

public RedisAPI client(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command client.

Parameters:: args -; handler -
Returns:: fluent self

clientObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxClient(List<String> args)
```
Redis command client.

Parameters:

args -

Returns:

fluent self

cluster

public RedisAPI cluster(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command cluster.

Parameters:: args -; handler -
Returns:: fluent self

clusterObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxCluster(List<String> args)
```
Redis command cluster.

Parameters:

args -

Returns:

fluent self

command

public RedisAPI command(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command command.

Parameters:: handler -
Returns:: fluent self

commandObservable
```
@Deprecated
public rx.Observable<Response> commandObservable()
```
Deprecated. use rxCommand() instead

Redis command command.

Returns:

fluent self

rxCommand
```
public rx.Single<Response> rxCommand()
```
Redis command command.

Returns:

fluent self

config

public RedisAPI config(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command config.

Parameters:: args -; handler -
Returns:: fluent self

configObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxConfig(List<String> args)
```
Redis command config.

Parameters:

args -

Returns:

fluent self

dbsize

public RedisAPI dbsize(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command dbsize.

Parameters:: handler -
Returns:: fluent self

dbsizeObservable
```
@Deprecated
public rx.Observable<Response> dbsizeObservable()
```
Deprecated. use rxDbsize() instead

Redis command dbsize.

Returns:

fluent self

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

Returns:

fluent self

debug

public RedisAPI debug(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command debug.

Parameters:: args -; handler -
Returns:: fluent self

debugObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxDebug(List<String> args)
```
Redis command debug.

Parameters:

args -

Returns:

fluent self

decr

public RedisAPI decr(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command decr.

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

decrObservable
```
@Deprecated
public rx.Observable<Response> decrObservable(String arg0)
```
Deprecated. use rxDecr(java.lang.String) instead

Redis command decr.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

decrby

public RedisAPI decrby(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command decrby.

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

decrbyObservable

@Deprecated
public rx.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 rx.Single<Response> rxDecrby(String arg0,
                                    String arg1)

Redis command decrby.

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

del

public RedisAPI del(List<String> args,
                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command del.

Parameters:: args -; handler -
Returns:: fluent self

delObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxDel(List<String> args)
```
Redis command del.

Parameters:

args -

Returns:

fluent self

discard

public RedisAPI discard(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command discard.

Parameters:: handler -
Returns:: fluent self

discardObservable
```
@Deprecated
public rx.Observable<Response> discardObservable()
```
Deprecated. use rxDiscard() instead

Redis command discard.

Returns:

fluent self

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

Returns:

fluent self

dump

public RedisAPI dump(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command dump.

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

dumpObservable
```
@Deprecated
public rx.Observable<Response> dumpObservable(String arg0)
```
Deprecated. use rxDump(java.lang.String) instead

Redis command dump.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

echo

public RedisAPI echo(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command echo.

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

echoObservable
```
@Deprecated
public rx.Observable<Response> echoObservable(String arg0)
```
Deprecated. use rxEcho(java.lang.String) instead

Redis command echo.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

eval

public RedisAPI eval(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command eval.

Parameters:: args -; handler -
Returns:: fluent self

evalObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxEval(List<String> args)
```
Redis command eval.

Parameters:

args -

Returns:

fluent self

evalsha

public RedisAPI evalsha(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command evalsha.

Parameters:: args -; handler -
Returns:: fluent self

evalshaObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxEvalsha(List<String> args)
```
Redis command evalsha.

Parameters:

args -

Returns:

fluent self

exec

public RedisAPI exec(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command exec.

Parameters:: handler -
Returns:: fluent self

execObservable
```
@Deprecated
public rx.Observable<Response> execObservable()
```
Deprecated. use rxExec() instead

Redis command exec.

Returns:

fluent self

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

Returns:

fluent self

exists

public RedisAPI exists(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command exists.

Parameters:: args -; handler -
Returns:: fluent self

existsObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxExists(List<String> args)
```
Redis command exists.

Parameters:

args -

Returns:

fluent self

expire

public RedisAPI expire(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command expire.

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

expireObservable

@Deprecated
public rx.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 rx.Single<Response> rxExpire(String arg0,
                                    String arg1)

Redis command expire.

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

expireat

public RedisAPI expireat(String arg0,
                         String arg1,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command expireat.

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

expireatObservable

@Deprecated
public rx.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 rx.Single<Response> rxExpireat(String arg0,
                                      String arg1)

Redis command expireat.

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

flushall

public RedisAPI flushall(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command flushall.

Parameters:: args -; handler -
Returns:: fluent self

flushallObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxFlushall(List<String> args)
```
Redis command flushall.

Parameters:

args -

Returns:

fluent self

flushdb

public RedisAPI flushdb(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command flushdb.

Parameters:: args -; handler -
Returns:: fluent self

flushdbObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxFlushdb(List<String> args)
```
Redis command flushdb.

Parameters:

args -

Returns:

fluent self

geoadd

public RedisAPI geoadd(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command geoadd.

Parameters:: args -; handler -
Returns:: fluent self

geoaddObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxGeoadd(List<String> args)
```
Redis command geoadd.

Parameters:

args -

Returns:

fluent self

geodist

public RedisAPI geodist(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command geodist.

Parameters:: args -; handler -
Returns:: fluent self

geodistObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxGeodist(List<String> args)
```
Redis command geodist.

Parameters:

args -

Returns:

fluent self

geohash

public RedisAPI geohash(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command geohash.

Parameters:: args -; handler -
Returns:: fluent self

geohashObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxGeohash(List<String> args)
```
Redis command geohash.

Parameters:

args -

Returns:

fluent self

geopos

public RedisAPI geopos(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command geopos.

Parameters:: args -; handler -
Returns:: fluent self

geoposObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxGeopos(List<String> args)
```
Redis command geopos.

Parameters:

args -

Returns:

fluent self

georadius

public RedisAPI georadius(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command georadius.

Parameters:: args -; handler -
Returns:: fluent self

georadiusObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxGeoradius(List<String> args)
```
Redis command georadius.

Parameters:

args -

Returns:

fluent self

georadiusRo

public RedisAPI georadiusRo(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command georadiusRo.

Parameters:: args -; handler -
Returns:: fluent self

georadiusRoObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxGeoradiusRo(List<String> args)
```
Redis command georadiusRo.

Parameters:

args -

Returns:

fluent self

georadiusbymember

public RedisAPI georadiusbymember(List<String> args,
                                  io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command georadiusbymember.

Parameters:: args -; handler -
Returns:: fluent self

georadiusbymemberObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxGeoradiusbymember(List<String> args)
```
Redis command georadiusbymember.

Parameters:

args -

Returns:

fluent self

georadiusbymemberRo

public RedisAPI georadiusbymemberRo(List<String> args,
                                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command georadiusbymemberRo.

Parameters:: args -; handler -
Returns:: fluent self

georadiusbymemberRoObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxGeoradiusbymemberRo(List<String> args)
```
Redis command georadiusbymemberRo.

Parameters:

args -

Returns:

fluent self

get

public RedisAPI get(String arg0,
                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command get.

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

getObservable
```
@Deprecated
public rx.Observable<Response> getObservable(String arg0)
```
Deprecated. use rxGet(java.lang.String) instead

Redis command get.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

getbit

public RedisAPI getbit(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command getbit.

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

getbitObservable

@Deprecated
public rx.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 rx.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,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command getrange.

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

getrangeObservable

@Deprecated
public rx.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 rx.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,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command getset.

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

getsetObservable

@Deprecated
public rx.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 rx.Single<Response> rxGetset(String arg0,
                                    String arg1)

Redis command getset.

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

hdel

public RedisAPI hdel(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hdel.

Parameters:: args -; handler -
Returns:: fluent self

hdelObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxHdel(List<String> args)
```
Redis command hdel.

Parameters:

args -

Returns:

fluent self

hexists

public RedisAPI hexists(String arg0,
                        String arg1,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hexists.

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

hexistsObservable

@Deprecated
public rx.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 rx.Single<Response> rxHexists(String arg0,
                                     String arg1)

Redis command hexists.

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

hget

public RedisAPI hget(String arg0,
                     String arg1,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hget.

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

hgetObservable

@Deprecated
public rx.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 rx.Single<Response> rxHget(String arg0,
                                  String arg1)

Redis command hget.

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

hgetall

public RedisAPI hgetall(String arg0,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hgetall.

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

hgetallObservable
```
@Deprecated
public rx.Observable<Response> hgetallObservable(String arg0)
```
Deprecated. use rxHgetall(java.lang.String) instead

Redis command hgetall.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

hincrby

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

Redis command hincrby.

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

hincrbyObservable

@Deprecated
public rx.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 rx.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,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hincrbyfloat.

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

hincrbyfloatObservable

@Deprecated
public rx.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 rx.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,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hkeys.

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

hkeysObservable
```
@Deprecated
public rx.Observable<Response> hkeysObservable(String arg0)
```
Deprecated. use rxHkeys(java.lang.String) instead

Redis command hkeys.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

hlen

public RedisAPI hlen(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hlen.

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

hlenObservable
```
@Deprecated
public rx.Observable<Response> hlenObservable(String arg0)
```
Deprecated. use rxHlen(java.lang.String) instead

Redis command hlen.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

hmget

public RedisAPI hmget(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hmget.

Parameters:: args -; handler -
Returns:: fluent self

hmgetObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxHmget(List<String> args)
```
Redis command hmget.

Parameters:

args -

Returns:

fluent self

hmset

public RedisAPI hmset(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hmset.

Parameters:: args -; handler -
Returns:: fluent self

hmsetObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxHmset(List<String> args)
```
Redis command hmset.

Parameters:

args -

Returns:

fluent self

host

public RedisAPI host(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command host.

Parameters:: args -; handler -
Returns:: fluent self

hostObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxHost(List<String> args)
```
Redis command host.

Parameters:

args -

Returns:

fluent self

hscan

public RedisAPI hscan(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hscan.

Parameters:: args -; handler -
Returns:: fluent self

hscanObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxHscan(List<String> args)
```
Redis command hscan.

Parameters:

args -

Returns:

fluent self

hset

public RedisAPI hset(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hset.

Parameters:: args -; handler -
Returns:: fluent self

hsetObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxHset(List<String> args)
```
Redis command hset.

Parameters:

args -

Returns:

fluent self

hsetnx

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

Redis command hsetnx.

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

hsetnxObservable

@Deprecated
public rx.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 rx.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,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hstrlen.

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

hstrlenObservable

@Deprecated
public rx.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 rx.Single<Response> rxHstrlen(String arg0,
                                     String arg1)

Redis command hstrlen.

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

hvals

public RedisAPI hvals(String arg0,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command hvals.

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

hvalsObservable
```
@Deprecated
public rx.Observable<Response> hvalsObservable(String arg0)
```
Deprecated. use rxHvals(java.lang.String) instead

Redis command hvals.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

incr

public RedisAPI incr(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command incr.

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

incrObservable
```
@Deprecated
public rx.Observable<Response> incrObservable(String arg0)
```
Deprecated. use rxIncr(java.lang.String) instead

Redis command incr.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

incrby

public RedisAPI incrby(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command incrby.

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

incrbyObservable

@Deprecated
public rx.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 rx.Single<Response> rxIncrby(String arg0,
                                    String arg1)

Redis command incrby.

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

incrbyfloat

public RedisAPI incrbyfloat(String arg0,
                            String arg1,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command incrbyfloat.

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

incrbyfloatObservable

@Deprecated
public rx.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 rx.Single<Response> rxIncrbyfloat(String arg0,
                                         String arg1)

Redis command incrbyfloat.

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

info

public RedisAPI info(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command info.

Parameters:: args -; handler -
Returns:: fluent self

infoObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxInfo(List<String> args)
```
Redis command info.

Parameters:

args -

Returns:

fluent self

keys

public RedisAPI keys(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command keys.

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

keysObservable
```
@Deprecated
public rx.Observable<Response> keysObservable(String arg0)
```
Deprecated. use rxKeys(java.lang.String) instead

Redis command keys.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

lastsave

public RedisAPI lastsave(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command lastsave.

Parameters:: handler -
Returns:: fluent self

lastsaveObservable
```
@Deprecated
public rx.Observable<Response> lastsaveObservable()
```
Deprecated. use rxLastsave() instead

Redis command lastsave.

Returns:

fluent self

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

Returns:

fluent self

latency

public RedisAPI latency(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command latency.

Parameters:: args -; handler -
Returns:: fluent self

latencyObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxLatency(List<String> args)
```
Redis command latency.

Parameters:

args -

Returns:

fluent self

lindex

public RedisAPI lindex(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command lindex.

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

lindexObservable

@Deprecated
public rx.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 rx.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,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command linsert.

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

linsertObservable

@Deprecated
public rx.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 rx.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,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command llen.

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

llenObservable
```
@Deprecated
public rx.Observable<Response> llenObservable(String arg0)
```
Deprecated. use rxLlen(java.lang.String) instead

Redis command llen.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

lolwut

public RedisAPI lolwut(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command lolwut.

Parameters:: args -; handler -
Returns:: fluent self

lolwutObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxLolwut(List<String> args)
```
Redis command lolwut.

Parameters:

args -

Returns:

fluent self

lpop

public RedisAPI lpop(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command lpop.

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

lpopObservable
```
@Deprecated
public rx.Observable<Response> lpopObservable(String arg0)
```
Deprecated. use rxLpop(java.lang.String) instead

Redis command lpop.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

lpush

public RedisAPI lpush(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command lpush.

Parameters:: args -; handler -
Returns:: fluent self

lpushObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxLpush(List<String> args)
```
Redis command lpush.

Parameters:

args -

Returns:

fluent self

lpushx

public RedisAPI lpushx(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command lpushx.

Parameters:: args -; handler -
Returns:: fluent self

lpushxObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxLpushx(List<String> args)
```
Redis command lpushx.

Parameters:

args -

Returns:

fluent self

lrange

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

Redis command lrange.

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

lrangeObservable

@Deprecated
public rx.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 rx.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,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command lrem.

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

lremObservable

@Deprecated
public rx.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 rx.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,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command lset.

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

lsetObservable

@Deprecated
public rx.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 rx.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,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ltrim.

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

ltrimObservable

@Deprecated
public rx.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 rx.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,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command memory.

Parameters:: args -; handler -
Returns:: fluent self

memoryObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxMemory(List<String> args)
```
Redis command memory.

Parameters:

args -

Returns:

fluent self

mget

public RedisAPI mget(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command mget.

Parameters:: args -; handler -
Returns:: fluent self

mgetObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxMget(List<String> args)
```
Redis command mget.

Parameters:

args -

Returns:

fluent self

migrate

public RedisAPI migrate(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command migrate.

Parameters:: args -; handler -
Returns:: fluent self

migrateObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxMigrate(List<String> args)
```
Redis command migrate.

Parameters:

args -

Returns:

fluent self

module

public RedisAPI module(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command module.

Parameters:: args -; handler -
Returns:: fluent self

moduleObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxModule(List<String> args)
```
Redis command module.

Parameters:

args -

Returns:

fluent self

monitor

public RedisAPI monitor(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command monitor.

Parameters:: handler -
Returns:: fluent self

monitorObservable
```
@Deprecated
public rx.Observable<Response> monitorObservable()
```
Deprecated. use rxMonitor() instead

Redis command monitor.

Returns:

fluent self

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

Returns:

fluent self

move

public RedisAPI move(String arg0,
                     String arg1,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command move.

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

moveObservable

@Deprecated
public rx.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 rx.Single<Response> rxMove(String arg0,
                                  String arg1)

Redis command move.

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

mset

public RedisAPI mset(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command mset.

Parameters:: args -; handler -
Returns:: fluent self

msetObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxMset(List<String> args)
```
Redis command mset.

Parameters:

args -

Returns:

fluent self

msetnx

public RedisAPI msetnx(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command msetnx.

Parameters:: args -; handler -
Returns:: fluent self

msetnxObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxMsetnx(List<String> args)
```
Redis command msetnx.

Parameters:

args -

Returns:

fluent self

multi

public RedisAPI multi(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command multi.

Parameters:: handler -
Returns:: fluent self

multiObservable
```
@Deprecated
public rx.Observable<Response> multiObservable()
```
Deprecated. use rxMulti() instead

Redis command multi.

Returns:

fluent self

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

Returns:

fluent self

object

public RedisAPI object(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command object.

Parameters:: args -; handler -
Returns:: fluent self

objectObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxObject(List<String> args)
```
Redis command object.

Parameters:

args -

Returns:

fluent self

persist

public RedisAPI persist(String arg0,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command persist.

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

persistObservable
```
@Deprecated
public rx.Observable<Response> persistObservable(String arg0)
```
Deprecated. use rxPersist(java.lang.String) instead

Redis command persist.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

pexpire

public RedisAPI pexpire(String arg0,
                        String arg1,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command pexpire.

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

pexpireObservable

@Deprecated
public rx.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 rx.Single<Response> rxPexpire(String arg0,
                                     String arg1)

Redis command pexpire.

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

pexpireat

public RedisAPI pexpireat(String arg0,
                          String arg1,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command pexpireat.

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

pexpireatObservable

@Deprecated
public rx.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 rx.Single<Response> rxPexpireat(String arg0,
                                       String arg1)

Redis command pexpireat.

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

pfadd

public RedisAPI pfadd(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command pfadd.

Parameters:: args -; handler -
Returns:: fluent self

pfaddObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxPfadd(List<String> args)
```
Redis command pfadd.

Parameters:

args -

Returns:

fluent self

pfcount

public RedisAPI pfcount(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command pfcount.

Parameters:: args -; handler -
Returns:: fluent self

pfcountObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxPfcount(List<String> args)
```
Redis command pfcount.

Parameters:

args -

Returns:

fluent self

pfdebug

public RedisAPI pfdebug(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command pfdebug.

Parameters:: args -; handler -
Returns:: fluent self

pfdebugObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxPfdebug(List<String> args)
```
Redis command pfdebug.

Parameters:

args -

Returns:

fluent self

pfmerge

public RedisAPI pfmerge(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command pfmerge.

Parameters:: args -; handler -
Returns:: fluent self

pfmergeObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxPfmerge(List<String> args)
```
Redis command pfmerge.

Parameters:

args -

Returns:

fluent self

pfselftest

public RedisAPI pfselftest(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command pfselftest.

Parameters:: handler -
Returns:: fluent self

pfselftestObservable
```
@Deprecated
public rx.Observable<Response> pfselftestObservable()
```
Deprecated. use rxPfselftest() instead

Redis command pfselftest.

Returns:

fluent self

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

Returns:

fluent self

ping

public RedisAPI ping(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ping.

Parameters:: args -; handler -
Returns:: fluent self

pingObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxPing(List<String> args)
```
Redis command ping.

Parameters:

args -

Returns:

fluent self

post

public RedisAPI post(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command post.

Parameters:: args -; handler -
Returns:: fluent self

postObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxPost(List<String> args)
```
Redis command post.

Parameters:

args -

Returns:

fluent self

psetex

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

Redis command psetex.

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

psetexObservable

@Deprecated
public rx.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 rx.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,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command psubscribe.

Parameters:: args -; handler -
Returns:: fluent self

psubscribeObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxPsubscribe(List<String> args)
```
Redis command psubscribe.

Parameters:

args -

Returns:

fluent self

psync

public RedisAPI psync(String arg0,
                      String arg1,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command psync.

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

psyncObservable

@Deprecated
public rx.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 rx.Single<Response> rxPsync(String arg0,
                                   String arg1)

Redis command psync.

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

pttl

public RedisAPI pttl(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command pttl.

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

pttlObservable
```
@Deprecated
public rx.Observable<Response> pttlObservable(String arg0)
```
Deprecated. use rxPttl(java.lang.String) instead

Redis command pttl.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

publish

public RedisAPI publish(String arg0,
                        String arg1,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command publish.

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

publishObservable

@Deprecated
public rx.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 rx.Single<Response> rxPublish(String arg0,
                                     String arg1)

Redis command publish.

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

pubsub

public RedisAPI pubsub(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command pubsub.

Parameters:: args -; handler -
Returns:: fluent self

pubsubObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxPubsub(List<String> args)
```
Redis command pubsub.

Parameters:

args -

Returns:

fluent self

punsubscribe

public RedisAPI punsubscribe(List<String> args,
                             io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command punsubscribe.

Parameters:: args -; handler -
Returns:: fluent self

punsubscribeObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxPunsubscribe(List<String> args)
```
Redis command punsubscribe.

Parameters:

args -

Returns:

fluent self

randomkey

public RedisAPI randomkey(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command randomkey.

Parameters:: handler -
Returns:: fluent self

randomkeyObservable
```
@Deprecated
public rx.Observable<Response> randomkeyObservable()
```
Deprecated. use rxRandomkey() instead

Redis command randomkey.

Returns:

fluent self

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

Returns:

fluent self

readonly

public RedisAPI readonly(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command readonly.

Parameters:: handler -
Returns:: fluent self

readonlyObservable
```
@Deprecated
public rx.Observable<Response> readonlyObservable()
```
Deprecated. use rxReadonly() instead

Redis command readonly.

Returns:

fluent self

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

Returns:

fluent self

readwrite

public RedisAPI readwrite(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command readwrite.

Parameters:: handler -
Returns:: fluent self

readwriteObservable
```
@Deprecated
public rx.Observable<Response> readwriteObservable()
```
Deprecated. use rxReadwrite() instead

Redis command readwrite.

Returns:

fluent self

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

Returns:

fluent self

rename

public RedisAPI rename(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command rename.

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

renameObservable

@Deprecated
public rx.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 rx.Single<Response> rxRename(String arg0,
                                    String arg1)

Redis command rename.

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

renamenx

public RedisAPI renamenx(String arg0,
                         String arg1,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command renamenx.

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

renamenxObservable

@Deprecated
public rx.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 rx.Single<Response> rxRenamenx(String arg0,
                                      String arg1)

Redis command renamenx.

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

replconf

public RedisAPI replconf(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command replconf.

Parameters:: args -; handler -
Returns:: fluent self

replconfObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxReplconf(List<String> args)
```
Redis command replconf.

Parameters:

args -

Returns:

fluent self

replicaof

public RedisAPI replicaof(String arg0,
                          String arg1,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command replicaof.

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

replicaofObservable

@Deprecated
public rx.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 rx.Single<Response> rxReplicaof(String arg0,
                                       String arg1)

Redis command replicaof.

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

restore

public RedisAPI restore(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command restore.

Parameters:: args -; handler -
Returns:: fluent self

restoreObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxRestore(List<String> args)
```
Redis command restore.

Parameters:

args -

Returns:

fluent self

restoreAsking

public RedisAPI restoreAsking(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command restoreAsking.

Parameters:: args -; handler -
Returns:: fluent self

restoreAskingObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxRestoreAsking(List<String> args)
```
Redis command restoreAsking.

Parameters:

args -

Returns:

fluent self

role

public RedisAPI role(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command role.

Parameters:: handler -
Returns:: fluent self

roleObservable
```
@Deprecated
public rx.Observable<Response> roleObservable()
```
Deprecated. use rxRole() instead

Redis command role.

Returns:

fluent self

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

Returns:

fluent self

rpop

public RedisAPI rpop(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command rpop.

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

rpopObservable
```
@Deprecated
public rx.Observable<Response> rpopObservable(String arg0)
```
Deprecated. use rxRpop(java.lang.String) instead

Redis command rpop.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

rpoplpush

public RedisAPI rpoplpush(String arg0,
                          String arg1,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command rpoplpush.

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

rpoplpushObservable

@Deprecated
public rx.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 rx.Single<Response> rxRpoplpush(String arg0,
                                       String arg1)

Redis command rpoplpush.

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

rpush

public RedisAPI rpush(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command rpush.

Parameters:: args -; handler -
Returns:: fluent self

rpushObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxRpush(List<String> args)
```
Redis command rpush.

Parameters:

args -

Returns:

fluent self

rpushx

public RedisAPI rpushx(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command rpushx.

Parameters:: args -; handler -
Returns:: fluent self

rpushxObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxRpushx(List<String> args)
```
Redis command rpushx.

Parameters:

args -

Returns:

fluent self

sadd

public RedisAPI sadd(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command sadd.

Parameters:: args -; handler -
Returns:: fluent self

saddObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSadd(List<String> args)
```
Redis command sadd.

Parameters:

args -

Returns:

fluent self

save

public RedisAPI save(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command save.

Parameters:: handler -
Returns:: fluent self

saveObservable
```
@Deprecated
public rx.Observable<Response> saveObservable()
```
Deprecated. use rxSave() instead

Redis command save.

Returns:

fluent self

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

Returns:

fluent self

scan

public RedisAPI scan(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command scan.

Parameters:: args -; handler -
Returns:: fluent self

scanObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxScan(List<String> args)
```
Redis command scan.

Parameters:

args -

Returns:

fluent self

scard

public RedisAPI scard(String arg0,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command scard.

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

scardObservable
```
@Deprecated
public rx.Observable<Response> scardObservable(String arg0)
```
Deprecated. use rxScard(java.lang.String) instead

Redis command scard.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

script

public RedisAPI script(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command script.

Parameters:: args -; handler -
Returns:: fluent self

scriptObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxScript(List<String> args)
```
Redis command script.

Parameters:

args -

Returns:

fluent self

sdiff

public RedisAPI sdiff(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command sdiff.

Parameters:: args -; handler -
Returns:: fluent self

sdiffObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSdiff(List<String> args)
```
Redis command sdiff.

Parameters:

args -

Returns:

fluent self

sdiffstore

public RedisAPI sdiffstore(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command sdiffstore.

Parameters:: args -; handler -
Returns:: fluent self

sdiffstoreObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSdiffstore(List<String> args)
```
Redis command sdiffstore.

Parameters:

args -

Returns:

fluent self

select

public RedisAPI select(String arg0,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command select.

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

selectObservable
```
@Deprecated
public rx.Observable<Response> selectObservable(String arg0)
```
Deprecated. use rxSelect(java.lang.String) instead

Redis command select.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

set

public RedisAPI set(List<String> args,
                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command set.

Parameters:: args -; handler -
Returns:: fluent self

setObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSet(List<String> args)
```
Redis command set.

Parameters:

args -

Returns:

fluent self

setbit

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

Redis command setbit.

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

setbitObservable

@Deprecated
public rx.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 rx.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,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command setex.

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

setexObservable

@Deprecated
public rx.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 rx.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,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command setnx.

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

setnxObservable

@Deprecated
public rx.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 rx.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,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command setrange.

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

setrangeObservable

@Deprecated
public rx.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 rx.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,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command shutdown.

Parameters:: args -; handler -
Returns:: fluent self

shutdownObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxShutdown(List<String> args)
```
Redis command shutdown.

Parameters:

args -

Returns:

fluent self

sinter

public RedisAPI sinter(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command sinter.

Parameters:: args -; handler -
Returns:: fluent self

sinterObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSinter(List<String> args)
```
Redis command sinter.

Parameters:

args -

Returns:

fluent self

sinterstore

public RedisAPI sinterstore(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command sinterstore.

Parameters:: args -; handler -
Returns:: fluent self

sinterstoreObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSinterstore(List<String> args)
```
Redis command sinterstore.

Parameters:

args -

Returns:

fluent self

sismember

public RedisAPI sismember(String arg0,
                          String arg1,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command sismember.

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

sismemberObservable

@Deprecated
public rx.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 rx.Single<Response> rxSismember(String arg0,
                                       String arg1)

Redis command sismember.

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

slaveof

public RedisAPI slaveof(String arg0,
                        String arg1,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command slaveof.

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

slaveofObservable

@Deprecated
public rx.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 rx.Single<Response> rxSlaveof(String arg0,
                                     String arg1)

Redis command slaveof.

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

slowlog

public RedisAPI slowlog(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command slowlog.

Parameters:: args -; handler -
Returns:: fluent self

slowlogObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSlowlog(List<String> args)
```
Redis command slowlog.

Parameters:

args -

Returns:

fluent self

smembers

public RedisAPI smembers(String arg0,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command smembers.

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

smembersObservable
```
@Deprecated
public rx.Observable<Response> smembersObservable(String arg0)
```
Deprecated. use rxSmembers(java.lang.String) instead

Redis command smembers.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

smove

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

Redis command smove.

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

smoveObservable

@Deprecated
public rx.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 rx.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,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command sort.

Parameters:: args -; handler -
Returns:: fluent self

sortObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSort(List<String> args)
```
Redis command sort.

Parameters:

args -

Returns:

fluent self

spop

public RedisAPI spop(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command spop.

Parameters:: args -; handler -
Returns:: fluent self

spopObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSpop(List<String> args)
```
Redis command spop.

Parameters:

args -

Returns:

fluent self

srandmember

public RedisAPI srandmember(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command srandmember.

Parameters:: args -; handler -
Returns:: fluent self

srandmemberObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSrandmember(List<String> args)
```
Redis command srandmember.

Parameters:

args -

Returns:

fluent self

srem

public RedisAPI srem(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command srem.

Parameters:: args -; handler -
Returns:: fluent self

sremObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSrem(List<String> args)
```
Redis command srem.

Parameters:

args -

Returns:

fluent self

sscan

public RedisAPI sscan(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command sscan.

Parameters:: args -; handler -
Returns:: fluent self

sscanObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSscan(List<String> args)
```
Redis command sscan.

Parameters:

args -

Returns:

fluent self

strlen

public RedisAPI strlen(String arg0,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command strlen.

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

strlenObservable
```
@Deprecated
public rx.Observable<Response> strlenObservable(String arg0)
```
Deprecated. use rxStrlen(java.lang.String) instead

Redis command strlen.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

public RedisAPI subscribe(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command subscribe.

Parameters:: args -; handler -
Returns:: fluent self

subscribeObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSubscribe(List<String> args)
```
Redis command subscribe.

Parameters:

args -

Returns:

fluent self

substr

public RedisAPI substr(String arg0,
                       String arg1,
                       String arg2,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command substr.

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

substrObservable

@Deprecated
public rx.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 rx.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,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command sunion.

Parameters:: args -; handler -
Returns:: fluent self

sunionObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSunion(List<String> args)
```
Redis command sunion.

Parameters:

args -

Returns:

fluent self

sunionstore

public RedisAPI sunionstore(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command sunionstore.

Parameters:: args -; handler -
Returns:: fluent self

sunionstoreObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxSunionstore(List<String> args)
```
Redis command sunionstore.

Parameters:

args -

Returns:

fluent self

swapdb

public RedisAPI swapdb(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command swapdb.

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

swapdbObservable

@Deprecated
public rx.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 rx.Single<Response> rxSwapdb(String arg0,
                                    String arg1)

Redis command swapdb.

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

sync

public RedisAPI sync(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command sync.

Parameters:: handler -
Returns:: fluent self

syncObservable
```
@Deprecated
public rx.Observable<Response> syncObservable()
```
Deprecated. use rxSync() instead

Redis command sync.

Returns:

fluent self

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

Returns:

fluent self

time

public RedisAPI time(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command time.

Parameters:: handler -
Returns:: fluent self

timeObservable
```
@Deprecated
public rx.Observable<Response> timeObservable()
```
Deprecated. use rxTime() instead

Redis command time.

Returns:

fluent self

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

Returns:

fluent self

touch

public RedisAPI touch(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command touch.

Parameters:: args -; handler -
Returns:: fluent self

touchObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxTouch(List<String> args)
```
Redis command touch.

Parameters:

args -

Returns:

fluent self

ttl

public RedisAPI ttl(String arg0,
                    io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command ttl.

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

ttlObservable
```
@Deprecated
public rx.Observable<Response> ttlObservable(String arg0)
```
Deprecated. use rxTtl(java.lang.String) instead

Redis command ttl.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

type

public RedisAPI type(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command type.

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

typeObservable
```
@Deprecated
public rx.Observable<Response> typeObservable(String arg0)
```
Deprecated. use rxType(java.lang.String) instead

Redis command type.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

unlink

public RedisAPI unlink(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command unlink.

Parameters:: args -; handler -
Returns:: fluent self

unlinkObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxUnlink(List<String> args)
```
Redis command unlink.

Parameters:

args -

Returns:

fluent self

unsubscribe

public RedisAPI unsubscribe(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command unsubscribe.

Parameters:: args -; handler -
Returns:: fluent self

unsubscribeObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxUnsubscribe(List<String> args)
```
Redis command unsubscribe.

Parameters:

args -

Returns:

fluent self

unwatch

public RedisAPI unwatch(io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command unwatch.

Parameters:: handler -
Returns:: fluent self

unwatchObservable
```
@Deprecated
public rx.Observable<Response> unwatchObservable()
```
Deprecated. use rxUnwatch() instead

Redis command unwatch.

Returns:

fluent self

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

Returns:

fluent self

wait

public RedisAPI wait(String arg0,
                     String arg1,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command wait.

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

waitObservable

@Deprecated
public rx.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 rx.Single<Response> rxWait(String arg0,
                                  String arg1)

Redis command wait.

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

watch

public RedisAPI watch(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command watch.

Parameters:: args -; handler -
Returns:: fluent self

watchObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxWatch(List<String> args)
```
Redis command watch.

Parameters:

args -

Returns:

fluent self

xack

public RedisAPI xack(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xack.

Parameters:: args -; handler -
Returns:: fluent self

xackObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXack(List<String> args)
```
Redis command xack.

Parameters:

args -

Returns:

fluent self

xadd

public RedisAPI xadd(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xadd.

Parameters:: args -; handler -
Returns:: fluent self

xaddObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXadd(List<String> args)
```
Redis command xadd.

Parameters:

args -

Returns:

fluent self

xclaim

public RedisAPI xclaim(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xclaim.

Parameters:: args -; handler -
Returns:: fluent self

xclaimObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXclaim(List<String> args)
```
Redis command xclaim.

Parameters:

args -

Returns:

fluent self

xdel

public RedisAPI xdel(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xdel.

Parameters:: args -; handler -
Returns:: fluent self

xdelObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXdel(List<String> args)
```
Redis command xdel.

Parameters:

args -

Returns:

fluent self

xgroup

public RedisAPI xgroup(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xgroup.

Parameters:: args -; handler -
Returns:: fluent self

xgroupObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXgroup(List<String> args)
```
Redis command xgroup.

Parameters:

args -

Returns:

fluent self

xinfo

public RedisAPI xinfo(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xinfo.

Parameters:: args -; handler -
Returns:: fluent self

xinfoObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXinfo(List<String> args)
```
Redis command xinfo.

Parameters:

args -

Returns:

fluent self

xlen

public RedisAPI xlen(String arg0,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xlen.

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

xlenObservable
```
@Deprecated
public rx.Observable<Response> xlenObservable(String arg0)
```
Deprecated. use rxXlen(java.lang.String) instead

Redis command xlen.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

xpending

public RedisAPI xpending(List<String> args,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xpending.

Parameters:: args -; handler -
Returns:: fluent self

xpendingObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXpending(List<String> args)
```
Redis command xpending.

Parameters:

args -

Returns:

fluent self

xrange

public RedisAPI xrange(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xrange.

Parameters:: args -; handler -
Returns:: fluent self

xrangeObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXrange(List<String> args)
```
Redis command xrange.

Parameters:

args -

Returns:

fluent self

xread

public RedisAPI xread(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xread.

Parameters:: args -; handler -
Returns:: fluent self

xreadObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXread(List<String> args)
```
Redis command xread.

Parameters:

args -

Returns:

fluent self

xreadgroup

public RedisAPI xreadgroup(List<String> args,
                           io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xreadgroup.

Parameters:: args -; handler -
Returns:: fluent self

xreadgroupObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXreadgroup(List<String> args)
```
Redis command xreadgroup.

Parameters:

args -

Returns:

fluent self

xrevrange

public RedisAPI xrevrange(List<String> args,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xrevrange.

Parameters:: args -; handler -
Returns:: fluent self

xrevrangeObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXrevrange(List<String> args)
```
Redis command xrevrange.

Parameters:

args -

Returns:

fluent self

xsetid

public RedisAPI xsetid(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xsetid.

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

xsetidObservable

@Deprecated
public rx.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 rx.Single<Response> rxXsetid(String arg0,
                                    String arg1)

Redis command xsetid.

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

xtrim

public RedisAPI xtrim(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command xtrim.

Parameters:: args -; handler -
Returns:: fluent self

xtrimObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxXtrim(List<String> args)
```
Redis command xtrim.

Parameters:

args -

Returns:

fluent self

zadd

public RedisAPI zadd(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zadd.

Parameters:: args -; handler -
Returns:: fluent self

zaddObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZadd(List<String> args)
```
Redis command zadd.

Parameters:

args -

Returns:

fluent self

zcard

public RedisAPI zcard(String arg0,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zcard.

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

zcardObservable
```
@Deprecated
public rx.Observable<Response> zcardObservable(String arg0)
```
Deprecated. use rxZcard(java.lang.String) instead

Redis command zcard.

Parameters:

arg0 -

Returns:

fluent self

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

Parameters:

arg0 -

Returns:

fluent self

zcount

public RedisAPI zcount(String arg0,
                       String arg1,
                       String arg2,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zcount.

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

zcountObservable

@Deprecated
public rx.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 rx.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,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zincrby.

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

zincrbyObservable

@Deprecated
public rx.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 rx.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,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zinterstore.

Parameters:: args -; handler -
Returns:: fluent self

zinterstoreObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZinterstore(List<String> args)
```
Redis command zinterstore.

Parameters:

args -

Returns:

fluent self

zlexcount

public RedisAPI zlexcount(String arg0,
                          String arg1,
                          String arg2,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zlexcount.

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

zlexcountObservable

@Deprecated
public rx.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 rx.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,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zpopmax.

Parameters:: args -; handler -
Returns:: fluent self

zpopmaxObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZpopmax(List<String> args)
```
Redis command zpopmax.

Parameters:

args -

Returns:

fluent self

zpopmin

public RedisAPI zpopmin(List<String> args,
                        io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zpopmin.

Parameters:: args -; handler -
Returns:: fluent self

zpopminObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZpopmin(List<String> args)
```
Redis command zpopmin.

Parameters:

args -

Returns:

fluent self

zrange

public RedisAPI zrange(List<String> args,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zrange.

Parameters:: args -; handler -
Returns:: fluent self

zrangeObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZrange(List<String> args)
```
Redis command zrange.

Parameters:

args -

Returns:

fluent self

zrangebylex

public RedisAPI zrangebylex(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zrangebylex.

Parameters:: args -; handler -
Returns:: fluent self

zrangebylexObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZrangebylex(List<String> args)
```
Redis command zrangebylex.

Parameters:

args -

Returns:

fluent self

zrangebyscore

public RedisAPI zrangebyscore(List<String> args,
                              io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zrangebyscore.

Parameters:: args -; handler -
Returns:: fluent self

zrangebyscoreObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZrangebyscore(List<String> args)
```
Redis command zrangebyscore.

Parameters:

args -

Returns:

fluent self

zrank

public RedisAPI zrank(String arg0,
                      String arg1,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zrank.

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

zrankObservable

@Deprecated
public rx.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 rx.Single<Response> rxZrank(String arg0,
                                   String arg1)

Redis command zrank.

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

zrem

public RedisAPI zrem(List<String> args,
                     io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zrem.

Parameters:: args -; handler -
Returns:: fluent self

zremObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZrem(List<String> args)
```
Redis command zrem.

Parameters:

args -

Returns:

fluent self

zremrangebylex

public RedisAPI zremrangebylex(String arg0,
                               String arg1,
                               String arg2,
                               io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zremrangebylex.

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

zremrangebylexObservable

@Deprecated
public rx.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 rx.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,
                                io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zremrangebyrank.

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

zremrangebyrankObservable

@Deprecated
public rx.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 rx.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,
                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zremrangebyscore.

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

zremrangebyscoreObservable

@Deprecated
public rx.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 rx.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,
                          io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zrevrange.

Parameters:: args -; handler -
Returns:: fluent self

zrevrangeObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZrevrange(List<String> args)
```
Redis command zrevrange.

Parameters:

args -

Returns:

fluent self

zrevrangebylex

public RedisAPI zrevrangebylex(List<String> args,
                               io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zrevrangebylex.

Parameters:: args -; handler -
Returns:: fluent self

zrevrangebylexObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZrevrangebylex(List<String> args)
```
Redis command zrevrangebylex.

Parameters:

args -

Returns:

fluent self

zrevrangebyscore

public RedisAPI zrevrangebyscore(List<String> args,
                                 io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zrevrangebyscore.

Parameters:: args -; handler -
Returns:: fluent self

zrevrangebyscoreObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZrevrangebyscore(List<String> args)
```
Redis command zrevrangebyscore.

Parameters:

args -

Returns:

fluent self

zrevrank

public RedisAPI zrevrank(String arg0,
                         String arg1,
                         io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zrevrank.

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

zrevrankObservable

@Deprecated
public rx.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 rx.Single<Response> rxZrevrank(String arg0,
                                      String arg1)

Redis command zrevrank.

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

zscan

public RedisAPI zscan(List<String> args,
                      io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zscan.

Parameters:: args -; handler -
Returns:: fluent self

zscanObservable
```
@Deprecated
public rx.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 rx.Single<Response> rxZscan(List<String> args)
```
Redis command zscan.

Parameters:

args -

Returns:

fluent self

zscore

public RedisAPI zscore(String arg0,
                       String arg1,
                       io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zscore.

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

zscoreObservable

@Deprecated
public rx.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 rx.Single<Response> rxZscore(String arg0,
                                    String arg1)

Redis command zscore.

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

zunionstore

public RedisAPI zunionstore(List<String> args,
                            io.vertx.core.Handler<io.vertx.core.AsyncResult<Response>> handler)

Redis command zunionstore.

Parameters:: args -; handler -
Returns:: fluent self

zunionstoreObservable
```
@Deprecated
public rx.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 rx.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(io.vertx.redis.client.RedisAPI arg)

Class RedisAPI

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

__TYPE_ARG

Constructor Detail

RedisAPI

RedisAPI

Method Detail

toString

equals

hashCode

getDelegate

close

append

appendObservable

rxAppend

asking

askingObservable

rxAsking

auth

authObservable

rxAuth

bgrewriteaof

bgrewriteaofObservable

rxBgrewriteaof

bgsave

bgsaveObservable

rxBgsave

bitcount

bitcountObservable

rxBitcount

bitfield

bitfieldObservable

rxBitfield

bitop

bitopObservable

rxBitop

bitpos

bitposObservable

rxBitpos

blpop

blpopObservable

rxBlpop

brpop

brpopObservable

rxBrpop

brpoplpush

brpoplpushObservable

rxBrpoplpush

bzpopmax

bzpopmaxObservable

rxBzpopmax

bzpopmin

bzpopminObservable

rxBzpopmin

client

clientObservable

rxClient

cluster

clusterObservable

rxCluster

command

commandObservable

rxCommand

config

configObservable

rxConfig

dbsize

dbsizeObservable

rxDbsize

debug

debugObservable

rxDebug

decr

decrObservable

rxDecr

decrby