/*
 * Copyright 2014 Red Hat, Inc.
 *
 * Red Hat licenses this file to you under the Apache License, version 2.0
 * (the "License"); you may not use this file except in compliance with the
 * License.  You may obtain a copy of the License at:
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
 * License for the specific language governing permissions and limitations
 * under the License.
 */

package io.vertx.rxjava.redis;

import java.util.Map;
import rx.Observable;
import rx.Single;
import io.vertx.redis.op.BitOperation;
import io.vertx.redis.op.ResetOptions;
import io.vertx.redis.op.ObjectCmd;
import io.vertx.redis.op.KillFilter;
import io.vertx.redis.op.ClientReplyOptions;
import java.util.Map;
import io.vertx.redis.op.GeoUnit;
import io.vertx.core.json.JsonObject;
import io.vertx.core.AsyncResult;
import io.vertx.redis.op.RangeOptions;
import io.vertx.redis.op.GeoMember;
import io.vertx.redis.op.GeoRadiusOptions;
import io.vertx.redis.op.InsertOptions;
import io.vertx.redis.op.AggregateOptions;
import io.vertx.redis.op.SetOptions;
import io.vertx.redis.op.SortOptions;
import io.vertx.redis.op.MigrateOptions;
import io.vertx.redis.op.ScanOptions;
import io.vertx.redis.op.BitFieldOptions;
import io.vertx.redis.op.ScriptDebugOptions;
import io.vertx.redis.op.FailoverOptions;
import io.vertx.redis.op.SlotCmd;
import io.vertx.redis.op.BitFieldOverflowOptions;
import io.vertx.redis.op.RangeLimitOptions;
import io.vertx.redis.op.LimitOptions;
import io.vertx.core.json.JsonArray;
import java.util.List;
import io.vertx.core.Handler;


@io.vertx.lang.rx.RxGen(io.vertx.redis.RedisClient.class)
public class RedisClient {

  @Override
  public String toString() {
    return delegate.toString();
  }

  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    RedisClient that = (RedisClient) o;
    return delegate.equals(that.delegate);
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

  public static final io.vertx.lang.rx.TypeArg<RedisClient> __TYPE_ARG = new io.vertx.lang.rx.TypeArg<>(    obj -> new RedisClient((io.vertx.redis.RedisClient) obj),
    RedisClient::getDelegate
  );

  private final io.vertx.redis.RedisClient delegate;
  
  public RedisClient(io.vertx.redis.RedisClient delegate) {
    this.delegate = delegate;
  }

  public io.vertx.redis.RedisClient getDelegate() {
    return delegate;
  }

  public static io.vertx.rxjava.redis.RedisClient create(io.vertx.rxjava.core.Vertx vertx) { 
    io.vertx.rxjava.redis.RedisClient ret = io.vertx.rxjava.redis.RedisClient.newInstance(io.vertx.redis.RedisClient.create(vertx.getDelegate()));
    return ret;
  }

  public static io.vertx.rxjava.redis.RedisClient create(io.vertx.rxjava.core.Vertx vertx, JsonObject config) { 
    io.vertx.rxjava.redis.RedisClient ret = io.vertx.rxjava.redis.RedisClient.newInstance(io.vertx.redis.RedisClient.create(vertx.getDelegate(), config));
    return ret;
  }

  
Close the client - when it is fully closed the handler will be called.
Params:
handler – /**
   * Close the client - when it is fully closed the handler will be called.
   * @param handler 
   */
  public void close(Handler<AsyncResult<Void>> handler) { 
    delegate.close(handler);
  }

    
Close the client - when it is fully closed the handler will be called.
Returns:
Deprecated:
use rxClose instead/**
   * Close the client - when it is fully closed the handler will be called.
   * @return 
   * @deprecated use {@link #rxClose} instead
   */
  @Deprecated()
  public Observable<Void> closeObservable() { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    close(handler.toHandler());
    return handler;
  }

  
Close the client - when it is fully closed the handler will be called.
Returns:
/**
   * Close the client - when it is fully closed the handler will be called.
   * @return 
   */
  public Single<Void> rxClose() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      close(fut);
    }));
  }

  
Append a value to a key
Params:
key – Key string
value – Value to append
handler – Handler for the result of this call.
Returns:
/**
   * Append a value to a key
   * @param key Key string
   * @param value Value to append
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient append(String key, String value, Handler<AsyncResult<Long>> handler) { 
    delegate.append(key, value, handler);
    return this;
  }

    
Append a value to a key
Params:
key – Key string
value – Value to append
Returns:
Deprecated:
use rxAppend instead/**
   * Append a value to a key
   * @param key Key string
   * @param value Value to append
   * @return 
   * @deprecated use {@link #rxAppend} instead
   */
  @Deprecated()
  public Observable<Long> appendObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    append(key, value, handler.toHandler());
    return handler;
  }

  
Append a value to a key
Params:
key – Key string
value – Value to append
Returns:
/**
   * Append a value to a key
   * @param key Key string
   * @param value Value to append
   * @return 
   */
  public Single<Long> rxAppend(String key, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      append(key, value, fut);
    }));
  }

  
Authenticate to the server
Params:
password – Password for authentication
handler – Handler for the result of this call.
Returns:
/**
   * Authenticate to the server
   * @param password Password for authentication
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient auth(String password, Handler<AsyncResult<String>> handler) { 
    delegate.auth(password, handler);
    return this;
  }

    
Authenticate to the server
Params:
password – Password for authentication
Returns:
Deprecated:
use rxAuth instead/**
   * Authenticate to the server
   * @param password Password for authentication
   * @return 
   * @deprecated use {@link #rxAuth} instead
   */
  @Deprecated()
  public Observable<String> authObservable(String password) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    auth(password, handler.toHandler());
    return handler;
  }

  
Authenticate to the server
Params:
password – Password for authentication
Returns:
/**
   * Authenticate to the server
   * @param password Password for authentication
   * @return 
   */
  public Single<String> rxAuth(String password) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      auth(password, fut);
    }));
  }

  
Asynchronously rewrite the append-only file
Params:
handler – 
Returns:
/**
   * Asynchronously rewrite the append-only file
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient bgrewriteaof(Handler<AsyncResult<String>> handler) { 
    delegate.bgrewriteaof(handler);
    return this;
  }

    
Asynchronously rewrite the append-only file
Returns:
Deprecated:
use rxBgrewriteaof instead/**
   * Asynchronously rewrite the append-only file
   * @return 
   * @deprecated use {@link #rxBgrewriteaof} instead
   */
  @Deprecated()
  public Observable<String> bgrewriteaofObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    bgrewriteaof(handler.toHandler());
    return handler;
  }

  
Asynchronously rewrite the append-only file
Returns:
/**
   * Asynchronously rewrite the append-only file
   * @return 
   */
  public Single<String> rxBgrewriteaof() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bgrewriteaof(fut);
    }));
  }

  
Asynchronously save the dataset to disk
Params:
handler – 
Returns:
/**
   * Asynchronously save the dataset to disk
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient bgsave(Handler<AsyncResult<String>> handler) { 
    delegate.bgsave(handler);
    return this;
  }

    
Asynchronously save the dataset to disk
Returns:
Deprecated:
use rxBgsave instead/**
   * Asynchronously save the dataset to disk
   * @return 
   * @deprecated use {@link #rxBgsave} instead
   */
  @Deprecated()
  public Observable<String> bgsaveObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    bgsave(handler.toHandler());
    return handler;
  }

  
Asynchronously save the dataset to disk
Returns:
/**
   * Asynchronously save the dataset to disk
   * @return 
   */
  public Single<String> rxBgsave() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bgsave(fut);
    }));
  }

  
Count set bits in a string
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Count set bits in a string
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient bitcount(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.bitcount(key, handler);
    return this;
  }

    
Count set bits in a string
Params:
key – Key string
Returns:
Deprecated:
use rxBitcount instead/**
   * Count set bits in a string
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxBitcount} instead
   */
  @Deprecated()
  public Observable<Long> bitcountObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitcount(key, handler.toHandler());
    return handler;
  }

  
Count set bits in a string
Params:
key – Key string
Returns:
/**
   * Count set bits in a string
   * @param key Key string
   * @return 
   */
  public Single<Long> rxBitcount(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitcount(key, fut);
    }));
  }

  
Count set bits in a string
Params:
key – Key string
start – Start index
end – End index
handler – Handler for the result of this call.
Returns:
/**
   * Count set bits in a string
   * @param key Key string
   * @param start Start index
   * @param end End index
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient bitcountRange(String key, long start, long end, Handler<AsyncResult<Long>> handler) { 
    delegate.bitcountRange(key, start, end, handler);
    return this;
  }

    
Count set bits in a string
Params:
key – Key string
start – Start index
end – End index
Returns:
Deprecated:
use rxBitcountRange instead/**
   * Count set bits in a string
   * @param key Key string
   * @param start Start index
   * @param end End index
   * @return 
   * @deprecated use {@link #rxBitcountRange} instead
   */
  @Deprecated()
  public Observable<Long> bitcountRangeObservable(String key, long start, long end) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitcountRange(key, start, end, handler.toHandler());
    return handler;
  }

  
Count set bits in a string
Params:
key – Key string
start – Start index
end – End index
Returns:
/**
   * Count set bits in a string
   * @param key Key string
   * @param start Start index
   * @param end End index
   * @return 
   */
  public Single<Long> rxBitcountRange(String key, long start, long end) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitcountRange(key, start, end, fut);
    }));
  }

  
Perform bitwise operations between strings
Params:
operation – Bitwise operation to perform
destkey – Destination key where result is stored
keys – List of keys on which to perform the operation
handler – Handler for the result of this call.
Returns:
/**
   * Perform bitwise operations between strings
   * @param operation Bitwise operation to perform
   * @param destkey Destination key where result is stored
   * @param keys List of keys on which to perform the operation
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient bitop(BitOperation operation, String destkey, List<String> keys, Handler<AsyncResult<Long>> handler) { 
    delegate.bitop(operation, destkey, keys, handler);
    return this;
  }

    
Perform bitwise operations between strings
Params:
operation – Bitwise operation to perform
destkey – Destination key where result is stored
keys – List of keys on which to perform the operation
Returns:
Deprecated:
use rxBitop instead/**
   * Perform bitwise operations between strings
   * @param operation Bitwise operation to perform
   * @param destkey Destination key where result is stored
   * @param keys List of keys on which to perform the operation
   * @return 
   * @deprecated use {@link #rxBitop} instead
   */
  @Deprecated()
  public Observable<Long> bitopObservable(BitOperation operation, String destkey, List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitop(operation, destkey, keys, handler.toHandler());
    return handler;
  }

  
Perform bitwise operations between strings
Params:
operation – Bitwise operation to perform
destkey – Destination key where result is stored
keys – List of keys on which to perform the operation
Returns:
/**
   * Perform bitwise operations between strings
   * @param operation Bitwise operation to perform
   * @param destkey Destination key where result is stored
   * @param keys List of keys on which to perform the operation
   * @return 
   */
  public Single<Long> rxBitop(BitOperation operation, String destkey, List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitop(operation, destkey, keys, fut);
    }));
  }

  
Find first bit set or clear in a string
Params:
key – Key string
bit – What bit value to look for - must be 1, or 0
handler – Handler for the result of this call.
Returns:
/**
   * Find first bit set or clear in a string
   * @param key Key string
   * @param bit What bit value to look for - must be 1, or 0
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient bitpos(String key, int bit, Handler<AsyncResult<Long>> handler) { 
    delegate.bitpos(key, bit, handler);
    return this;
  }

    
Find first bit set or clear in a string
Params:
key – Key string
bit – What bit value to look for - must be 1, or 0
Returns:
Deprecated:
use rxBitpos instead/**
   * Find first bit set or clear in a string
   * @param key Key string
   * @param bit What bit value to look for - must be 1, or 0
   * @return 
   * @deprecated use {@link #rxBitpos} instead
   */
  @Deprecated()
  public Observable<Long> bitposObservable(String key, int bit) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitpos(key, bit, handler.toHandler());
    return handler;
  }

  
Find first bit set or clear in a string
Params:
key – Key string
bit – What bit value to look for - must be 1, or 0
Returns:
/**
   * Find first bit set or clear in a string
   * @param key Key string
   * @param bit What bit value to look for - must be 1, or 0
   * @return 
   */
  public Single<Long> rxBitpos(String key, int bit) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitpos(key, bit, fut);
    }));
  }

  
Find first bit set or clear in a string
See also bitposRange() method, which takes start, and stop offset.
Params:
key – Key string
bit – What bit value to look for - must be 1, or 0
start – Start offset
handler – Handler for the result of this call.
Returns:
/**
   * Find first bit set or clear in a string
   *
   * See also bitposRange() method, which takes start, and stop offset.
   * @param key Key string
   * @param bit What bit value to look for - must be 1, or 0
   * @param start Start offset
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient bitposFrom(String key, int bit, int start, Handler<AsyncResult<Long>> handler) { 
    delegate.bitposFrom(key, bit, start, handler);
    return this;
  }

    
Find first bit set or clear in a string
See also bitposRange() method, which takes start, and stop offset.
Params:
key – Key string
bit – What bit value to look for - must be 1, or 0
start – Start offset
Returns:
Deprecated:
use rxBitposFrom instead/**
   * Find first bit set or clear in a string
   *
   * See also bitposRange() method, which takes start, and stop offset.
   * @param key Key string
   * @param bit What bit value to look for - must be 1, or 0
   * @param start Start offset
   * @return 
   * @deprecated use {@link #rxBitposFrom} instead
   */
  @Deprecated()
  public Observable<Long> bitposFromObservable(String key, int bit, int start) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitposFrom(key, bit, start, handler.toHandler());
    return handler;
  }

  
Find first bit set or clear in a string
See also bitposRange() method, which takes start, and stop offset.
Params:
key – Key string
bit – What bit value to look for - must be 1, or 0
start – Start offset
Returns:
/**
   * Find first bit set or clear in a string
   *
   * See also bitposRange() method, which takes start, and stop offset.
   * @param key Key string
   * @param bit What bit value to look for - must be 1, or 0
   * @param start Start offset
   * @return 
   */
  public Single<Long> rxBitposFrom(String key, int bit, int start) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitposFrom(key, bit, start, fut);
    }));
  }

  
Find first bit set or clear in a string
Note: when both start, and stop offsets are specified,
behaviour is slightly different than if only start is specified
Params:
key – Key string
bit – What bit value to look for - must be 1, or 0
start – Start offset
stop – End offset - inclusive
handler – Handler for the result of this call.
Returns:
/**
   * Find first bit set or clear in a string
   *
   * Note: when both start, and stop offsets are specified,
   * behaviour is slightly different than if only start is specified
   * @param key Key string
   * @param bit What bit value to look for - must be 1, or 0
   * @param start Start offset
   * @param stop End offset - inclusive
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient bitposRange(String key, int bit, int start, int stop, Handler<AsyncResult<Long>> handler) { 
    delegate.bitposRange(key, bit, start, stop, handler);
    return this;
  }

    
Find first bit set or clear in a string
Note: when both start, and stop offsets are specified,
behaviour is slightly different than if only start is specified
Params:
key – Key string
bit – What bit value to look for - must be 1, or 0
start – Start offset
stop – End offset - inclusive
Returns:
Deprecated:
use rxBitposRange instead/**
   * Find first bit set or clear in a string
   *
   * Note: when both start, and stop offsets are specified,
   * behaviour is slightly different than if only start is specified
   * @param key Key string
   * @param bit What bit value to look for - must be 1, or 0
   * @param start Start offset
   * @param stop End offset - inclusive
   * @return 
   * @deprecated use {@link #rxBitposRange} instead
   */
  @Deprecated()
  public Observable<Long> bitposRangeObservable(String key, int bit, int start, int stop) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitposRange(key, bit, start, stop, handler.toHandler());
    return handler;
  }

  
Find first bit set or clear in a string
Note: when both start, and stop offsets are specified,
behaviour is slightly different than if only start is specified
Params:
key – Key string
bit – What bit value to look for - must be 1, or 0
start – Start offset
stop – End offset - inclusive
Returns:
/**
   * Find first bit set or clear in a string
   *
   * Note: when both start, and stop offsets are specified,
   * behaviour is slightly different than if only start is specified
   * @param key Key string
   * @param bit What bit value to look for - must be 1, or 0
   * @param start Start offset
   * @param stop End offset - inclusive
   * @return 
   */
  public Single<Long> rxBitposRange(String key, int bit, int start, int stop) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitposRange(key, bit, start, stop, fut);
    }));
  }

  
Remove and get the first element in a list, or block until one is available
Params:
key – Key string identifying a list to watch
seconds – Timeout in seconds
handler – Handler for the result of this call.
Returns:
/**
   * Remove and get the first element in a list, or block until one is available
   * @param key Key string identifying a list to watch
   * @param seconds Timeout in seconds
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient blpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.blpop(key, seconds, handler);
    return this;
  }

    
Remove and get the first element in a list, or block until one is available
Params:
key – Key string identifying a list to watch
seconds – Timeout in seconds
Returns:
Deprecated:
use rxBlpop instead/**
   * Remove and get the first element in a list, or block until one is available
   * @param key Key string identifying a list to watch
   * @param seconds Timeout in seconds
   * @return 
   * @deprecated use {@link #rxBlpop} instead
   */
  @Deprecated()
  public Observable<JsonArray> blpopObservable(String key, int seconds) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    blpop(key, seconds, handler.toHandler());
    return handler;
  }

  
Remove and get the first element in a list, or block until one is available
Params:
key – Key string identifying a list to watch
seconds – Timeout in seconds
Returns:
/**
   * Remove and get the first element in a list, or block until one is available
   * @param key Key string identifying a list to watch
   * @param seconds Timeout in seconds
   * @return 
   */
  public Single<JsonArray> rxBlpop(String key, int seconds) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      blpop(key, seconds, fut);
    }));
  }

  
Remove and get the first element in any of the lists, or block until one is available
Params:
keys – List of key strings identifying lists to watch
seconds – Timeout in seconds
handler – Handler for the result of this call.
Returns:
/**
   * Remove and get the first element in any of the lists, or block until one is available
   * @param keys List of key strings identifying lists to watch
   * @param seconds Timeout in seconds
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient blpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.blpopMany(keys, seconds, handler);
    return this;
  }

    
Remove and get the first element in any of the lists, or block until one is available
Params:
keys – List of key strings identifying lists to watch
seconds – Timeout in seconds
Returns:
Deprecated:
use rxBlpopMany instead/**
   * Remove and get the first element in any of the lists, or block until one is available
   * @param keys List of key strings identifying lists to watch
   * @param seconds Timeout in seconds
   * @return 
   * @deprecated use {@link #rxBlpopMany} instead
   */
  @Deprecated()
  public Observable<JsonArray> blpopManyObservable(List<String> keys, int seconds) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    blpopMany(keys, seconds, handler.toHandler());
    return handler;
  }

  
Remove and get the first element in any of the lists, or block until one is available
Params:
keys – List of key strings identifying lists to watch
seconds – Timeout in seconds
Returns:
/**
   * Remove and get the first element in any of the lists, or block until one is available
   * @param keys List of key strings identifying lists to watch
   * @param seconds Timeout in seconds
   * @return 
   */
  public Single<JsonArray> rxBlpopMany(List<String> keys, int seconds) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      blpopMany(keys, seconds, fut);
    }));
  }

  
Remove and get the last element in a list, or block until one is available
Params:
key – Key string identifying a list to watch
seconds – Timeout in seconds
handler – Handler for the result of this call.
Returns:
/**
   * Remove and get the last element in a list, or block until one is available
   * @param key Key string identifying a list to watch
   * @param seconds Timeout in seconds
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient brpop(String key, int seconds, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.brpop(key, seconds, handler);
    return this;
  }

    
Remove and get the last element in a list, or block until one is available
Params:
key – Key string identifying a list to watch
seconds – Timeout in seconds
Returns:
Deprecated:
use rxBrpop instead/**
   * Remove and get the last element in a list, or block until one is available
   * @param key Key string identifying a list to watch
   * @param seconds Timeout in seconds
   * @return 
   * @deprecated use {@link #rxBrpop} instead
   */
  @Deprecated()
  public Observable<JsonArray> brpopObservable(String key, int seconds) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    brpop(key, seconds, handler.toHandler());
    return handler;
  }

  
Remove and get the last element in a list, or block until one is available
Params:
key – Key string identifying a list to watch
seconds – Timeout in seconds
Returns:
/**
   * Remove and get the last element in a list, or block until one is available
   * @param key Key string identifying a list to watch
   * @param seconds Timeout in seconds
   * @return 
   */
  public Single<JsonArray> rxBrpop(String key, int seconds) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      brpop(key, seconds, fut);
    }));
  }

  
Remove and get the last element in any of the lists, or block until one is available
Params:
keys – List of key strings identifying lists to watch
seconds – Timeout in seconds
handler – Handler for the result of this call.
Returns:
/**
   * Remove and get the last element in any of the lists, or block until one is available
   * @param keys List of key strings identifying lists to watch
   * @param seconds Timeout in seconds
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient brpopMany(List<String> keys, int seconds, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.brpopMany(keys, seconds, handler);
    return this;
  }

    
Remove and get the last element in any of the lists, or block until one is available
Params:
keys – List of key strings identifying lists to watch
seconds – Timeout in seconds
Returns:
Deprecated:
use rxBrpopMany instead/**
   * Remove and get the last element in any of the lists, or block until one is available
   * @param keys List of key strings identifying lists to watch
   * @param seconds Timeout in seconds
   * @return 
   * @deprecated use {@link #rxBrpopMany} instead
   */
  @Deprecated()
  public Observable<JsonArray> brpopManyObservable(List<String> keys, int seconds) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    brpopMany(keys, seconds, handler.toHandler());
    return handler;
  }

  
Remove and get the last element in any of the lists, or block until one is available
Params:
keys – List of key strings identifying lists to watch
seconds – Timeout in seconds
Returns:
/**
   * Remove and get the last element in any of the lists, or block until one is available
   * @param keys List of key strings identifying lists to watch
   * @param seconds Timeout in seconds
   * @return 
   */
  public Single<JsonArray> rxBrpopMany(List<String> keys, int seconds) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      brpopMany(keys, seconds, fut);
    }));
  }

  
Pop a value from a list, push it to another list and return it; or block until one is available
Params:
key – Key string identifying the source list
destkey – Key string identifying the destination list
seconds – Timeout in seconds
handler – Handler for the result of this call.
Returns:
/**
   * Pop a value from a list, push it to another list and return it; or block until one is available
   * @param key Key string identifying the source list
   * @param destkey Key string identifying the destination list
   * @param seconds Timeout in seconds
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient brpoplpush(String key, String destkey, int seconds, Handler<AsyncResult<String>> handler) { 
    delegate.brpoplpush(key, destkey, seconds, handler);
    return this;
  }

    
Pop a value from a list, push it to another list and return it; or block until one is available
Params:
key – Key string identifying the source list
destkey – Key string identifying the destination list
seconds – Timeout in seconds
Returns:
Deprecated:
use rxBrpoplpush instead/**
   * Pop a value from a list, push it to another list and return it; or block until one is available
   * @param key Key string identifying the source list
   * @param destkey Key string identifying the destination list
   * @param seconds Timeout in seconds
   * @return 
   * @deprecated use {@link #rxBrpoplpush} instead
   */
  @Deprecated()
  public Observable<String> brpoplpushObservable(String key, String destkey, int seconds) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    brpoplpush(key, destkey, seconds, handler.toHandler());
    return handler;
  }

  
Pop a value from a list, push it to another list and return it; or block until one is available
Params:
key – Key string identifying the source list
destkey – Key string identifying the destination list
seconds – Timeout in seconds
Returns:
/**
   * Pop a value from a list, push it to another list and return it; or block until one is available
   * @param key Key string identifying the source list
   * @param destkey Key string identifying the destination list
   * @param seconds Timeout in seconds
   * @return 
   */
  public Single<String> rxBrpoplpush(String key, String destkey, int seconds) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      brpoplpush(key, destkey, seconds, fut);
    }));
  }

  
Kill the connection of a client
Params:
filter – Filter options
handler – Handler for the result of this call.
Returns:
/**
   * Kill the connection of a client
   * @param filter Filter options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clientKill(KillFilter filter, Handler<AsyncResult<Long>> handler) { 
    delegate.clientKill(filter, handler);
    return this;
  }

    
Kill the connection of a client
Params:
filter – Filter options
Returns:
Deprecated:
use rxClientKill instead/**
   * Kill the connection of a client
   * @param filter Filter options
   * @return 
   * @deprecated use {@link #rxClientKill} instead
   */
  @Deprecated()
  public Observable<Long> clientKillObservable(KillFilter filter) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clientKill(filter, handler.toHandler());
    return handler;
  }

  
Kill the connection of a client
Params:
filter – Filter options
Returns:
/**
   * Kill the connection of a client
   * @param filter Filter options
   * @return 
   */
  public Single<Long> rxClientKill(KillFilter filter) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clientKill(filter, fut);
    }));
  }

  
Get the list of client connections
Params:
handler – 
Returns:
/**
   * Get the list of client connections
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clientList(Handler<AsyncResult<String>> handler) { 
    delegate.clientList(handler);
    return this;
  }

    
Get the list of client connections
Returns:
Deprecated:
use rxClientList instead/**
   * Get the list of client connections
   * @return 
   * @deprecated use {@link #rxClientList} instead
   */
  @Deprecated()
  public Observable<String> clientListObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clientList(handler.toHandler());
    return handler;
  }

  
Get the list of client connections
Returns:
/**
   * Get the list of client connections
   * @return 
   */
  public Single<String> rxClientList() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clientList(fut);
    }));
  }

  
Get the current connection name
Params:
handler – 
Returns:
/**
   * Get the current connection name
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clientGetname(Handler<AsyncResult<String>> handler) { 
    delegate.clientGetname(handler);
    return this;
  }

    
Get the current connection name
Returns:
Deprecated:
use rxClientGetname instead/**
   * Get the current connection name
   * @return 
   * @deprecated use {@link #rxClientGetname} instead
   */
  @Deprecated()
  public Observable<String> clientGetnameObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clientGetname(handler.toHandler());
    return handler;
  }

  
Get the current connection name
Returns:
/**
   * Get the current connection name
   * @return 
   */
  public Single<String> rxClientGetname() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clientGetname(fut);
    }));
  }

  
Stop processing commands from clients for some time
Params:
millis – Pause time in milliseconds
handler – Handler for the result of this call.
Returns:
/**
   * Stop processing commands from clients for some time
   * @param millis Pause time in milliseconds
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clientPause(long millis, Handler<AsyncResult<String>> handler) { 
    delegate.clientPause(millis, handler);
    return this;
  }

    
Stop processing commands from clients for some time
Params:
millis – Pause time in milliseconds
Returns:
Deprecated:
use rxClientPause instead/**
   * Stop processing commands from clients for some time
   * @param millis Pause time in milliseconds
   * @return 
   * @deprecated use {@link #rxClientPause} instead
   */
  @Deprecated()
  public Observable<String> clientPauseObservable(long millis) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clientPause(millis, handler.toHandler());
    return handler;
  }

  
Stop processing commands from clients for some time
Params:
millis – Pause time in milliseconds
Returns:
/**
   * Stop processing commands from clients for some time
   * @param millis Pause time in milliseconds
   * @return 
   */
  public Single<String> rxClientPause(long millis) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clientPause(millis, fut);
    }));
  }

  
Set the current connection name
Params:
name – New name for current connection
handler – Handler for the result of this call.
Returns:
/**
   * Set the current connection name
   * @param name New name for current connection
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clientSetname(String name, Handler<AsyncResult<String>> handler) { 
    delegate.clientSetname(name, handler);
    return this;
  }

    
Set the current connection name
Params:
name – New name for current connection
Returns:
Deprecated:
use rxClientSetname instead/**
   * Set the current connection name
   * @param name New name for current connection
   * @return 
   * @deprecated use {@link #rxClientSetname} instead
   */
  @Deprecated()
  public Observable<String> clientSetnameObservable(String name) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clientSetname(name, handler.toHandler());
    return handler;
  }

  
Set the current connection name
Params:
name – New name for current connection
Returns:
/**
   * Set the current connection name
   * @param name New name for current connection
   * @return 
   */
  public Single<String> rxClientSetname(String name) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clientSetname(name, fut);
    }));
  }

  
Assign new hash slots to receiving node.
Params:
slots – 
handler – Handler for the result of this call.
Returns:
/**
   * Assign new hash slots to receiving node.
   * @param slots 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterAddslots(List<Long> slots, Handler<AsyncResult<Void>> handler) { 
    delegate.clusterAddslots(slots, handler);
    return this;
  }

    
Assign new hash slots to receiving node.
Params:
slots – 
Returns:
Deprecated:
use rxClusterAddslots instead/**
   * Assign new hash slots to receiving node.
   * @param slots 
   * @return 
   * @deprecated use {@link #rxClusterAddslots} instead
   */
  @Deprecated()
  public Observable<Void> clusterAddslotsObservable(List<Long> slots) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterAddslots(slots, handler.toHandler());
    return handler;
  }

  
Assign new hash slots to receiving node.
Params:
slots – 
Returns:
/**
   * Assign new hash slots to receiving node.
   * @param slots 
   * @return 
   */
  public Single<Void> rxClusterAddslots(List<Long> slots) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterAddslots(slots, fut);
    }));
  }

  
Return the number of failure reports active for a given node.
Params:
nodeId – 
handler – Handler for the result of this call.
Returns:
/**
   * Return the number of failure reports active for a given node.
   * @param nodeId 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterCountFailureReports(String nodeId, Handler<AsyncResult<Long>> handler) { 
    delegate.clusterCountFailureReports(nodeId, handler);
    return this;
  }

    
Return the number of failure reports active for a given node.
Params:
nodeId – 
Returns:
Deprecated:
use rxClusterCountFailureReports instead/**
   * Return the number of failure reports active for a given node.
   * @param nodeId 
   * @return 
   * @deprecated use {@link #rxClusterCountFailureReports} instead
   */
  @Deprecated()
  public Observable<Long> clusterCountFailureReportsObservable(String nodeId) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterCountFailureReports(nodeId, handler.toHandler());
    return handler;
  }

  
Return the number of failure reports active for a given node.
Params:
nodeId – 
Returns:
/**
   * Return the number of failure reports active for a given node.
   * @param nodeId 
   * @return 
   */
  public Single<Long> rxClusterCountFailureReports(String nodeId) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterCountFailureReports(nodeId, fut);
    }));
  }

  
Return the number of local keys in the specified hash slot.
Params:
slot – 
handler – Handler for the result of this call.
Returns:
/**
   * Return the number of local keys in the specified hash slot.
   * @param slot 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterCountkeysinslot(long slot, Handler<AsyncResult<Long>> handler) { 
    delegate.clusterCountkeysinslot(slot, handler);
    return this;
  }

    
Return the number of local keys in the specified hash slot.
Params:
slot – 
Returns:
Deprecated:
use rxClusterCountkeysinslot instead/**
   * Return the number of local keys in the specified hash slot.
   * @param slot 
   * @return 
   * @deprecated use {@link #rxClusterCountkeysinslot} instead
   */
  @Deprecated()
  public Observable<Long> clusterCountkeysinslotObservable(long slot) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterCountkeysinslot(slot, handler.toHandler());
    return handler;
  }

  
Return the number of local keys in the specified hash slot.
Params:
slot – 
Returns:
/**
   * Return the number of local keys in the specified hash slot.
   * @param slot 
   * @return 
   */
  public Single<Long> rxClusterCountkeysinslot(long slot) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterCountkeysinslot(slot, fut);
    }));
  }

  
Set hash slots as unbound in receiving node.
Params:
slot – 
handler – Handler for the result of this call.
Returns:
/**
   * Set hash slots as unbound in receiving node.
   * @param slot 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterDelslots(long slot, Handler<AsyncResult<Void>> handler) { 
    delegate.clusterDelslots(slot, handler);
    return this;
  }

    
Set hash slots as unbound in receiving node.
Params:
slot – 
Returns:
Deprecated:
use rxClusterDelslots instead/**
   * Set hash slots as unbound in receiving node.
   * @param slot 
   * @return 
   * @deprecated use {@link #rxClusterDelslots} instead
   */
  @Deprecated()
  public Observable<Void> clusterDelslotsObservable(long slot) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterDelslots(slot, handler.toHandler());
    return handler;
  }

  
Set hash slots as unbound in receiving node.
Params:
slot – 
Returns:
/**
   * Set hash slots as unbound in receiving node.
   * @param slot 
   * @return 
   */
  public Single<Void> rxClusterDelslots(long slot) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterDelslots(slot, fut);
    }));
  }

  
Set hash slots as unbound in receiving node.
Params:
slots – 
handler – Handler for the result of this call.
Returns:
/**
   * Set hash slots as unbound in receiving node.
   * @param slots 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterDelslotsMany(List<Long> slots, Handler<AsyncResult<Void>> handler) { 
    delegate.clusterDelslotsMany(slots, handler);
    return this;
  }

    
Set hash slots as unbound in receiving node.
Params:
slots – 
Returns:
Deprecated:
use rxClusterDelslotsMany instead/**
   * Set hash slots as unbound in receiving node.
   * @param slots 
   * @return 
   * @deprecated use {@link #rxClusterDelslotsMany} instead
   */
  @Deprecated()
  public Observable<Void> clusterDelslotsManyObservable(List<Long> slots) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterDelslotsMany(slots, handler.toHandler());
    return handler;
  }

  
Set hash slots as unbound in receiving node.
Params:
slots – 
Returns:
/**
   * Set hash slots as unbound in receiving node.
   * @param slots 
   * @return 
   */
  public Single<Void> rxClusterDelslotsMany(List<Long> slots) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterDelslotsMany(slots, fut);
    }));
  }

  
Forces a slave to perform a manual failover of its master.
Params:
handler – Handler for the result of this call.
Returns:
/**
   * Forces a slave to perform a manual failover of its master.
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterFailover(Handler<AsyncResult<Void>> handler) { 
    delegate.clusterFailover(handler);
    return this;
  }

    
Forces a slave to perform a manual failover of its master.
Returns:
Deprecated:
use rxClusterFailover instead/**
   * Forces a slave to perform a manual failover of its master.
   * @return 
   * @deprecated use {@link #rxClusterFailover} instead
   */
  @Deprecated()
  public Observable<Void> clusterFailoverObservable() { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterFailover(handler.toHandler());
    return handler;
  }

  
Forces a slave to perform a manual failover of its master.
Returns:
/**
   * Forces a slave to perform a manual failover of its master.
   * @return 
   */
  public Single<Void> rxClusterFailover() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterFailover(fut);
    }));
  }

  
Forces a slave to perform a manual failover of its master.
Params:
options – 
handler – Handler for the result of this call.
Returns:
/**
   * Forces a slave to perform a manual failover of its master.
   * @param options 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterFailOverWithOptions(FailoverOptions options, Handler<AsyncResult<Void>> handler) { 
    delegate.clusterFailOverWithOptions(options, handler);
    return this;
  }

    
Forces a slave to perform a manual failover of its master.
Params:
options – 
Returns:
Deprecated:
use rxClusterFailOverWithOptions instead/**
   * Forces a slave to perform a manual failover of its master.
   * @param options 
   * @return 
   * @deprecated use {@link #rxClusterFailOverWithOptions} instead
   */
  @Deprecated()
  public Observable<Void> clusterFailOverWithOptionsObservable(FailoverOptions options) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterFailOverWithOptions(options, handler.toHandler());
    return handler;
  }

  
Forces a slave to perform a manual failover of its master.
Params:
options – 
Returns:
/**
   * Forces a slave to perform a manual failover of its master.
   * @param options 
   * @return 
   */
  public Single<Void> rxClusterFailOverWithOptions(FailoverOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterFailOverWithOptions(options, fut);
    }));
  }

  
Remove a node from the nodes table.
Params:
nodeId – 
handler – Handler for the result of this call.
Returns:
/**
   * Remove a node from the nodes table.
   * @param nodeId 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterForget(String nodeId, Handler<AsyncResult<Void>> handler) { 
    delegate.clusterForget(nodeId, handler);
    return this;
  }

    
Remove a node from the nodes table.
Params:
nodeId – 
Returns:
Deprecated:
use rxClusterForget instead/**
   * Remove a node from the nodes table.
   * @param nodeId 
   * @return 
   * @deprecated use {@link #rxClusterForget} instead
   */
  @Deprecated()
  public Observable<Void> clusterForgetObservable(String nodeId) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterForget(nodeId, handler.toHandler());
    return handler;
  }

  
Remove a node from the nodes table.
Params:
nodeId – 
Returns:
/**
   * Remove a node from the nodes table.
   * @param nodeId 
   * @return 
   */
  public Single<Void> rxClusterForget(String nodeId) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterForget(nodeId, fut);
    }));
  }

  
Return local key names in the specified hash slot.
Params:
slot – 
count – 
handler – Handler for the result of this call.
Returns:
/**
   * Return local key names in the specified hash slot.
   * @param slot 
   * @param count 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterGetkeysinslot(long slot, long count, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.clusterGetkeysinslot(slot, count, handler);
    return this;
  }

    
Return local key names in the specified hash slot.
Params:
slot – 
count – 
Returns:
Deprecated:
use rxClusterGetkeysinslot instead/**
   * Return local key names in the specified hash slot.
   * @param slot 
   * @param count 
   * @return 
   * @deprecated use {@link #rxClusterGetkeysinslot} instead
   */
  @Deprecated()
  public Observable<JsonArray> clusterGetkeysinslotObservable(long slot, long count) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterGetkeysinslot(slot, count, handler.toHandler());
    return handler;
  }

  
Return local key names in the specified hash slot.
Params:
slot – 
count – 
Returns:
/**
   * Return local key names in the specified hash slot.
   * @param slot 
   * @param count 
   * @return 
   */
  public Single<JsonArray> rxClusterGetkeysinslot(long slot, long count) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterGetkeysinslot(slot, count, fut);
    }));
  }

  
Provides info about Redis Cluster node state.
Params:
handler – Handler for the result of this call.
Returns:
/**
   * Provides info about Redis Cluster node state.
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterInfo(Handler<AsyncResult<JsonArray>> handler) { 
    delegate.clusterInfo(handler);
    return this;
  }

    
Provides info about Redis Cluster node state.
Returns:
Deprecated:
use rxClusterInfo instead/**
   * Provides info about Redis Cluster node state.
   * @return 
   * @deprecated use {@link #rxClusterInfo} instead
   */
  @Deprecated()
  public Observable<JsonArray> clusterInfoObservable() { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterInfo(handler.toHandler());
    return handler;
  }

  
Provides info about Redis Cluster node state.
Returns:
/**
   * Provides info about Redis Cluster node state.
   * @return 
   */
  public Single<JsonArray> rxClusterInfo() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterInfo(fut);
    }));
  }

  
Returns the hash slot of the specified key.
Params:
key – 
handler – Handler for the result of this call.
Returns:
/**
   * Returns the hash slot of the specified key.
   * @param key 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterKeyslot(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.clusterKeyslot(key, handler);
    return this;
  }

    
Returns the hash slot of the specified key.
Params:
key – 
Returns:
Deprecated:
use rxClusterKeyslot instead/**
   * Returns the hash slot of the specified key.
   * @param key 
   * @return 
   * @deprecated use {@link #rxClusterKeyslot} instead
   */
  @Deprecated()
  public Observable<Long> clusterKeyslotObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterKeyslot(key, handler.toHandler());
    return handler;
  }

  
Returns the hash slot of the specified key.
Params:
key – 
Returns:
/**
   * Returns the hash slot of the specified key.
   * @param key 
   * @return 
   */
  public Single<Long> rxClusterKeyslot(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterKeyslot(key, fut);
    }));
  }

  
Force a node cluster to handshake with another node.
Params:
ip – 
port – 
handler – Handler for the result of this call.
Returns:
/**
   * Force a node cluster to handshake with another node.
   * @param ip 
   * @param port 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterMeet(String ip, long port, Handler<AsyncResult<Void>> handler) { 
    delegate.clusterMeet(ip, port, handler);
    return this;
  }

    
Force a node cluster to handshake with another node.
Params:
ip – 
port – 
Returns:
Deprecated:
use rxClusterMeet instead/**
   * Force a node cluster to handshake with another node.
   * @param ip 
   * @param port 
   * @return 
   * @deprecated use {@link #rxClusterMeet} instead
   */
  @Deprecated()
  public Observable<Void> clusterMeetObservable(String ip, long port) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterMeet(ip, port, handler.toHandler());
    return handler;
  }

  
Force a node cluster to handshake with another node.
Params:
ip – 
port – 
Returns:
/**
   * Force a node cluster to handshake with another node.
   * @param ip 
   * @param port 
   * @return 
   */
  public Single<Void> rxClusterMeet(String ip, long port) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterMeet(ip, port, fut);
    }));
  }

  
Get Cluster config for the node.
Params:
handler – Handler for the result of this call.
Returns:
/**
   * Get Cluster config for the node.
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterNodes(Handler<AsyncResult<JsonArray>> handler) { 
    delegate.clusterNodes(handler);
    return this;
  }

    
Get Cluster config for the node.
Returns:
Deprecated:
use rxClusterNodes instead/**
   * Get Cluster config for the node.
   * @return 
   * @deprecated use {@link #rxClusterNodes} instead
   */
  @Deprecated()
  public Observable<JsonArray> clusterNodesObservable() { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterNodes(handler.toHandler());
    return handler;
  }

  
Get Cluster config for the node.
Returns:
/**
   * Get Cluster config for the node.
   * @return 
   */
  public Single<JsonArray> rxClusterNodes() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterNodes(fut);
    }));
  }

  
Reconfigure a node as a slave of the specified master node.
Params:
nodeId – 
handler – Handler for the result of this call.
Returns:
/**
   * Reconfigure a node as a slave of the specified master node.
   * @param nodeId 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterReplicate(String nodeId, Handler<AsyncResult<Void>> handler) { 
    delegate.clusterReplicate(nodeId, handler);
    return this;
  }

    
Reconfigure a node as a slave of the specified master node.
Params:
nodeId – 
Returns:
Deprecated:
use rxClusterReplicate instead/**
   * Reconfigure a node as a slave of the specified master node.
   * @param nodeId 
   * @return 
   * @deprecated use {@link #rxClusterReplicate} instead
   */
  @Deprecated()
  public Observable<Void> clusterReplicateObservable(String nodeId) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterReplicate(nodeId, handler.toHandler());
    return handler;
  }

  
Reconfigure a node as a slave of the specified master node.
Params:
nodeId – 
Returns:
/**
   * Reconfigure a node as a slave of the specified master node.
   * @param nodeId 
   * @return 
   */
  public Single<Void> rxClusterReplicate(String nodeId) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterReplicate(nodeId, fut);
    }));
  }

  
Reset a Redis Cluster node.
Params:
handler – Handler for the result of this call.
Returns:
/**
   * Reset a Redis Cluster node.
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterReset(Handler<AsyncResult<Void>> handler) { 
    delegate.clusterReset(handler);
    return this;
  }

    
Reset a Redis Cluster node.
Returns:
Deprecated:
use rxClusterReset instead/**
   * Reset a Redis Cluster node.
   * @return 
   * @deprecated use {@link #rxClusterReset} instead
   */
  @Deprecated()
  public Observable<Void> clusterResetObservable() { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterReset(handler.toHandler());
    return handler;
  }

  
Reset a Redis Cluster node.
Returns:
/**
   * Reset a Redis Cluster node.
   * @return 
   */
  public Single<Void> rxClusterReset() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterReset(fut);
    }));
  }

  
Reset a Redis Cluster node.
Params:
options – 
handler – Handler for the result of this call.
Returns:
/**
   * Reset a Redis Cluster node.
   * @param options 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterResetWithOptions(ResetOptions options, Handler<AsyncResult<Void>> handler) { 
    delegate.clusterResetWithOptions(options, handler);
    return this;
  }

    
Reset a Redis Cluster node.
Params:
options – 
Returns:
Deprecated:
use rxClusterResetWithOptions instead/**
   * Reset a Redis Cluster node.
   * @param options 
   * @return 
   * @deprecated use {@link #rxClusterResetWithOptions} instead
   */
  @Deprecated()
  public Observable<Void> clusterResetWithOptionsObservable(ResetOptions options) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterResetWithOptions(options, handler.toHandler());
    return handler;
  }

  
Reset a Redis Cluster node.
Params:
options – 
Returns:
/**
   * Reset a Redis Cluster node.
   * @param options 
   * @return 
   */
  public Single<Void> rxClusterResetWithOptions(ResetOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterResetWithOptions(options, fut);
    }));
  }

  
Forces the node to save cluster state on disk.
Params:
handler – Handler for the result of this call.
Returns:
/**
   * Forces the node to save cluster state on disk.
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterSaveconfig(Handler<AsyncResult<Void>> handler) { 
    delegate.clusterSaveconfig(handler);
    return this;
  }

    
Forces the node to save cluster state on disk.
Returns:
Deprecated:
use rxClusterSaveconfig instead/**
   * Forces the node to save cluster state on disk.
   * @return 
   * @deprecated use {@link #rxClusterSaveconfig} instead
   */
  @Deprecated()
  public Observable<Void> clusterSaveconfigObservable() { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterSaveconfig(handler.toHandler());
    return handler;
  }

  
Forces the node to save cluster state on disk.
Returns:
/**
   * Forces the node to save cluster state on disk.
   * @return 
   */
  public Single<Void> rxClusterSaveconfig() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterSaveconfig(fut);
    }));
  }

  
Set the configuration epoch in a new node.
Params:
epoch – 
handler – Handler for the result of this call.
Returns:
/**
   * Set the configuration epoch in a new node.
   * @param epoch 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterSetConfigEpoch(long epoch, Handler<AsyncResult<Void>> handler) { 
    delegate.clusterSetConfigEpoch(epoch, handler);
    return this;
  }

    
Set the configuration epoch in a new node.
Params:
epoch – 
Returns:
Deprecated:
use rxClusterSetConfigEpoch instead/**
   * Set the configuration epoch in a new node.
   * @param epoch 
   * @return 
   * @deprecated use {@link #rxClusterSetConfigEpoch} instead
   */
  @Deprecated()
  public Observable<Void> clusterSetConfigEpochObservable(long epoch) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterSetConfigEpoch(epoch, handler.toHandler());
    return handler;
  }

  
Set the configuration epoch in a new node.
Params:
epoch – 
Returns:
/**
   * Set the configuration epoch in a new node.
   * @param epoch 
   * @return 
   */
  public Single<Void> rxClusterSetConfigEpoch(long epoch) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterSetConfigEpoch(epoch, fut);
    }));
  }

  
Bind an hash slot to a specific node.
Params:
slot – 
subcommand – 
handler – Handler for the result of this call.
Returns:
/**
   * Bind an hash slot to a specific node.
   * @param slot 
   * @param subcommand 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterSetslot(long slot, SlotCmd subcommand, Handler<AsyncResult<Void>> handler) { 
    delegate.clusterSetslot(slot, subcommand, handler);
    return this;
  }

    
Bind an hash slot to a specific node.
Params:
slot – 
subcommand – 
Returns:
Deprecated:
use rxClusterSetslot instead/**
   * Bind an hash slot to a specific node.
   * @param slot 
   * @param subcommand 
   * @return 
   * @deprecated use {@link #rxClusterSetslot} instead
   */
  @Deprecated()
  public Observable<Void> clusterSetslotObservable(long slot, SlotCmd subcommand) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterSetslot(slot, subcommand, handler.toHandler());
    return handler;
  }

  
Bind an hash slot to a specific node.
Params:
slot – 
subcommand – 
Returns:
/**
   * Bind an hash slot to a specific node.
   * @param slot 
   * @param subcommand 
   * @return 
   */
  public Single<Void> rxClusterSetslot(long slot, SlotCmd subcommand) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterSetslot(slot, subcommand, fut);
    }));
  }

  
Bind an hash slot to a specific node.
Params:
slot – 
subcommand – 
nodeId – 
handler – Handler for the result of this call.
Returns:
/**
   * Bind an hash slot to a specific node.
   * @param slot 
   * @param subcommand 
   * @param nodeId 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId, Handler<AsyncResult<Void>> handler) { 
    delegate.clusterSetslotWithNode(slot, subcommand, nodeId, handler);
    return this;
  }

    
Bind an hash slot to a specific node.
Params:
slot – 
subcommand – 
nodeId – 
Returns:
Deprecated:
use rxClusterSetslotWithNode instead/**
   * Bind an hash slot to a specific node.
   * @param slot 
   * @param subcommand 
   * @param nodeId 
   * @return 
   * @deprecated use {@link #rxClusterSetslotWithNode} instead
   */
  @Deprecated()
  public Observable<Void> clusterSetslotWithNodeObservable(long slot, SlotCmd subcommand, String nodeId) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterSetslotWithNode(slot, subcommand, nodeId, handler.toHandler());
    return handler;
  }

  
Bind an hash slot to a specific node.
Params:
slot – 
subcommand – 
nodeId – 
Returns:
/**
   * Bind an hash slot to a specific node.
   * @param slot 
   * @param subcommand 
   * @param nodeId 
   * @return 
   */
  public Single<Void> rxClusterSetslotWithNode(long slot, SlotCmd subcommand, String nodeId) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterSetslotWithNode(slot, subcommand, nodeId, fut);
    }));
  }

  
List slave nodes of the specified master node.
Params:
nodeId – 
handler – Handler for the result of this call.
Returns:
/**
   * List slave nodes of the specified master node.
   * @param nodeId 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterSlaves(String nodeId, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.clusterSlaves(nodeId, handler);
    return this;
  }

    
List slave nodes of the specified master node.
Params:
nodeId – 
Returns:
Deprecated:
use rxClusterSlaves instead/**
   * List slave nodes of the specified master node.
   * @param nodeId 
   * @return 
   * @deprecated use {@link #rxClusterSlaves} instead
   */
  @Deprecated()
  public Observable<JsonArray> clusterSlavesObservable(String nodeId) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterSlaves(nodeId, handler.toHandler());
    return handler;
  }

  
List slave nodes of the specified master node.
Params:
nodeId – 
Returns:
/**
   * List slave nodes of the specified master node.
   * @param nodeId 
   * @return 
   */
  public Single<JsonArray> rxClusterSlaves(String nodeId) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterSlaves(nodeId, fut);
    }));
  }

  
Get array of Cluster slot to node mappings
Params:
handler – 
Returns:
/**
   * Get array of Cluster slot to node mappings
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterSlots(Handler<AsyncResult<JsonArray>> handler) { 
    delegate.clusterSlots(handler);
    return this;
  }

    
Get array of Cluster slot to node mappings
Returns:
Deprecated:
use rxClusterSlots instead/**
   * Get array of Cluster slot to node mappings
   * @return 
   * @deprecated use {@link #rxClusterSlots} instead
   */
  @Deprecated()
  public Observable<JsonArray> clusterSlotsObservable() { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clusterSlots(handler.toHandler());
    return handler;
  }

  
Get array of Cluster slot to node mappings
Returns:
/**
   * Get array of Cluster slot to node mappings
   * @return 
   */
  public Single<JsonArray> rxClusterSlots() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clusterSlots(fut);
    }));
  }

  
Get array of Redis command details
Params:
handler – 
Returns:
/**
   * Get array of Redis command details
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient command(Handler<AsyncResult<JsonArray>> handler) { 
    delegate.command(handler);
    return this;
  }

    
Get array of Redis command details
Returns:
Deprecated:
use rxCommand instead/**
   * Get array of Redis command details
   * @return 
   * @deprecated use {@link #rxCommand} instead
   */
  @Deprecated()
  public Observable<JsonArray> commandObservable() { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    command(handler.toHandler());
    return handler;
  }

  
Get array of Redis command details
Returns:
/**
   * Get array of Redis command details
   * @return 
   */
  public Single<JsonArray> rxCommand() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      command(fut);
    }));
  }

  
Get total number of Redis commands
Params:
handler – 
Returns:
/**
   * Get total number of Redis commands
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient commandCount(Handler<AsyncResult<Long>> handler) { 
    delegate.commandCount(handler);
    return this;
  }

    
Get total number of Redis commands
Returns:
Deprecated:
use rxCommandCount instead/**
   * Get total number of Redis commands
   * @return 
   * @deprecated use {@link #rxCommandCount} instead
   */
  @Deprecated()
  public Observable<Long> commandCountObservable() { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    commandCount(handler.toHandler());
    return handler;
  }

  
Get total number of Redis commands
Returns:
/**
   * Get total number of Redis commands
   * @return 
   */
  public Single<Long> rxCommandCount() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      commandCount(fut);
    }));
  }

  
Extract keys given a full Redis command
Params:
handler – 
Returns:
/**
   * Extract keys given a full Redis command
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient commandGetkeys(Handler<AsyncResult<JsonArray>> handler) { 
    delegate.commandGetkeys(handler);
    return this;
  }

    
Extract keys given a full Redis command
Returns:
Deprecated:
use rxCommandGetkeys instead/**
   * Extract keys given a full Redis command
   * @return 
   * @deprecated use {@link #rxCommandGetkeys} instead
   */
  @Deprecated()
  public Observable<JsonArray> commandGetkeysObservable() { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    commandGetkeys(handler.toHandler());
    return handler;
  }

  
Extract keys given a full Redis command
Returns:
/**
   * Extract keys given a full Redis command
   * @return 
   */
  public Single<JsonArray> rxCommandGetkeys() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      commandGetkeys(fut);
    }));
  }

  
Get array of specific Redis command details
Params:
commands – List of commands to get info for
handler – Handler for the result of this call.
Returns:
/**
   * Get array of specific Redis command details
   * @param commands List of commands to get info for
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient commandInfo(List<String> commands, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.commandInfo(commands, handler);
    return this;
  }

    
Get array of specific Redis command details
Params:
commands – List of commands to get info for
Returns:
Deprecated:
use rxCommandInfo instead/**
   * Get array of specific Redis command details
   * @param commands List of commands to get info for
   * @return 
   * @deprecated use {@link #rxCommandInfo} instead
   */
  @Deprecated()
  public Observable<JsonArray> commandInfoObservable(List<String> commands) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    commandInfo(commands, handler.toHandler());
    return handler;
  }

  
Get array of specific Redis command details
Params:
commands – List of commands to get info for
Returns:
/**
   * Get array of specific Redis command details
   * @param commands List of commands to get info for
   * @return 
   */
  public Single<JsonArray> rxCommandInfo(List<String> commands) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      commandInfo(commands, fut);
    }));
  }

  
Get the value of a configuration parameter
Params:
parameter – Configuration parameter
handler – Handler for the result of this call.
Returns:
/**
   * Get the value of a configuration parameter
   * @param parameter Configuration parameter
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient configGet(String parameter, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.configGet(parameter, handler);
    return this;
  }

    
Get the value of a configuration parameter
Params:
parameter – Configuration parameter
Returns:
Deprecated:
use rxConfigGet instead/**
   * Get the value of a configuration parameter
   * @param parameter Configuration parameter
   * @return 
   * @deprecated use {@link #rxConfigGet} instead
   */
  @Deprecated()
  public Observable<JsonArray> configGetObservable(String parameter) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    configGet(parameter, handler.toHandler());
    return handler;
  }

  
Get the value of a configuration parameter
Params:
parameter – Configuration parameter
Returns:
/**
   * Get the value of a configuration parameter
   * @param parameter Configuration parameter
   * @return 
   */
  public Single<JsonArray> rxConfigGet(String parameter) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      configGet(parameter, fut);
    }));
  }

  
Rewrite the configuration file with the in memory configuration
Params:
handler – 
Returns:
/**
   * Rewrite the configuration file with the in memory configuration
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient configRewrite(Handler<AsyncResult<String>> handler) { 
    delegate.configRewrite(handler);
    return this;
  }

    
Rewrite the configuration file with the in memory configuration
Returns:
Deprecated:
use rxConfigRewrite instead/**
   * Rewrite the configuration file with the in memory configuration
   * @return 
   * @deprecated use {@link #rxConfigRewrite} instead
   */
  @Deprecated()
  public Observable<String> configRewriteObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    configRewrite(handler.toHandler());
    return handler;
  }

  
Rewrite the configuration file with the in memory configuration
Returns:
/**
   * Rewrite the configuration file with the in memory configuration
   * @return 
   */
  public Single<String> rxConfigRewrite() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      configRewrite(fut);
    }));
  }

  
Set a configuration parameter to the given value
Params:
parameter – Configuration parameter
value – New value
handler – Handler for the result of this call.
Returns:
/**
   * Set a configuration parameter to the given value
   * @param parameter Configuration parameter
   * @param value New value
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient configSet(String parameter, String value, Handler<AsyncResult<String>> handler) { 
    delegate.configSet(parameter, value, handler);
    return this;
  }

    
Set a configuration parameter to the given value
Params:
parameter – Configuration parameter
value – New value
Returns:
Deprecated:
use rxConfigSet instead/**
   * Set a configuration parameter to the given value
   * @param parameter Configuration parameter
   * @param value New value
   * @return 
   * @deprecated use {@link #rxConfigSet} instead
   */
  @Deprecated()
  public Observable<String> configSetObservable(String parameter, String value) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    configSet(parameter, value, handler.toHandler());
    return handler;
  }

  
Set a configuration parameter to the given value
Params:
parameter – Configuration parameter
value – New value
Returns:
/**
   * Set a configuration parameter to the given value
   * @param parameter Configuration parameter
   * @param value New value
   * @return 
   */
  public Single<String> rxConfigSet(String parameter, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      configSet(parameter, value, fut);
    }));
  }

  
Reset the stats returned by INFO
Params:
handler – 
Returns:
/**
   * Reset the stats returned by INFO
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient configResetstat(Handler<AsyncResult<String>> handler) { 
    delegate.configResetstat(handler);
    return this;
  }

    
Reset the stats returned by INFO
Returns:
Deprecated:
use rxConfigResetstat instead/**
   * Reset the stats returned by INFO
   * @return 
   * @deprecated use {@link #rxConfigResetstat} instead
   */
  @Deprecated()
  public Observable<String> configResetstatObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    configResetstat(handler.toHandler());
    return handler;
  }

  
Reset the stats returned by INFO
Returns:
/**
   * Reset the stats returned by INFO
   * @return 
   */
  public Single<String> rxConfigResetstat() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      configResetstat(fut);
    }));
  }

  
Return the number of keys in the selected database
Params:
handler – 
Returns:
/**
   * Return the number of keys in the selected database
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient dbsize(Handler<AsyncResult<Long>> handler) { 
    delegate.dbsize(handler);
    return this;
  }

    
Return the number of keys in the selected database
Returns:
Deprecated:
use rxDbsize instead/**
   * Return the number of keys in the selected database
   * @return 
   * @deprecated use {@link #rxDbsize} instead
   */
  @Deprecated()
  public Observable<Long> dbsizeObservable() { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    dbsize(handler.toHandler());
    return handler;
  }

  
Return the number of keys in the selected database
Returns:
/**
   * Return the number of keys in the selected database
   * @return 
   */
  public Single<Long> rxDbsize() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      dbsize(fut);
    }));
  }

  
Get debugging information about a key
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get debugging information about a key
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient debugObject(String key, Handler<AsyncResult<String>> handler) { 
    delegate.debugObject(key, handler);
    return this;
  }

    
Get debugging information about a key
Params:
key – Key string
Returns:
Deprecated:
use rxDebugObject instead/**
   * Get debugging information about a key
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxDebugObject} instead
   */
  @Deprecated()
  public Observable<String> debugObjectObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    debugObject(key, handler.toHandler());
    return handler;
  }

  
Get debugging information about a key
Params:
key – Key string
Returns:
/**
   * Get debugging information about a key
   * @param key Key string
   * @return 
   */
  public Single<String> rxDebugObject(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      debugObject(key, fut);
    }));
  }

  
Make the server crash
Params:
handler – 
Returns:
/**
   * Make the server crash
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient debugSegfault(Handler<AsyncResult<String>> handler) { 
    delegate.debugSegfault(handler);
    return this;
  }

    
Make the server crash
Returns:
Deprecated:
use rxDebugSegfault instead/**
   * Make the server crash
   * @return 
   * @deprecated use {@link #rxDebugSegfault} instead
   */
  @Deprecated()
  public Observable<String> debugSegfaultObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    debugSegfault(handler.toHandler());
    return handler;
  }

  
Make the server crash
Returns:
/**
   * Make the server crash
   * @return 
   */
  public Single<String> rxDebugSegfault() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      debugSegfault(fut);
    }));
  }

  
Decrement the integer value of a key by one
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Decrement the integer value of a key by one
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient decr(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.decr(key, handler);
    return this;
  }

    
Decrement the integer value of a key by one
Params:
key – Key string
Returns:
Deprecated:
use rxDecr instead/**
   * Decrement the integer value of a key by one
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxDecr} instead
   */
  @Deprecated()
  public Observable<Long> decrObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    decr(key, handler.toHandler());
    return handler;
  }

  
Decrement the integer value of a key by one
Params:
key – Key string
Returns:
/**
   * Decrement the integer value of a key by one
   * @param key Key string
   * @return 
   */
  public Single<Long> rxDecr(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      decr(key, fut);
    }));
  }

  
Decrement the integer value of a key by the given number
Params:
key – Key string
decrement – Value by which to decrement
handler – Handler for the result of this call.
Returns:
/**
   * Decrement the integer value of a key by the given number
   * @param key Key string
   * @param decrement Value by which to decrement
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient decrby(String key, long decrement, Handler<AsyncResult<Long>> handler) { 
    delegate.decrby(key, decrement, handler);
    return this;
  }

    
Decrement the integer value of a key by the given number
Params:
key – Key string
decrement – Value by which to decrement
Returns:
Deprecated:
use rxDecrby instead/**
   * Decrement the integer value of a key by the given number
   * @param key Key string
   * @param decrement Value by which to decrement
   * @return 
   * @deprecated use {@link #rxDecrby} instead
   */
  @Deprecated()
  public Observable<Long> decrbyObservable(String key, long decrement) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    decrby(key, decrement, handler.toHandler());
    return handler;
  }

  
Decrement the integer value of a key by the given number
Params:
key – Key string
decrement – Value by which to decrement
Returns:
/**
   * Decrement the integer value of a key by the given number
   * @param key Key string
   * @param decrement Value by which to decrement
   * @return 
   */
  public Single<Long> rxDecrby(String key, long decrement) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      decrby(key, decrement, fut);
    }));
  }

  
Delete a key
Params:
key – Keys to delete
handler – Handler for the result of this call.
Returns:
/**
   * Delete a key
   * @param key Keys to delete
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient del(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.del(key, handler);
    return this;
  }

    
Delete a key
Params:
key – Keys to delete
Returns:
Deprecated:
use rxDel instead/**
   * Delete a key
   * @param key Keys to delete
   * @return 
   * @deprecated use {@link #rxDel} instead
   */
  @Deprecated()
  public Observable<Long> delObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    del(key, handler.toHandler());
    return handler;
  }

  
Delete a key
Params:
key – Keys to delete
Returns:
/**
   * Delete a key
   * @param key Keys to delete
   * @return 
   */
  public Single<Long> rxDel(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      del(key, fut);
    }));
  }

  
Delete many keys
Params:
keys – List of keys to delete
handler – Handler for the result of this call.
Returns:
/**
   * Delete many keys
   * @param keys List of keys to delete
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient delMany(List<String> keys, Handler<AsyncResult<Long>> handler) { 
    delegate.delMany(keys, handler);
    return this;
  }

    
Delete many keys
Params:
keys – List of keys to delete
Returns:
Deprecated:
use rxDelMany instead/**
   * Delete many keys
   * @param keys List of keys to delete
   * @return 
   * @deprecated use {@link #rxDelMany} instead
   */
  @Deprecated()
  public Observable<Long> delManyObservable(List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    delMany(keys, handler.toHandler());
    return handler;
  }

  
Delete many keys
Params:
keys – List of keys to delete
Returns:
/**
   * Delete many keys
   * @param keys List of keys to delete
   * @return 
   */
  public Single<Long> rxDelMany(List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      delMany(keys, fut);
    }));
  }

  
Return a serialized version of the value stored at the specified key.
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Return a serialized version of the value stored at the specified key.
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient dump(String key, Handler<AsyncResult<String>> handler) { 
    delegate.dump(key, handler);
    return this;
  }

    
Return a serialized version of the value stored at the specified key.
Params:
key – Key string
Returns:
Deprecated:
use rxDump instead/**
   * Return a serialized version of the value stored at the specified key.
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxDump} instead
   */
  @Deprecated()
  public Observable<String> dumpObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    dump(key, handler.toHandler());
    return handler;
  }

  
Return a serialized version of the value stored at the specified key.
Params:
key – Key string
Returns:
/**
   * Return a serialized version of the value stored at the specified key.
   * @param key Key string
   * @return 
   */
  public Single<String> rxDump(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      dump(key, fut);
    }));
  }

  
Echo the given string
Params:
message – String to echo
handler – Handler for the result of this call.
Returns:
/**
   * Echo the given string
   * @param message String to echo
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient echo(String message, Handler<AsyncResult<String>> handler) { 
    delegate.echo(message, handler);
    return this;
  }

    
Echo the given string
Params:
message – String to echo
Returns:
Deprecated:
use rxEcho instead/**
   * Echo the given string
   * @param message String to echo
   * @return 
   * @deprecated use {@link #rxEcho} instead
   */
  @Deprecated()
  public Observable<String> echoObservable(String message) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    echo(message, handler.toHandler());
    return handler;
  }

  
Echo the given string
Params:
message – String to echo
Returns:
/**
   * Echo the given string
   * @param message String to echo
   * @return 
   */
  public Single<String> rxEcho(String message) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      echo(message, fut);
    }));
  }

  
Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
When a reply if for example a String the handler will be called with a JsonArray with a single element containing
the String.
Params:
script – Lua script to evaluate
keys – List of keys
args – List of argument values
handler – Handler for the result of this call.
Returns:
/**
   * Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
   * for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
   *
   * When a reply if for example a String the handler will be called with a JsonArray with a single element containing
   * the String.
   * @param script Lua script to evaluate
   * @param keys List of keys
   * @param args List of argument values
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient eval(String script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.eval(script, keys, args, handler);
    return this;
  }

    
Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
When a reply if for example a String the handler will be called with a JsonArray with a single element containing
the String.
Params:
script – Lua script to evaluate
keys – List of keys
args – List of argument values
Returns:
Deprecated:
use rxEval instead/**
   * Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
   * for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
   *
   * When a reply if for example a String the handler will be called with a JsonArray with a single element containing
   * the String.
   * @param script Lua script to evaluate
   * @param keys List of keys
   * @param args List of argument values
   * @return 
   * @deprecated use {@link #rxEval} instead
   */
  @Deprecated()
  public Observable<JsonArray> evalObservable(String script, List<String> keys, List<String> args) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    eval(script, keys, args, handler.toHandler());
    return handler;
  }

  
Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
When a reply if for example a String the handler will be called with a JsonArray with a single element containing
the String.
Params:
script – Lua script to evaluate
keys – List of keys
args – List of argument values
Returns:
/**
   * Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
   * for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
   *
   * When a reply if for example a String the handler will be called with a JsonArray with a single element containing
   * the String.
   * @param script Lua script to evaluate
   * @param keys List of keys
   * @param args List of argument values
   * @return 
   */
  public Single<JsonArray> rxEval(String script, List<String> keys, List<String> args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      eval(script, keys, args, fut);
    }));
  }

  
Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
When a reply if for example a String the handler will be called with a JsonArray with a single element containing
the String.
Params:
sha1 – SHA1 digest of the script cached on the server
keys – List of keys
values – List of values
handler – Handler for the result of this call.
Returns:
/**
   * Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
   * for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
   *
   * When a reply if for example a String the handler will be called with a JsonArray with a single element containing
   * the String.
   * @param sha1 SHA1 digest of the script cached on the server
   * @param keys List of keys
   * @param values List of values
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient evalsha(String sha1, List<String> keys, List<String> values, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.evalsha(sha1, keys, values, handler);
    return this;
  }

    
Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
When a reply if for example a String the handler will be called with a JsonArray with a single element containing
the String.
Params:
sha1 – SHA1 digest of the script cached on the server
keys – List of keys
values – List of values
Returns:
Deprecated:
use rxEvalsha instead/**
   * Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
   * for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
   *
   * When a reply if for example a String the handler will be called with a JsonArray with a single element containing
   * the String.
   * @param sha1 SHA1 digest of the script cached on the server
   * @param keys List of keys
   * @param values List of values
   * @return 
   * @deprecated use {@link #rxEvalsha} instead
   */
  @Deprecated()
  public Observable<JsonArray> evalshaObservable(String sha1, List<String> keys, List<String> values) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    evalsha(sha1, keys, values, handler.toHandler());
    return handler;
  }

  
Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
When a reply if for example a String the handler will be called with a JsonArray with a single element containing
the String.
Params:
sha1 – SHA1 digest of the script cached on the server
keys – List of keys
values – List of values
Returns:
/**
   * Execute a Lua script server side. Due to the dynamic nature of this command any response type could be returned
   * for This reason and to ensure type safety the reply is always guaranteed to be a JsonArray.
   *
   * When a reply if for example a String the handler will be called with a JsonArray with a single element containing
   * the String.
   * @param sha1 SHA1 digest of the script cached on the server
   * @param keys List of keys
   * @param values List of values
   * @return 
   */
  public Single<JsonArray> rxEvalsha(String sha1, List<String> keys, List<String> values) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      evalsha(sha1, keys, values, fut);
    }));
  }

  
Execute a Lua script server side. This method is a high level wrapper around EVAL and EVALSHA
using the latter if possible, falling back to EVAL if the script is not cached by the server yet.
According to Redis documentation, executed scripts are guaranteed to be in the script cache of a
given execution of a Redis instance forever, which means typically the overhead incurred by
optimistically sending EVALSHA is minimal, while improving performance and saving bandwidth
compared to using EVAL every time.
Params:
script – Lua script and its SHA1 digest
keys – List of keys
args – List of argument values
handler – Handler for the result of this call. group: scripting
Returns:
/**
   * Execute a Lua script server side. This method is a high level wrapper around EVAL and EVALSHA
   * using the latter if possible, falling back to EVAL if the script is not cached by the server yet.
   * According to Redis documentation, executed scripts are guaranteed to be in the script cache of a
   * given execution of a Redis instance forever, which means typically the overhead incurred by
   * optimistically sending EVALSHA is minimal, while improving performance and saving bandwidth
   * compared to using EVAL every time.
   * @param script Lua script and its SHA1 digest
   * @param keys List of keys
   * @param args List of argument values
   * @param handler Handler for the result of this call. group: scripting
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient evalScript(io.vertx.rxjava.redis.Script script, List<String> keys, List<String> args, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.evalScript(script.getDelegate(), keys, args, handler);
    return this;
  }

    
Execute a Lua script server side. This method is a high level wrapper around EVAL and EVALSHA
using the latter if possible, falling back to EVAL if the script is not cached by the server yet.
According to Redis documentation, executed scripts are guaranteed to be in the script cache of a
given execution of a Redis instance forever, which means typically the overhead incurred by
optimistically sending EVALSHA is minimal, while improving performance and saving bandwidth
compared to using EVAL every time.
Params:
script – Lua script and its SHA1 digest
keys – List of keys
args – List of argument values
Returns:
Deprecated:
use rxEvalScript instead/**
   * Execute a Lua script server side. This method is a high level wrapper around EVAL and EVALSHA
   * using the latter if possible, falling back to EVAL if the script is not cached by the server yet.
   * According to Redis documentation, executed scripts are guaranteed to be in the script cache of a
   * given execution of a Redis instance forever, which means typically the overhead incurred by
   * optimistically sending EVALSHA is minimal, while improving performance and saving bandwidth
   * compared to using EVAL every time.
   * @param script Lua script and its SHA1 digest
   * @param keys List of keys
   * @param args List of argument values
   * @return 
   * @deprecated use {@link #rxEvalScript} instead
   */
  @Deprecated()
  public Observable<JsonArray> evalScriptObservable(io.vertx.rxjava.redis.Script script, List<String> keys, List<String> args) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    evalScript(script, keys, args, handler.toHandler());
    return handler;
  }

  
Execute a Lua script server side. This method is a high level wrapper around EVAL and EVALSHA
using the latter if possible, falling back to EVAL if the script is not cached by the server yet.
According to Redis documentation, executed scripts are guaranteed to be in the script cache of a
given execution of a Redis instance forever, which means typically the overhead incurred by
optimistically sending EVALSHA is minimal, while improving performance and saving bandwidth
compared to using EVAL every time.
Params:
script – Lua script and its SHA1 digest
keys – List of keys
args – List of argument values
Returns:
/**
   * Execute a Lua script server side. This method is a high level wrapper around EVAL and EVALSHA
   * using the latter if possible, falling back to EVAL if the script is not cached by the server yet.
   * According to Redis documentation, executed scripts are guaranteed to be in the script cache of a
   * given execution of a Redis instance forever, which means typically the overhead incurred by
   * optimistically sending EVALSHA is minimal, while improving performance and saving bandwidth
   * compared to using EVAL every time.
   * @param script Lua script and its SHA1 digest
   * @param keys List of keys
   * @param args List of argument values
   * @return 
   */
  public Single<JsonArray> rxEvalScript(io.vertx.rxjava.redis.Script script, List<String> keys, List<String> args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      evalScript(script, keys, args, fut);
    }));
  }

  
Determine if a key exists
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Determine if a key exists
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient exists(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.exists(key, handler);
    return this;
  }

    
Determine if a key exists
Params:
key – Key string
Returns:
Deprecated:
use rxExists instead/**
   * Determine if a key exists
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxExists} instead
   */
  @Deprecated()
  public Observable<Long> existsObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    exists(key, handler.toHandler());
    return handler;
  }

  
Determine if a key exists
Params:
key – Key string
Returns:
/**
   * Determine if a key exists
   * @param key Key string
   * @return 
   */
  public Single<Long> rxExists(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      exists(key, fut);
    }));
  }

  
Determine if one or many keys exist
Params:
keys – List of key strings
handler – Handler for the result of this call.
Returns:
/**
   * Determine if one or many keys exist
   * @param keys List of key strings
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient existsMany(List<String> keys, Handler<AsyncResult<Long>> handler) { 
    delegate.existsMany(keys, handler);
    return this;
  }

    
Determine if one or many keys exist
Params:
keys – List of key strings
Returns:
Deprecated:
use rxExistsMany instead/**
   * Determine if one or many keys exist
   * @param keys List of key strings
   * @return 
   * @deprecated use {@link #rxExistsMany} instead
   */
  @Deprecated()
  public Observable<Long> existsManyObservable(List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    existsMany(keys, handler.toHandler());
    return handler;
  }

  
Determine if one or many keys exist
Params:
keys – List of key strings
Returns:
/**
   * Determine if one or many keys exist
   * @param keys List of key strings
   * @return 
   */
  public Single<Long> rxExistsMany(List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      existsMany(keys, fut);
    }));
  }

  
Set a key's time to live in seconds
Params:
key – Key string
seconds – Time to live in seconds
handler – Handler for the result of this call.
Returns:
/**
   * Set a key's time to live in seconds
   * @param key Key string
   * @param seconds Time to live in seconds
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient expire(String key, long seconds, Handler<AsyncResult<Long>> handler) { 
    delegate.expire(key, seconds, handler);
    return this;
  }

    
Set a key's time to live in seconds
Params:
key – Key string
seconds – Time to live in seconds
Returns:
Deprecated:
use rxExpire instead/**
   * Set a key's time to live in seconds
   * @param key Key string
   * @param seconds Time to live in seconds
   * @return 
   * @deprecated use {@link #rxExpire} instead
   */
  @Deprecated()
  public Observable<Long> expireObservable(String key, long seconds) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    expire(key, seconds, handler.toHandler());
    return handler;
  }

  
Set a key's time to live in seconds
Params:
key – Key string
seconds – Time to live in seconds
Returns:
/**
   * Set a key's time to live in seconds
   * @param key Key string
   * @param seconds Time to live in seconds
   * @return 
   */
  public Single<Long> rxExpire(String key, long seconds) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      expire(key, seconds, fut);
    }));
  }

  
Set the expiration for a key as a UNIX timestamp
Params:
key – Key string
seconds – Expiry time as Unix timestamp in seconds
handler – Handler for the result of this call.
Returns:
/**
   * Set the expiration for a key as a UNIX timestamp
   * @param key Key string
   * @param seconds Expiry time as Unix timestamp in seconds
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient expireat(String key, long seconds, Handler<AsyncResult<Long>> handler) { 
    delegate.expireat(key, seconds, handler);
    return this;
  }

    
Set the expiration for a key as a UNIX timestamp
Params:
key – Key string
seconds – Expiry time as Unix timestamp in seconds
Returns:
Deprecated:
use rxExpireat instead/**
   * Set the expiration for a key as a UNIX timestamp
   * @param key Key string
   * @param seconds Expiry time as Unix timestamp in seconds
   * @return 
   * @deprecated use {@link #rxExpireat} instead
   */
  @Deprecated()
  public Observable<Long> expireatObservable(String key, long seconds) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    expireat(key, seconds, handler.toHandler());
    return handler;
  }

  
Set the expiration for a key as a UNIX timestamp
Params:
key – Key string
seconds – Expiry time as Unix timestamp in seconds
Returns:
/**
   * Set the expiration for a key as a UNIX timestamp
   * @param key Key string
   * @param seconds Expiry time as Unix timestamp in seconds
   * @return 
   */
  public Single<Long> rxExpireat(String key, long seconds) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      expireat(key, seconds, fut);
    }));
  }

  
Remove all keys from all databases
Params:
handler – 
Returns:
/**
   * Remove all keys from all databases
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient flushall(Handler<AsyncResult<String>> handler) { 
    delegate.flushall(handler);
    return this;
  }

    
Remove all keys from all databases
Returns:
Deprecated:
use rxFlushall instead/**
   * Remove all keys from all databases
   * @return 
   * @deprecated use {@link #rxFlushall} instead
   */
  @Deprecated()
  public Observable<String> flushallObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    flushall(handler.toHandler());
    return handler;
  }

  
Remove all keys from all databases
Returns:
/**
   * Remove all keys from all databases
   * @return 
   */
  public Single<String> rxFlushall() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      flushall(fut);
    }));
  }

  
Remove all keys from the current database
Params:
handler – 
Returns:
/**
   * Remove all keys from the current database
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient flushdb(Handler<AsyncResult<String>> handler) { 
    delegate.flushdb(handler);
    return this;
  }

    
Remove all keys from the current database
Returns:
Deprecated:
use rxFlushdb instead/**
   * Remove all keys from the current database
   * @return 
   * @deprecated use {@link #rxFlushdb} instead
   */
  @Deprecated()
  public Observable<String> flushdbObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    flushdb(handler.toHandler());
    return handler;
  }

  
Remove all keys from the current database
Returns:
/**
   * Remove all keys from the current database
   * @return 
   */
  public Single<String> rxFlushdb() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      flushdb(fut);
    }));
  }

  
Get the value of a key
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get the value of a key
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient get(String key, Handler<AsyncResult<String>> handler) { 
    delegate.get(key, handler);
    return this;
  }

    
Get the value of a key
Params:
key – Key string
Returns:
Deprecated:
use rxGet instead/**
   * Get the value of a key
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxGet} instead
   */
  @Deprecated()
  public Observable<String> getObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    get(key, handler.toHandler());
    return handler;
  }

  
Get the value of a key
Params:
key – Key string
Returns:
/**
   * Get the value of a key
   * @param key Key string
   * @return 
   */
  public Single<String> rxGet(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      get(key, fut);
    }));
  }

  
Get the value of a key - without decoding as utf-8
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get the value of a key - without decoding as utf-8
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient getBinary(String key, Handler<AsyncResult<io.vertx.rxjava.core.buffer.Buffer>> handler) { 
    delegate.getBinary(key, new Handler<AsyncResult<io.vertx.core.buffer.Buffer>>() {
      public void handle(AsyncResult<io.vertx.core.buffer.Buffer> ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.core.buffer.Buffer.newInstance(ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    
Get the value of a key - without decoding as utf-8
Params:
key – Key string
Returns:
Deprecated:
use rxGetBinary instead/**
   * Get the value of a key - without decoding as utf-8
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxGetBinary} instead
   */
  @Deprecated()
  public Observable<io.vertx.rxjava.core.buffer.Buffer> getBinaryObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<io.vertx.rxjava.core.buffer.Buffer> handler = io.vertx.rx.java.RxHelper.observableFuture();
    getBinary(key, handler.toHandler());
    return handler;
  }

  
Get the value of a key - without decoding as utf-8
Params:
key – Key string
Returns:
/**
   * Get the value of a key - without decoding as utf-8
   * @param key Key string
   * @return 
   */
  public Single<io.vertx.rxjava.core.buffer.Buffer> rxGetBinary(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      getBinary(key, fut);
    }));
  }

  
Returns the bit value at offset in the string value stored at key
Params:
key – Key string
offset – Offset in bits
handler – Handler for the result of this call.
Returns:
/**
   * Returns the bit value at offset in the string value stored at key
   * @param key Key string
   * @param offset Offset in bits
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient getbit(String key, long offset, Handler<AsyncResult<Long>> handler) { 
    delegate.getbit(key, offset, handler);
    return this;
  }

    
Returns the bit value at offset in the string value stored at key
Params:
key – Key string
offset – Offset in bits
Returns:
Deprecated:
use rxGetbit instead/**
   * Returns the bit value at offset in the string value stored at key
   * @param key Key string
   * @param offset Offset in bits
   * @return 
   * @deprecated use {@link #rxGetbit} instead
   */
  @Deprecated()
  public Observable<Long> getbitObservable(String key, long offset) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    getbit(key, offset, handler.toHandler());
    return handler;
  }

  
Returns the bit value at offset in the string value stored at key
Params:
key – Key string
offset – Offset in bits
Returns:
/**
   * Returns the bit value at offset in the string value stored at key
   * @param key Key string
   * @param offset Offset in bits
   * @return 
   */
  public Single<Long> rxGetbit(String key, long offset) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      getbit(key, offset, fut);
    }));
  }

  
Get a substring of the string stored at a key
Params:
key – Key string
start – Start offset
end – End offset - inclusive
handler – Handler for the result of this call.
Returns:
/**
   * Get a substring of the string stored at a key
   * @param key Key string
   * @param start Start offset
   * @param end End offset - inclusive
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient getrange(String key, long start, long end, Handler<AsyncResult<String>> handler) { 
    delegate.getrange(key, start, end, handler);
    return this;
  }

    
Get a substring of the string stored at a key
Params:
key – Key string
start – Start offset
end – End offset - inclusive
Returns:
Deprecated:
use rxGetrange instead/**
   * Get a substring of the string stored at a key
   * @param key Key string
   * @param start Start offset
   * @param end End offset - inclusive
   * @return 
   * @deprecated use {@link #rxGetrange} instead
   */
  @Deprecated()
  public Observable<String> getrangeObservable(String key, long start, long end) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    getrange(key, start, end, handler.toHandler());
    return handler;
  }

  
Get a substring of the string stored at a key
Params:
key – Key string
start – Start offset
end – End offset - inclusive
Returns:
/**
   * Get a substring of the string stored at a key
   * @param key Key string
   * @param start Start offset
   * @param end End offset - inclusive
   * @return 
   */
  public Single<String> rxGetrange(String key, long start, long end) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      getrange(key, start, end, fut);
    }));
  }

  
Set the string value of a key and return its old value
Params:
key – Key of which value to set
value – New value for the key
handler – Handler for the result of this call.
Returns:
/**
   * Set the string value of a key and return its old value
   * @param key Key of which value to set
   * @param value New value for the key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient getset(String key, String value, Handler<AsyncResult<String>> handler) { 
    delegate.getset(key, value, handler);
    return this;
  }

    
Set the string value of a key and return its old value
Params:
key – Key of which value to set
value – New value for the key
Returns:
Deprecated:
use rxGetset instead/**
   * Set the string value of a key and return its old value
   * @param key Key of which value to set
   * @param value New value for the key
   * @return 
   * @deprecated use {@link #rxGetset} instead
   */
  @Deprecated()
  public Observable<String> getsetObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    getset(key, value, handler.toHandler());
    return handler;
  }

  
Set the string value of a key and return its old value
Params:
key – Key of which value to set
value – New value for the key
Returns:
/**
   * Set the string value of a key and return its old value
   * @param key Key of which value to set
   * @param value New value for the key
   * @return 
   */
  public Single<String> rxGetset(String key, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      getset(key, value, fut);
    }));
  }

  
Delete one or more hash fields
Params:
key – Key string
field – Field name
handler – Handler for the result of this call.
Returns:
/**
   * Delete one or more hash fields
   * @param key Key string
   * @param field Field name
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hdel(String key, String field, Handler<AsyncResult<Long>> handler) { 
    delegate.hdel(key, field, handler);
    return this;
  }

    
Delete one or more hash fields
Params:
key – Key string
field – Field name
Returns:
Deprecated:
use rxHdel instead/**
   * Delete one or more hash fields
   * @param key Key string
   * @param field Field name
   * @return 
   * @deprecated use {@link #rxHdel} instead
   */
  @Deprecated()
  public Observable<Long> hdelObservable(String key, String field) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hdel(key, field, handler.toHandler());
    return handler;
  }

  
Delete one or more hash fields
Params:
key – Key string
field – Field name
Returns:
/**
   * Delete one or more hash fields
   * @param key Key string
   * @param field Field name
   * @return 
   */
  public Single<Long> rxHdel(String key, String field) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hdel(key, field, fut);
    }));
  }

  
Delete one or more hash fields
Params:
key – Key string
fields – Field names
handler – Handler for the result of this call.
Returns:
/**
   * Delete one or more hash fields
   * @param key Key string
   * @param fields Field names
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hdelMany(String key, List<String> fields, Handler<AsyncResult<Long>> handler) { 
    delegate.hdelMany(key, fields, handler);
    return this;
  }

    
Delete one or more hash fields
Params:
key – Key string
fields – Field names
Returns:
Deprecated:
use rxHdelMany instead/**
   * Delete one or more hash fields
   * @param key Key string
   * @param fields Field names
   * @return 
   * @deprecated use {@link #rxHdelMany} instead
   */
  @Deprecated()
  public Observable<Long> hdelManyObservable(String key, List<String> fields) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hdelMany(key, fields, handler.toHandler());
    return handler;
  }

  
Delete one or more hash fields
Params:
key – Key string
fields – Field names
Returns:
/**
   * Delete one or more hash fields
   * @param key Key string
   * @param fields Field names
   * @return 
   */
  public Single<Long> rxHdelMany(String key, List<String> fields) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hdelMany(key, fields, fut);
    }));
  }

  
Determine if a hash field exists
Params:
key – Key string
field – Field name
handler – Handler for the result of this call.
Returns:
/**
   * Determine if a hash field exists
   * @param key Key string
   * @param field Field name
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hexists(String key, String field, Handler<AsyncResult<Long>> handler) { 
    delegate.hexists(key, field, handler);
    return this;
  }

    
Determine if a hash field exists
Params:
key – Key string
field – Field name
Returns:
Deprecated:
use rxHexists instead/**
   * Determine if a hash field exists
   * @param key Key string
   * @param field Field name
   * @return 
   * @deprecated use {@link #rxHexists} instead
   */
  @Deprecated()
  public Observable<Long> hexistsObservable(String key, String field) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hexists(key, field, handler.toHandler());
    return handler;
  }

  
Determine if a hash field exists
Params:
key – Key string
field – Field name
Returns:
/**
   * Determine if a hash field exists
   * @param key Key string
   * @param field Field name
   * @return 
   */
  public Single<Long> rxHexists(String key, String field) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hexists(key, field, fut);
    }));
  }

  
Get the value of a hash field
Params:
key – Key string
field – Field name
handler – Handler for the result of this call.
Returns:
/**
   * Get the value of a hash field
   * @param key Key string
   * @param field Field name
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hget(String key, String field, Handler<AsyncResult<String>> handler) { 
    delegate.hget(key, field, handler);
    return this;
  }

    
Get the value of a hash field
Params:
key – Key string
field – Field name
Returns:
Deprecated:
use rxHget instead/**
   * Get the value of a hash field
   * @param key Key string
   * @param field Field name
   * @return 
   * @deprecated use {@link #rxHget} instead
   */
  @Deprecated()
  public Observable<String> hgetObservable(String key, String field) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hget(key, field, handler.toHandler());
    return handler;
  }

  
Get the value of a hash field
Params:
key – Key string
field – Field name
Returns:
/**
   * Get the value of a hash field
   * @param key Key string
   * @param field Field name
   * @return 
   */
  public Single<String> rxHget(String key, String field) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hget(key, field, fut);
    }));
  }

  
Get all the fields and values in a hash
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get all the fields and values in a hash
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hgetall(String key, Handler<AsyncResult<JsonObject>> handler) { 
    delegate.hgetall(key, handler);
    return this;
  }

    
Get all the fields and values in a hash
Params:
key – Key string
Returns:
Deprecated:
use rxHgetall instead/**
   * Get all the fields and values in a hash
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxHgetall} instead
   */
  @Deprecated()
  public Observable<JsonObject> hgetallObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<JsonObject> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hgetall(key, handler.toHandler());
    return handler;
  }

  
Get all the fields and values in a hash
Params:
key – Key string
Returns:
/**
   * Get all the fields and values in a hash
   * @param key Key string
   * @return 
   */
  public Single<JsonObject> rxHgetall(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hgetall(key, fut);
    }));
  }

  
Increment the integer value of a hash field by the given number
Params:
key – Key string
field – Field name
increment – Value by which to increment
handler – Handler for the result of this call.
Returns:
/**
   * Increment the integer value of a hash field by the given number
   * @param key Key string
   * @param field Field name
   * @param increment Value by which to increment
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hincrby(String key, String field, long increment, Handler<AsyncResult<Long>> handler) { 
    delegate.hincrby(key, field, increment, handler);
    return this;
  }

    
Increment the integer value of a hash field by the given number
Params:
key – Key string
field – Field name
increment – Value by which to increment
Returns:
Deprecated:
use rxHincrby instead/**
   * Increment the integer value of a hash field by the given number
   * @param key Key string
   * @param field Field name
   * @param increment Value by which to increment
   * @return 
   * @deprecated use {@link #rxHincrby} instead
   */
  @Deprecated()
  public Observable<Long> hincrbyObservable(String key, String field, long increment) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hincrby(key, field, increment, handler.toHandler());
    return handler;
  }

  
Increment the integer value of a hash field by the given number
Params:
key – Key string
field – Field name
increment – Value by which to increment
Returns:
/**
   * Increment the integer value of a hash field by the given number
   * @param key Key string
   * @param field Field name
   * @param increment Value by which to increment
   * @return 
   */
  public Single<Long> rxHincrby(String key, String field, long increment) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hincrby(key, field, increment, fut);
    }));
  }

  
Increment the float value of a hash field by the given amount
Params:
key – Key string
field – Field name
increment – Value by which to increment
handler – Handler for the result of this call.
Returns:
/**
   * Increment the float value of a hash field by the given amount
   * @param key Key string
   * @param field Field name
   * @param increment Value by which to increment
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hincrbyfloat(String key, String field, double increment, Handler<AsyncResult<String>> handler) { 
    delegate.hincrbyfloat(key, field, increment, handler);
    return this;
  }

    
Increment the float value of a hash field by the given amount
Params:
key – Key string
field – Field name
increment – Value by which to increment
Returns:
Deprecated:
use rxHincrbyfloat instead/**
   * Increment the float value of a hash field by the given amount
   * @param key Key string
   * @param field Field name
   * @param increment Value by which to increment
   * @return 
   * @deprecated use {@link #rxHincrbyfloat} instead
   */
  @Deprecated()
  public Observable<String> hincrbyfloatObservable(String key, String field, double increment) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hincrbyfloat(key, field, increment, handler.toHandler());
    return handler;
  }

  
Increment the float value of a hash field by the given amount
Params:
key – Key string
field – Field name
increment – Value by which to increment
Returns:
/**
   * Increment the float value of a hash field by the given amount
   * @param key Key string
   * @param field Field name
   * @param increment Value by which to increment
   * @return 
   */
  public Single<String> rxHincrbyfloat(String key, String field, double increment) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hincrbyfloat(key, field, increment, fut);
    }));
  }

  
Get all the fields in a hash
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get all the fields in a hash
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hkeys(String key, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.hkeys(key, handler);
    return this;
  }

    
Get all the fields in a hash
Params:
key – Key string
Returns:
Deprecated:
use rxHkeys instead/**
   * Get all the fields in a hash
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxHkeys} instead
   */
  @Deprecated()
  public Observable<JsonArray> hkeysObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hkeys(key, handler.toHandler());
    return handler;
  }

  
Get all the fields in a hash
Params:
key – Key string
Returns:
/**
   * Get all the fields in a hash
   * @param key Key string
   * @return 
   */
  public Single<JsonArray> rxHkeys(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hkeys(key, fut);
    }));
  }

  
Get the number of fields in a hash
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get the number of fields in a hash
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hlen(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.hlen(key, handler);
    return this;
  }

    
Get the number of fields in a hash
Params:
key – Key string
Returns:
Deprecated:
use rxHlen instead/**
   * Get the number of fields in a hash
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxHlen} instead
   */
  @Deprecated()
  public Observable<Long> hlenObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hlen(key, handler.toHandler());
    return handler;
  }

  
Get the number of fields in a hash
Params:
key – Key string
Returns:
/**
   * Get the number of fields in a hash
   * @param key Key string
   * @return 
   */
  public Single<Long> rxHlen(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hlen(key, fut);
    }));
  }

  
Get the values of all the given hash fields
Params:
key – Key string
fields – Field names
handler – Handler for the result of this call.
Returns:
/**
   * Get the values of all the given hash fields
   * @param key Key string
   * @param fields Field names
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hmget(String key, List<String> fields, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.hmget(key, fields, handler);
    return this;
  }

    
Get the values of all the given hash fields
Params:
key – Key string
fields – Field names
Returns:
Deprecated:
use rxHmget instead/**
   * Get the values of all the given hash fields
   * @param key Key string
   * @param fields Field names
   * @return 
   * @deprecated use {@link #rxHmget} instead
   */
  @Deprecated()
  public Observable<JsonArray> hmgetObservable(String key, List<String> fields) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hmget(key, fields, handler.toHandler());
    return handler;
  }

  
Get the values of all the given hash fields
Params:
key – Key string
fields – Field names
Returns:
/**
   * Get the values of all the given hash fields
   * @param key Key string
   * @param fields Field names
   * @return 
   */
  public Single<JsonArray> rxHmget(String key, List<String> fields) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hmget(key, fields, fut);
    }));
  }

  
Set multiple hash fields to multiple values
Params:
key – Key string
values – Map of field:value pairs
handler – Handler for the result of this call.
Returns:
/**
   * Set multiple hash fields to multiple values
   * @param key Key string
   * @param values Map of field:value pairs
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hmset(String key, JsonObject values, Handler<AsyncResult<String>> handler) { 
    delegate.hmset(key, values, handler);
    return this;
  }

    
Set multiple hash fields to multiple values
Params:
key – Key string
values – Map of field:value pairs
Returns:
Deprecated:
use rxHmset instead/**
   * Set multiple hash fields to multiple values
   * @param key Key string
   * @param values Map of field:value pairs
   * @return 
   * @deprecated use {@link #rxHmset} instead
   */
  @Deprecated()
  public Observable<String> hmsetObservable(String key, JsonObject values) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hmset(key, values, handler.toHandler());
    return handler;
  }

  
Set multiple hash fields to multiple values
Params:
key – Key string
values – Map of field:value pairs
Returns:
/**
   * Set multiple hash fields to multiple values
   * @param key Key string
   * @param values Map of field:value pairs
   * @return 
   */
  public Single<String> rxHmset(String key, JsonObject values) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hmset(key, values, fut);
    }));
  }

  
Set the string value of a hash field
Params:
key – Key string
field – Field name
value – New value
handler – Handler for the result of this call.
Returns:
/**
   * Set the string value of a hash field
   * @param key Key string
   * @param field Field name
   * @param value New value
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hset(String key, String field, String value, Handler<AsyncResult<Long>> handler) { 
    delegate.hset(key, field, value, handler);
    return this;
  }

    
Set the string value of a hash field
Params:
key – Key string
field – Field name
value – New value
Returns:
Deprecated:
use rxHset instead/**
   * Set the string value of a hash field
   * @param key Key string
   * @param field Field name
   * @param value New value
   * @return 
   * @deprecated use {@link #rxHset} instead
   */
  @Deprecated()
  public Observable<Long> hsetObservable(String key, String field, String value) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hset(key, field, value, handler.toHandler());
    return handler;
  }

  
Set the string value of a hash field
Params:
key – Key string
field – Field name
value – New value
Returns:
/**
   * Set the string value of a hash field
   * @param key Key string
   * @param field Field name
   * @param value New value
   * @return 
   */
  public Single<Long> rxHset(String key, String field, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hset(key, field, value, fut);
    }));
  }

  
Set the value of a hash field, only if the field does not exist
Params:
key – Key string
field – Field name
value – New value
handler – Handler for the result of this call.
Returns:
/**
   * Set the value of a hash field, only if the field does not exist
   * @param key Key string
   * @param field Field name
   * @param value New value
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hsetnx(String key, String field, String value, Handler<AsyncResult<Long>> handler) { 
    delegate.hsetnx(key, field, value, handler);
    return this;
  }

    
Set the value of a hash field, only if the field does not exist
Params:
key – Key string
field – Field name
value – New value
Returns:
Deprecated:
use rxHsetnx instead/**
   * Set the value of a hash field, only if the field does not exist
   * @param key Key string
   * @param field Field name
   * @param value New value
   * @return 
   * @deprecated use {@link #rxHsetnx} instead
   */
  @Deprecated()
  public Observable<Long> hsetnxObservable(String key, String field, String value) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hsetnx(key, field, value, handler.toHandler());
    return handler;
  }

  
Set the value of a hash field, only if the field does not exist
Params:
key – Key string
field – Field name
value – New value
Returns:
/**
   * Set the value of a hash field, only if the field does not exist
   * @param key Key string
   * @param field Field name
   * @param value New value
   * @return 
   */
  public Single<Long> rxHsetnx(String key, String field, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hsetnx(key, field, value, fut);
    }));
  }

  
Get all the values in a hash
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get all the values in a hash
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hvals(String key, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.hvals(key, handler);
    return this;
  }

    
Get all the values in a hash
Params:
key – Key string
Returns:
Deprecated:
use rxHvals instead/**
   * Get all the values in a hash
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxHvals} instead
   */
  @Deprecated()
  public Observable<JsonArray> hvalsObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hvals(key, handler.toHandler());
    return handler;
  }

  
Get all the values in a hash
Params:
key – Key string
Returns:
/**
   * Get all the values in a hash
   * @param key Key string
   * @return 
   */
  public Single<JsonArray> rxHvals(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hvals(key, fut);
    }));
  }

  
Increment the integer value of a key by one
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Increment the integer value of a key by one
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient incr(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.incr(key, handler);
    return this;
  }

    
Increment the integer value of a key by one
Params:
key – Key string
Returns:
Deprecated:
use rxIncr instead/**
   * Increment the integer value of a key by one
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxIncr} instead
   */
  @Deprecated()
  public Observable<Long> incrObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    incr(key, handler.toHandler());
    return handler;
  }

  
Increment the integer value of a key by one
Params:
key – Key string
Returns:
/**
   * Increment the integer value of a key by one
   * @param key Key string
   * @return 
   */
  public Single<Long> rxIncr(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      incr(key, fut);
    }));
  }

  
Increment the integer value of a key by the given amount
Params:
key – Key string
increment – Value by which to increment
handler – Handler for the result of this call.
Returns:
/**
   * Increment the integer value of a key by the given amount
   * @param key Key string
   * @param increment Value by which to increment
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient incrby(String key, long increment, Handler<AsyncResult<Long>> handler) { 
    delegate.incrby(key, increment, handler);
    return this;
  }

    
Increment the integer value of a key by the given amount
Params:
key – Key string
increment – Value by which to increment
Returns:
Deprecated:
use rxIncrby instead/**
   * Increment the integer value of a key by the given amount
   * @param key Key string
   * @param increment Value by which to increment
   * @return 
   * @deprecated use {@link #rxIncrby} instead
   */
  @Deprecated()
  public Observable<Long> incrbyObservable(String key, long increment) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    incrby(key, increment, handler.toHandler());
    return handler;
  }

  
Increment the integer value of a key by the given amount
Params:
key – Key string
increment – Value by which to increment
Returns:
/**
   * Increment the integer value of a key by the given amount
   * @param key Key string
   * @param increment Value by which to increment
   * @return 
   */
  public Single<Long> rxIncrby(String key, long increment) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      incrby(key, increment, fut);
    }));
  }

  
Increment the float value of a key by the given amount
Params:
key – Key string
increment – Value by which to increment
handler – Handler for the result of this call.
Returns:
/**
   * Increment the float value of a key by the given amount
   * @param key Key string
   * @param increment Value by which to increment
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient incrbyfloat(String key, double increment, Handler<AsyncResult<String>> handler) { 
    delegate.incrbyfloat(key, increment, handler);
    return this;
  }

    
Increment the float value of a key by the given amount
Params:
key – Key string
increment – Value by which to increment
Returns:
Deprecated:
use rxIncrbyfloat instead/**
   * Increment the float value of a key by the given amount
   * @param key Key string
   * @param increment Value by which to increment
   * @return 
   * @deprecated use {@link #rxIncrbyfloat} instead
   */
  @Deprecated()
  public Observable<String> incrbyfloatObservable(String key, double increment) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    incrbyfloat(key, increment, handler.toHandler());
    return handler;
  }

  
Increment the float value of a key by the given amount
Params:
key – Key string
increment – Value by which to increment
Returns:
/**
   * Increment the float value of a key by the given amount
   * @param key Key string
   * @param increment Value by which to increment
   * @return 
   */
  public Single<String> rxIncrbyfloat(String key, double increment) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      incrbyfloat(key, increment, fut);
    }));
  }

  
Get information and statistics about the server
Params:
handler – Handler for the result of this call.
Returns:
/**
   * Get information and statistics about the server
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient info(Handler<AsyncResult<JsonObject>> handler) { 
    delegate.info(handler);
    return this;
  }

    
Get information and statistics about the server
Returns:
Deprecated:
use rxInfo instead/**
   * Get information and statistics about the server
   * @return 
   * @deprecated use {@link #rxInfo} instead
   */
  @Deprecated()
  public Observable<JsonObject> infoObservable() { 
    io.vertx.rx.java.ObservableFuture<JsonObject> handler = io.vertx.rx.java.RxHelper.observableFuture();
    info(handler.toHandler());
    return handler;
  }

  
Get information and statistics about the server
Returns:
/**
   * Get information and statistics about the server
   * @return 
   */
  public Single<JsonObject> rxInfo() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      info(fut);
    }));
  }

  
Get information and statistics about the server
Params:
section – Specific section of information to return
handler – Handler for the result of this call.
Returns:
/**
   * Get information and statistics about the server
   * @param section Specific section of information to return
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient infoSection(String section, Handler<AsyncResult<JsonObject>> handler) { 
    delegate.infoSection(section, handler);
    return this;
  }

    
Get information and statistics about the server
Params:
section – Specific section of information to return
Returns:
Deprecated:
use rxInfoSection instead/**
   * Get information and statistics about the server
   * @param section Specific section of information to return
   * @return 
   * @deprecated use {@link #rxInfoSection} instead
   */
  @Deprecated()
  public Observable<JsonObject> infoSectionObservable(String section) { 
    io.vertx.rx.java.ObservableFuture<JsonObject> handler = io.vertx.rx.java.RxHelper.observableFuture();
    infoSection(section, handler.toHandler());
    return handler;
  }

  
Get information and statistics about the server
Params:
section – Specific section of information to return
Returns:
/**
   * Get information and statistics about the server
   * @param section Specific section of information to return
   * @return 
   */
  public Single<JsonObject> rxInfoSection(String section) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      infoSection(section, fut);
    }));
  }

  
Find all keys matching the given pattern
Params:
pattern – Pattern to limit the keys returned
handler – Handler for the result of this call.
Returns:
/**
   * Find all keys matching the given pattern
   * @param pattern Pattern to limit the keys returned
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient keys(String pattern, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.keys(pattern, handler);
    return this;
  }

    
Find all keys matching the given pattern
Params:
pattern – Pattern to limit the keys returned
Returns:
Deprecated:
use rxKeys instead/**
   * Find all keys matching the given pattern
   * @param pattern Pattern to limit the keys returned
   * @return 
   * @deprecated use {@link #rxKeys} instead
   */
  @Deprecated()
  public Observable<JsonArray> keysObservable(String pattern) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    keys(pattern, handler.toHandler());
    return handler;
  }

  
Find all keys matching the given pattern
Params:
pattern – Pattern to limit the keys returned
Returns:
/**
   * Find all keys matching the given pattern
   * @param pattern Pattern to limit the keys returned
   * @return 
   */
  public Single<JsonArray> rxKeys(String pattern) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      keys(pattern, fut);
    }));
  }

  
Get the UNIX time stamp of the last successful save to disk
Params:
handler – 
Returns:
/**
   * Get the UNIX time stamp of the last successful save to disk
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient lastsave(Handler<AsyncResult<Long>> handler) { 
    delegate.lastsave(handler);
    return this;
  }

    
Get the UNIX time stamp of the last successful save to disk
Returns:
Deprecated:
use rxLastsave instead/**
   * Get the UNIX time stamp of the last successful save to disk
   * @return 
   * @deprecated use {@link #rxLastsave} instead
   */
  @Deprecated()
  public Observable<Long> lastsaveObservable() { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    lastsave(handler.toHandler());
    return handler;
  }

  
Get the UNIX time stamp of the last successful save to disk
Returns:
/**
   * Get the UNIX time stamp of the last successful save to disk
   * @return 
   */
  public Single<Long> rxLastsave() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lastsave(fut);
    }));
  }

  
Get an element from a list by its index
Params:
key – Key string
index – Index of list element to get
handler – Handler for the result of this call.
Returns:
/**
   * Get an element from a list by its index
   * @param key Key string
   * @param index Index of list element to get
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient lindex(String key, int index, Handler<AsyncResult<String>> handler) { 
    delegate.lindex(key, index, handler);
    return this;
  }

    
Get an element from a list by its index
Params:
key – Key string
index – Index of list element to get
Returns:
Deprecated:
use rxLindex instead/**
   * Get an element from a list by its index
   * @param key Key string
   * @param index Index of list element to get
   * @return 
   * @deprecated use {@link #rxLindex} instead
   */
  @Deprecated()
  public Observable<String> lindexObservable(String key, int index) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    lindex(key, index, handler.toHandler());
    return handler;
  }

  
Get an element from a list by its index
Params:
key – Key string
index – Index of list element to get
Returns:
/**
   * Get an element from a list by its index
   * @param key Key string
   * @param index Index of list element to get
   * @return 
   */
  public Single<String> rxLindex(String key, int index) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lindex(key, index, fut);
    }));
  }

  
Insert an element before or after another element in a list
Params:
key – Key string
option – BEFORE or AFTER
pivot – Key to use as a pivot
value – Value to be inserted before or after the pivot
handler – Handler for the result of this call.
Returns:
/**
   * Insert an element before or after another element in a list
   * @param key Key string
   * @param option BEFORE or AFTER
   * @param pivot Key to use as a pivot
   * @param value Value to be inserted before or after the pivot
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient linsert(String key, InsertOptions option, String pivot, String value, Handler<AsyncResult<Long>> handler) { 
    delegate.linsert(key, option, pivot, value, handler);
    return this;
  }

    
Insert an element before or after another element in a list
Params:
key – Key string
option – BEFORE or AFTER
pivot – Key to use as a pivot
value – Value to be inserted before or after the pivot
Returns:
Deprecated:
use rxLinsert instead/**
   * Insert an element before or after another element in a list
   * @param key Key string
   * @param option BEFORE or AFTER
   * @param pivot Key to use as a pivot
   * @param value Value to be inserted before or after the pivot
   * @return 
   * @deprecated use {@link #rxLinsert} instead
   */
  @Deprecated()
  public Observable<Long> linsertObservable(String key, InsertOptions option, String pivot, String value) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    linsert(key, option, pivot, value, handler.toHandler());
    return handler;
  }

  
Insert an element before or after another element in a list
Params:
key – Key string
option – BEFORE or AFTER
pivot – Key to use as a pivot
value – Value to be inserted before or after the pivot
Returns:
/**
   * Insert an element before or after another element in a list
   * @param key Key string
   * @param option BEFORE or AFTER
   * @param pivot Key to use as a pivot
   * @param value Value to be inserted before or after the pivot
   * @return 
   */
  public Single<Long> rxLinsert(String key, InsertOptions option, String pivot, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      linsert(key, option, pivot, value, fut);
    }));
  }

  
Get the length of a list
Params:
key – String key
handler – Handler for the result of this call.
Returns:
/**
   * Get the length of a list
   * @param key String key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient llen(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.llen(key, handler);
    return this;
  }

    
Get the length of a list
Params:
key – String key
Returns:
Deprecated:
use rxLlen instead/**
   * Get the length of a list
   * @param key String key
   * @return 
   * @deprecated use {@link #rxLlen} instead
   */
  @Deprecated()
  public Observable<Long> llenObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    llen(key, handler.toHandler());
    return handler;
  }

  
Get the length of a list
Params:
key – String key
Returns:
/**
   * Get the length of a list
   * @param key String key
   * @return 
   */
  public Single<Long> rxLlen(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      llen(key, fut);
    }));
  }

  
Remove and get the first element in a list
Params:
key – String key
handler – Handler for the result of this call.
Returns:
/**
   * Remove and get the first element in a list
   * @param key String key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient lpop(String key, Handler<AsyncResult<String>> handler) { 
    delegate.lpop(key, handler);
    return this;
  }

    
Remove and get the first element in a list
Params:
key – String key
Returns:
Deprecated:
use rxLpop instead/**
   * Remove and get the first element in a list
   * @param key String key
   * @return 
   * @deprecated use {@link #rxLpop} instead
   */
  @Deprecated()
  public Observable<String> lpopObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    lpop(key, handler.toHandler());
    return handler;
  }

  
Remove and get the first element in a list
Params:
key – String key
Returns:
/**
   * Remove and get the first element in a list
   * @param key String key
   * @return 
   */
  public Single<String> rxLpop(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lpop(key, fut);
    }));
  }

  
Prepend one or multiple values to a list
Params:
key – Key string
values – Values to be added at the beginning of the list, one by one
handler – Handler for the result of this call.
Returns:
/**
   * Prepend one or multiple values to a list
   * @param key Key string
   * @param values Values to be added at the beginning of the list, one by one
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient lpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler) { 
    delegate.lpushMany(key, values, handler);
    return this;
  }

    
Prepend one or multiple values to a list
Params:
key – Key string
values – Values to be added at the beginning of the list, one by one
Returns:
Deprecated:
use rxLpushMany instead/**
   * Prepend one or multiple values to a list
   * @param key Key string
   * @param values Values to be added at the beginning of the list, one by one
   * @return 
   * @deprecated use {@link #rxLpushMany} instead
   */
  @Deprecated()
  public Observable<Long> lpushManyObservable(String key, List<String> values) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    lpushMany(key, values, handler.toHandler());
    return handler;
  }

  
Prepend one or multiple values to a list
Params:
key – Key string
values – Values to be added at the beginning of the list, one by one
Returns:
/**
   * Prepend one or multiple values to a list
   * @param key Key string
   * @param values Values to be added at the beginning of the list, one by one
   * @return 
   */
  public Single<Long> rxLpushMany(String key, List<String> values) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lpushMany(key, values, fut);
    }));
  }

  
Prepend one value to a list
Params:
key – Key string
value – Value to be added at the beginning of the list
handler – Handler for the result of this call.
Returns:
/**
   * Prepend one value to a list
   * @param key Key string
   * @param value Value to be added at the beginning of the list
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient lpush(String key, String value, Handler<AsyncResult<Long>> handler) { 
    delegate.lpush(key, value, handler);
    return this;
  }

    
Prepend one value to a list
Params:
key – Key string
value – Value to be added at the beginning of the list
Returns:
Deprecated:
use rxLpush instead/**
   * Prepend one value to a list
   * @param key Key string
   * @param value Value to be added at the beginning of the list
   * @return 
   * @deprecated use {@link #rxLpush} instead
   */
  @Deprecated()
  public Observable<Long> lpushObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    lpush(key, value, handler.toHandler());
    return handler;
  }

  
Prepend one value to a list
Params:
key – Key string
value – Value to be added at the beginning of the list
Returns:
/**
   * Prepend one value to a list
   * @param key Key string
   * @param value Value to be added at the beginning of the list
   * @return 
   */
  public Single<Long> rxLpush(String key, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lpush(key, value, fut);
    }));
  }

  
Prepend a value to a list, only if the list exists
Params:
key – Key string
value – Value to add at the beginning of the list
handler – Handler for the result of this call.
Returns:
/**
   * Prepend a value to a list, only if the list exists
   * @param key Key string
   * @param value Value to add at the beginning of the list
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient lpushx(String key, String value, Handler<AsyncResult<Long>> handler) { 
    delegate.lpushx(key, value, handler);
    return this;
  }

    
Prepend a value to a list, only if the list exists
Params:
key – Key string
value – Value to add at the beginning of the list
Returns:
Deprecated:
use rxLpushx instead/**
   * Prepend a value to a list, only if the list exists
   * @param key Key string
   * @param value Value to add at the beginning of the list
   * @return 
   * @deprecated use {@link #rxLpushx} instead
   */
  @Deprecated()
  public Observable<Long> lpushxObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    lpushx(key, value, handler.toHandler());
    return handler;
  }

  
Prepend a value to a list, only if the list exists
Params:
key – Key string
value – Value to add at the beginning of the list
Returns:
/**
   * Prepend a value to a list, only if the list exists
   * @param key Key string
   * @param value Value to add at the beginning of the list
   * @return 
   */
  public Single<Long> rxLpushx(String key, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lpushx(key, value, fut);
    }));
  }

  
Get a range of elements from a list
Params:
key – Key string
from – Start index
to – Stop index
handler – Handler for the result of this call.
Returns:
/**
   * Get a range of elements from a list
   * @param key Key string
   * @param from Start index
   * @param to Stop index
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient lrange(String key, long from, long to, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.lrange(key, from, to, handler);
    return this;
  }

    
Get a range of elements from a list
Params:
key – Key string
from – Start index
to – Stop index
Returns:
Deprecated:
use rxLrange instead/**
   * Get a range of elements from a list
   * @param key Key string
   * @param from Start index
   * @param to Stop index
   * @return 
   * @deprecated use {@link #rxLrange} instead
   */
  @Deprecated()
  public Observable<JsonArray> lrangeObservable(String key, long from, long to) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    lrange(key, from, to, handler.toHandler());
    return handler;
  }

  
Get a range of elements from a list
Params:
key – Key string
from – Start index
to – Stop index
Returns:
/**
   * Get a range of elements from a list
   * @param key Key string
   * @param from Start index
   * @param to Stop index
   * @return 
   */
  public Single<JsonArray> rxLrange(String key, long from, long to) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lrange(key, from, to, fut);
    }));
  }

  
Remove elements from a list
Params:
key – Key string
count – Number of first found occurrences equal to $value to remove from the list
value – Value to be removed
handler – Handler for the result of this call.
Returns:
/**
   * Remove elements from a list
   * @param key Key string
   * @param count Number of first found occurrences equal to $value to remove from the list
   * @param value Value to be removed
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient lrem(String key, long count, String value, Handler<AsyncResult<Long>> handler) { 
    delegate.lrem(key, count, value, handler);
    return this;
  }

    
Remove elements from a list
Params:
key – Key string
count – Number of first found occurrences equal to $value to remove from the list
value – Value to be removed
Returns:
Deprecated:
use rxLrem instead/**
   * Remove elements from a list
   * @param key Key string
   * @param count Number of first found occurrences equal to $value to remove from the list
   * @param value Value to be removed
   * @return 
   * @deprecated use {@link #rxLrem} instead
   */
  @Deprecated()
  public Observable<Long> lremObservable(String key, long count, String value) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    lrem(key, count, value, handler.toHandler());
    return handler;
  }

  
Remove elements from a list
Params:
key – Key string
count – Number of first found occurrences equal to $value to remove from the list
value – Value to be removed
Returns:
/**
   * Remove elements from a list
   * @param key Key string
   * @param count Number of first found occurrences equal to $value to remove from the list
   * @param value Value to be removed
   * @return 
   */
  public Single<Long> rxLrem(String key, long count, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lrem(key, count, value, fut);
    }));
  }

  
Set the value of an element in a list by its index
Params:
key – Key string
index – Position within list
value – New value
handler – Handler for the result of this call.
Returns:
/**
   * Set the value of an element in a list by its index
   * @param key Key string
   * @param index Position within list
   * @param value New value
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient lset(String key, long index, String value, Handler<AsyncResult<String>> handler) { 
    delegate.lset(key, index, value, handler);
    return this;
  }

    
Set the value of an element in a list by its index
Params:
key – Key string
index – Position within list
value – New value
Returns:
Deprecated:
use rxLset instead/**
   * Set the value of an element in a list by its index
   * @param key Key string
   * @param index Position within list
   * @param value New value
   * @return 
   * @deprecated use {@link #rxLset} instead
   */
  @Deprecated()
  public Observable<String> lsetObservable(String key, long index, String value) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    lset(key, index, value, handler.toHandler());
    return handler;
  }

  
Set the value of an element in a list by its index
Params:
key – Key string
index – Position within list
value – New value
Returns:
/**
   * Set the value of an element in a list by its index
   * @param key Key string
   * @param index Position within list
   * @param value New value
   * @return 
   */
  public Single<String> rxLset(String key, long index, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lset(key, index, value, fut);
    }));
  }

  
Trim a list to the specified range
Params:
key – Key string
from – Start index
to – Stop index
handler – Handler for the result of this call.
Returns:
/**
   * Trim a list to the specified range
   * @param key Key string
   * @param from Start index
   * @param to Stop index
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient ltrim(String key, long from, long to, Handler<AsyncResult<String>> handler) { 
    delegate.ltrim(key, from, to, handler);
    return this;
  }

    
Trim a list to the specified range
Params:
key – Key string
from – Start index
to – Stop index
Returns:
Deprecated:
use rxLtrim instead/**
   * Trim a list to the specified range
   * @param key Key string
   * @param from Start index
   * @param to Stop index
   * @return 
   * @deprecated use {@link #rxLtrim} instead
   */
  @Deprecated()
  public Observable<String> ltrimObservable(String key, long from, long to) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    ltrim(key, from, to, handler.toHandler());
    return handler;
  }

  
Trim a list to the specified range
Params:
key – Key string
from – Start index
to – Stop index
Returns:
/**
   * Trim a list to the specified range
   * @param key Key string
   * @param from Start index
   * @param to Stop index
   * @return 
   */
  public Single<String> rxLtrim(String key, long from, long to) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      ltrim(key, from, to, fut);
    }));
  }

  
Get the value of the given key
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get the value of the given key
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient mget(String key, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.mget(key, handler);
    return this;
  }

    
Get the value of the given key
Params:
key – Key string
Returns:
Deprecated:
use rxMget instead/**
   * Get the value of the given key
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxMget} instead
   */
  @Deprecated()
  public Observable<JsonArray> mgetObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    mget(key, handler.toHandler());
    return handler;
  }

  
Get the value of the given key
Params:
key – Key string
Returns:
/**
   * Get the value of the given key
   * @param key Key string
   * @return 
   */
  public Single<JsonArray> rxMget(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      mget(key, fut);
    }));
  }

  
Get the values of all the given keys
Params:
keys – List of keys to get
handler – Handler for the result of this call.
Returns:
/**
   * Get the values of all the given keys
   * @param keys List of keys to get
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient mgetMany(List<String> keys, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.mgetMany(keys, handler);
    return this;
  }

    
Get the values of all the given keys
Params:
keys – List of keys to get
Returns:
Deprecated:
use rxMgetMany instead/**
   * Get the values of all the given keys
   * @param keys List of keys to get
   * @return 
   * @deprecated use {@link #rxMgetMany} instead
   */
  @Deprecated()
  public Observable<JsonArray> mgetManyObservable(List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    mgetMany(keys, handler.toHandler());
    return handler;
  }

  
Get the values of all the given keys
Params:
keys – List of keys to get
Returns:
/**
   * Get the values of all the given keys
   * @param keys List of keys to get
   * @return 
   */
  public Single<JsonArray> rxMgetMany(List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      mgetMany(keys, fut);
    }));
  }

  
Atomically transfer a key from a Redis instance to another one.
Params:
host – Destination host
port – Destination port
key – Key to migrate
destdb – Destination database index
timeout – 
options – Migrate options
handler – Handler for the result of this call.
Returns:
/**
   * Atomically transfer a key from a Redis instance to another one.
   * @param host Destination host
   * @param port Destination port
   * @param key Key to migrate
   * @param destdb Destination database index
   * @param timeout 
   * @param options Migrate options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient migrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options, Handler<AsyncResult<String>> handler) { 
    delegate.migrate(host, port, key, destdb, timeout, options, handler);
    return this;
  }

    
Atomically transfer a key from a Redis instance to another one.
Params:
host – Destination host
port – Destination port
key – Key to migrate
destdb – Destination database index
timeout – 
options – Migrate options
Returns:
Deprecated:
use rxMigrate instead/**
   * Atomically transfer a key from a Redis instance to another one.
   * @param host Destination host
   * @param port Destination port
   * @param key Key to migrate
   * @param destdb Destination database index
   * @param timeout 
   * @param options Migrate options
   * @return 
   * @deprecated use {@link #rxMigrate} instead
   */
  @Deprecated()
  public Observable<String> migrateObservable(String host, int port, String key, int destdb, long timeout, MigrateOptions options) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    migrate(host, port, key, destdb, timeout, options, handler.toHandler());
    return handler;
  }

  
Atomically transfer a key from a Redis instance to another one.
Params:
host – Destination host
port – Destination port
key – Key to migrate
destdb – Destination database index
timeout – 
options – Migrate options
Returns:
/**
   * Atomically transfer a key from a Redis instance to another one.
   * @param host Destination host
   * @param port Destination port
   * @param key Key to migrate
   * @param destdb Destination database index
   * @param timeout 
   * @param options Migrate options
   * @return 
   */
  public Single<String> rxMigrate(String host, int port, String key, int destdb, long timeout, MigrateOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      migrate(host, port, key, destdb, timeout, options, fut);
    }));
  }

  
Listen for all requests received by the server in real time
Params:
handler – 
Returns:
/**
   * Listen for all requests received by the server in real time
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient monitor(Handler<AsyncResult<Void>> handler) { 
    delegate.monitor(handler);
    return this;
  }

    
Listen for all requests received by the server in real time
Returns:
Deprecated:
use rxMonitor instead/**
   * Listen for all requests received by the server in real time
   * @return 
   * @deprecated use {@link #rxMonitor} instead
   */
  @Deprecated()
  public Observable<Void> monitorObservable() { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    monitor(handler.toHandler());
    return handler;
  }

  
Listen for all requests received by the server in real time
Returns:
/**
   * Listen for all requests received by the server in real time
   * @return 
   */
  public Single<Void> rxMonitor() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      monitor(fut);
    }));
  }

  
Move a key to another database
Params:
key – Key to migrate
destdb – Destination database index
handler – Handler for the result of this call.
Returns:
/**
   * Move a key to another database
   * @param key Key to migrate
   * @param destdb Destination database index
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient move(String key, int destdb, Handler<AsyncResult<Long>> handler) { 
    delegate.move(key, destdb, handler);
    return this;
  }

    
Move a key to another database
Params:
key – Key to migrate
destdb – Destination database index
Returns:
Deprecated:
use rxMove instead/**
   * Move a key to another database
   * @param key Key to migrate
   * @param destdb Destination database index
   * @return 
   * @deprecated use {@link #rxMove} instead
   */
  @Deprecated()
  public Observable<Long> moveObservable(String key, int destdb) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    move(key, destdb, handler.toHandler());
    return handler;
  }

  
Move a key to another database
Params:
key – Key to migrate
destdb – Destination database index
Returns:
/**
   * Move a key to another database
   * @param key Key to migrate
   * @param destdb Destination database index
   * @return 
   */
  public Single<Long> rxMove(String key, int destdb) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      move(key, destdb, fut);
    }));
  }

  
Set multiple keys to multiple values
Params:
keyvals – Key value pairs to set
handler – Handler for the result of this call.
Returns:
/**
   * Set multiple keys to multiple values
   * @param keyvals Key value pairs to set
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient mset(JsonObject keyvals, Handler<AsyncResult<String>> handler) { 
    delegate.mset(keyvals, handler);
    return this;
  }

    
Set multiple keys to multiple values
Params:
keyvals – Key value pairs to set
Returns:
Deprecated:
use rxMset instead/**
   * Set multiple keys to multiple values
   * @param keyvals Key value pairs to set
   * @return 
   * @deprecated use {@link #rxMset} instead
   */
  @Deprecated()
  public Observable<String> msetObservable(JsonObject keyvals) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    mset(keyvals, handler.toHandler());
    return handler;
  }

  
Set multiple keys to multiple values
Params:
keyvals – Key value pairs to set
Returns:
/**
   * Set multiple keys to multiple values
   * @param keyvals Key value pairs to set
   * @return 
   */
  public Single<String> rxMset(JsonObject keyvals) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      mset(keyvals, fut);
    }));
  }

  
Set multiple keys to multiple values, only if none of the keys exist
Params:
keyvals – Key value pairs to set
handler – Handler for the result of this call.
Returns:
/**
   * Set multiple keys to multiple values, only if none of the keys exist
   * @param keyvals Key value pairs to set
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient msetnx(JsonObject keyvals, Handler<AsyncResult<Long>> handler) { 
    delegate.msetnx(keyvals, handler);
    return this;
  }

    
Set multiple keys to multiple values, only if none of the keys exist
Params:
keyvals – Key value pairs to set
Returns:
Deprecated:
use rxMsetnx instead/**
   * Set multiple keys to multiple values, only if none of the keys exist
   * @param keyvals Key value pairs to set
   * @return 
   * @deprecated use {@link #rxMsetnx} instead
   */
  @Deprecated()
  public Observable<Long> msetnxObservable(JsonObject keyvals) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    msetnx(keyvals, handler.toHandler());
    return handler;
  }

  
Set multiple keys to multiple values, only if none of the keys exist
Params:
keyvals – Key value pairs to set
Returns:
/**
   * Set multiple keys to multiple values, only if none of the keys exist
   * @param keyvals Key value pairs to set
   * @return 
   */
  public Single<Long> rxMsetnx(JsonObject keyvals) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      msetnx(keyvals, fut);
    }));
  }

  
Inspect the internals of Redis objects
Params:
key – Key string
cmd – Object sub command
handler – Handler for the result of this call.
Returns:
/**
   * Inspect the internals of Redis objects
   * @param key Key string
   * @param cmd Object sub command
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient object(String key, ObjectCmd cmd, Handler<AsyncResult<Void>> handler) { 
    delegate.object(key, cmd, handler);
    return this;
  }

    
Inspect the internals of Redis objects
Params:
key – Key string
cmd – Object sub command
Returns:
Deprecated:
use rxObject instead/**
   * Inspect the internals of Redis objects
   * @param key Key string
   * @param cmd Object sub command
   * @return 
   * @deprecated use {@link #rxObject} instead
   */
  @Deprecated()
  public Observable<Void> objectObservable(String key, ObjectCmd cmd) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    object(key, cmd, handler.toHandler());
    return handler;
  }

  
Inspect the internals of Redis objects
Params:
key – Key string
cmd – Object sub command
Returns:
/**
   * Inspect the internals of Redis objects
   * @param key Key string
   * @param cmd Object sub command
   * @return 
   */
  public Single<Void> rxObject(String key, ObjectCmd cmd) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      object(key, cmd, fut);
    }));
  }

  
Remove the expiration from a key
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Remove the expiration from a key
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient persist(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.persist(key, handler);
    return this;
  }

    
Remove the expiration from a key
Params:
key – Key string
Returns:
Deprecated:
use rxPersist instead/**
   * Remove the expiration from a key
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxPersist} instead
   */
  @Deprecated()
  public Observable<Long> persistObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    persist(key, handler.toHandler());
    return handler;
  }

  
Remove the expiration from a key
Params:
key – Key string
Returns:
/**
   * Remove the expiration from a key
   * @param key Key string
   * @return 
   */
  public Single<Long> rxPersist(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      persist(key, fut);
    }));
  }

  
Set a key's time to live in milliseconds
Params:
key – String key
millis – Time to live in milliseconds
handler – Handler for the result of this call.
Returns:
/**
   * Set a key's time to live in milliseconds
   * @param key String key
   * @param millis Time to live in milliseconds
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pexpire(String key, long millis, Handler<AsyncResult<Long>> handler) { 
    delegate.pexpire(key, millis, handler);
    return this;
  }

    
Set a key's time to live in milliseconds
Params:
key – String key
millis – Time to live in milliseconds
Returns:
Deprecated:
use rxPexpire instead/**
   * Set a key's time to live in milliseconds
   * @param key String key
   * @param millis Time to live in milliseconds
   * @return 
   * @deprecated use {@link #rxPexpire} instead
   */
  @Deprecated()
  public Observable<Long> pexpireObservable(String key, long millis) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pexpire(key, millis, handler.toHandler());
    return handler;
  }

  
Set a key's time to live in milliseconds
Params:
key – String key
millis – Time to live in milliseconds
Returns:
/**
   * Set a key's time to live in milliseconds
   * @param key String key
   * @param millis Time to live in milliseconds
   * @return 
   */
  public Single<Long> rxPexpire(String key, long millis) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pexpire(key, millis, fut);
    }));
  }

  
Set the expiration for a key as a UNIX timestamp specified in milliseconds
Params:
key – Key string
millis – Expiry time as Unix timestamp in milliseconds
handler – Handler for the result of this call.
Returns:
/**
   * Set the expiration for a key as a UNIX timestamp specified in milliseconds
   * @param key Key string
   * @param millis Expiry time as Unix timestamp in milliseconds
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pexpireat(String key, long millis, Handler<AsyncResult<Long>> handler) { 
    delegate.pexpireat(key, millis, handler);
    return this;
  }

    
Set the expiration for a key as a UNIX timestamp specified in milliseconds
Params:
key – Key string
millis – Expiry time as Unix timestamp in milliseconds
Returns:
Deprecated:
use rxPexpireat instead/**
   * Set the expiration for a key as a UNIX timestamp specified in milliseconds
   * @param key Key string
   * @param millis Expiry time as Unix timestamp in milliseconds
   * @return 
   * @deprecated use {@link #rxPexpireat} instead
   */
  @Deprecated()
  public Observable<Long> pexpireatObservable(String key, long millis) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pexpireat(key, millis, handler.toHandler());
    return handler;
  }

  
Set the expiration for a key as a UNIX timestamp specified in milliseconds
Params:
key – Key string
millis – Expiry time as Unix timestamp in milliseconds
Returns:
/**
   * Set the expiration for a key as a UNIX timestamp specified in milliseconds
   * @param key Key string
   * @param millis Expiry time as Unix timestamp in milliseconds
   * @return 
   */
  public Single<Long> rxPexpireat(String key, long millis) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pexpireat(key, millis, fut);
    }));
  }

  
Adds the specified element to the specified HyperLogLog.
Params:
key – Key string
element – Element to add
handler – Handler for the result of this call.
Returns:
/**
   * Adds the specified element to the specified HyperLogLog.
   * @param key Key string
   * @param element Element to add
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pfadd(String key, String element, Handler<AsyncResult<Long>> handler) { 
    delegate.pfadd(key, element, handler);
    return this;
  }

    
Adds the specified element to the specified HyperLogLog.
Params:
key – Key string
element – Element to add
Returns:
Deprecated:
use rxPfadd instead/**
   * Adds the specified element to the specified HyperLogLog.
   * @param key Key string
   * @param element Element to add
   * @return 
   * @deprecated use {@link #rxPfadd} instead
   */
  @Deprecated()
  public Observable<Long> pfaddObservable(String key, String element) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfadd(key, element, handler.toHandler());
    return handler;
  }

  
Adds the specified element to the specified HyperLogLog.
Params:
key – Key string
element – Element to add
Returns:
/**
   * Adds the specified element to the specified HyperLogLog.
   * @param key Key string
   * @param element Element to add
   * @return 
   */
  public Single<Long> rxPfadd(String key, String element) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pfadd(key, element, fut);
    }));
  }

  
Adds the specified elements to the specified HyperLogLog.
Params:
key – Key string
elements – Elementa to add
handler – Handler for the result of this call.
Returns:
/**
   * Adds the specified elements to the specified HyperLogLog.
   * @param key Key string
   * @param elements Elementa to add
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pfaddMany(String key, List<String> elements, Handler<AsyncResult<Long>> handler) { 
    delegate.pfaddMany(key, elements, handler);
    return this;
  }

    
Adds the specified elements to the specified HyperLogLog.
Params:
key – Key string
elements – Elementa to add
Returns:
Deprecated:
use rxPfaddMany instead/**
   * Adds the specified elements to the specified HyperLogLog.
   * @param key Key string
   * @param elements Elementa to add
   * @return 
   * @deprecated use {@link #rxPfaddMany} instead
   */
  @Deprecated()
  public Observable<Long> pfaddManyObservable(String key, List<String> elements) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfaddMany(key, elements, handler.toHandler());
    return handler;
  }

  
Adds the specified elements to the specified HyperLogLog.
Params:
key – Key string
elements – Elementa to add
Returns:
/**
   * Adds the specified elements to the specified HyperLogLog.
   * @param key Key string
   * @param elements Elementa to add
   * @return 
   */
  public Single<Long> rxPfaddMany(String key, List<String> elements) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pfaddMany(key, elements, fut);
    }));
  }

  
Return the approximated cardinality of the set observed by the HyperLogLog at key.
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Return the approximated cardinality of the set observed by the HyperLogLog at key.
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pfcount(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.pfcount(key, handler);
    return this;
  }

    
Return the approximated cardinality of the set observed by the HyperLogLog at key.
Params:
key – Key string
Returns:
Deprecated:
use rxPfcount instead/**
   * Return the approximated cardinality of the set observed by the HyperLogLog at key.
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxPfcount} instead
   */
  @Deprecated()
  public Observable<Long> pfcountObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfcount(key, handler.toHandler());
    return handler;
  }

  
Return the approximated cardinality of the set observed by the HyperLogLog at key.
Params:
key – Key string
Returns:
/**
   * Return the approximated cardinality of the set observed by the HyperLogLog at key.
   * @param key Key string
   * @return 
   */
  public Single<Long> rxPfcount(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pfcount(key, fut);
    }));
  }

  
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
Params:
keys – List of keys
handler – Handler for the result of this call.
Returns:
/**
   * Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
   * @param keys List of keys
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pfcountMany(List<String> keys, Handler<AsyncResult<Long>> handler) { 
    delegate.pfcountMany(keys, handler);
    return this;
  }

    
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
Params:
keys – List of keys
Returns:
Deprecated:
use rxPfcountMany instead/**
   * Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
   * @param keys List of keys
   * @return 
   * @deprecated use {@link #rxPfcountMany} instead
   */
  @Deprecated()
  public Observable<Long> pfcountManyObservable(List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfcountMany(keys, handler.toHandler());
    return handler;
  }

  
Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
Params:
keys – List of keys
Returns:
/**
   * Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
   * @param keys List of keys
   * @return 
   */
  public Single<Long> rxPfcountMany(List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pfcountMany(keys, fut);
    }));
  }

  
Merge N different HyperLogLogs into a single one.
Params:
destkey – Destination key
keys – List of source keys
handler – Handler for the result of this call.
Returns:
/**
   * Merge N different HyperLogLogs into a single one.
   * @param destkey Destination key
   * @param keys List of source keys
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pfmerge(String destkey, List<String> keys, Handler<AsyncResult<String>> handler) { 
    delegate.pfmerge(destkey, keys, handler);
    return this;
  }

    
Merge N different HyperLogLogs into a single one.
Params:
destkey – Destination key
keys – List of source keys
Returns:
Deprecated:
use rxPfmerge instead/**
   * Merge N different HyperLogLogs into a single one.
   * @param destkey Destination key
   * @param keys List of source keys
   * @return 
   * @deprecated use {@link #rxPfmerge} instead
   */
  @Deprecated()
  public Observable<String> pfmergeObservable(String destkey, List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfmerge(destkey, keys, handler.toHandler());
    return handler;
  }

  
Merge N different HyperLogLogs into a single one.
Params:
destkey – Destination key
keys – List of source keys
Returns:
/**
   * Merge N different HyperLogLogs into a single one.
   * @param destkey Destination key
   * @param keys List of source keys
   * @return 
   */
  public Single<String> rxPfmerge(String destkey, List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pfmerge(destkey, keys, fut);
    }));
  }

  
Ping the server
Params:
handler – 
Returns:
/**
   * Ping the server
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient ping(Handler<AsyncResult<String>> handler) { 
    delegate.ping(handler);
    return this;
  }

    
Ping the server
Returns:
Deprecated:
use rxPing instead/**
   * Ping the server
   * @return 
   * @deprecated use {@link #rxPing} instead
   */
  @Deprecated()
  public Observable<String> pingObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    ping(handler.toHandler());
    return handler;
  }

  
Ping the server
Returns:
/**
   * Ping the server
   * @return 
   */
  public Single<String> rxPing() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      ping(fut);
    }));
  }

  
Set the value and expiration in milliseconds of a key
Params:
key – Key string
millis – Number of milliseconds until the key expires
value – New value for key
handler – Handler for the result of this call.
Returns:
/**
   * Set the value and expiration in milliseconds of a key
   * @param key Key string
   * @param millis Number of milliseconds until the key expires
   * @param value New value for key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient psetex(String key, long millis, String value, Handler<AsyncResult<Void>> handler) { 
    delegate.psetex(key, millis, value, handler);
    return this;
  }

    
Set the value and expiration in milliseconds of a key
Params:
key – Key string
millis – Number of milliseconds until the key expires
value – New value for key
Returns:
Deprecated:
use rxPsetex instead/**
   * Set the value and expiration in milliseconds of a key
   * @param key Key string
   * @param millis Number of milliseconds until the key expires
   * @param value New value for key
   * @return 
   * @deprecated use {@link #rxPsetex} instead
   */
  @Deprecated()
  public Observable<Void> psetexObservable(String key, long millis, String value) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    psetex(key, millis, value, handler.toHandler());
    return handler;
  }

  
Set the value and expiration in milliseconds of a key
Params:
key – Key string
millis – Number of milliseconds until the key expires
value – New value for key
Returns:
/**
   * Set the value and expiration in milliseconds of a key
   * @param key Key string
   * @param millis Number of milliseconds until the key expires
   * @param value New value for key
   * @return 
   */
  public Single<Void> rxPsetex(String key, long millis, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      psetex(key, millis, value, fut);
    }));
  }

  
Listen for messages published to channels matching the given pattern
Params:
pattern – Pattern string
handler – Handler for the result of this call.
Returns:
/**
   * Listen for messages published to channels matching the given pattern
   * @param pattern Pattern string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient psubscribe(String pattern, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.psubscribe(pattern, handler);
    return this;
  }

    
Listen for messages published to channels matching the given pattern
Params:
pattern – Pattern string
Returns:
Deprecated:
use rxPsubscribe instead/**
   * Listen for messages published to channels matching the given pattern
   * @param pattern Pattern string
   * @return 
   * @deprecated use {@link #rxPsubscribe} instead
   */
  @Deprecated()
  public Observable<JsonArray> psubscribeObservable(String pattern) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    psubscribe(pattern, handler.toHandler());
    return handler;
  }

  
Listen for messages published to channels matching the given pattern
Params:
pattern – Pattern string
Returns:
/**
   * Listen for messages published to channels matching the given pattern
   * @param pattern Pattern string
   * @return 
   */
  public Single<JsonArray> rxPsubscribe(String pattern) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      psubscribe(pattern, fut);
    }));
  }

  
Listen for messages published to channels matching the given patterns
Params:
patterns – List of patterns
handler – Handler for the result of this call.
Returns:
/**
   * Listen for messages published to channels matching the given patterns
   * @param patterns List of patterns
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient psubscribeMany(List<String> patterns, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.psubscribeMany(patterns, handler);
    return this;
  }

    
Listen for messages published to channels matching the given patterns
Params:
patterns – List of patterns
Returns:
Deprecated:
use rxPsubscribeMany instead/**
   * Listen for messages published to channels matching the given patterns
   * @param patterns List of patterns
   * @return 
   * @deprecated use {@link #rxPsubscribeMany} instead
   */
  @Deprecated()
  public Observable<JsonArray> psubscribeManyObservable(List<String> patterns) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    psubscribeMany(patterns, handler.toHandler());
    return handler;
  }

  
Listen for messages published to channels matching the given patterns
Params:
patterns – List of patterns
Returns:
/**
   * Listen for messages published to channels matching the given patterns
   * @param patterns List of patterns
   * @return 
   */
  public Single<JsonArray> rxPsubscribeMany(List<String> patterns) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      psubscribeMany(patterns, fut);
    }));
  }

  
Lists the currently active channels - only those matching the pattern
Params:
pattern – A glob-style pattern - an empty string means no pattern
handler – Handler for the result of this call.
Returns:
/**
   * Lists the currently active channels - only those matching the pattern
   * @param pattern A glob-style pattern - an empty string means no pattern
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pubsubChannels(String pattern, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.pubsubChannels(pattern, handler);
    return this;
  }

    
Lists the currently active channels - only those matching the pattern
Params:
pattern – A glob-style pattern - an empty string means no pattern
Returns:
Deprecated:
use rxPubsubChannels instead/**
   * Lists the currently active channels - only those matching the pattern
   * @param pattern A glob-style pattern - an empty string means no pattern
   * @return 
   * @deprecated use {@link #rxPubsubChannels} instead
   */
  @Deprecated()
  public Observable<JsonArray> pubsubChannelsObservable(String pattern) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pubsubChannels(pattern, handler.toHandler());
    return handler;
  }

  
Lists the currently active channels - only those matching the pattern
Params:
pattern – A glob-style pattern - an empty string means no pattern
Returns:
/**
   * Lists the currently active channels - only those matching the pattern
   * @param pattern A glob-style pattern - an empty string means no pattern
   * @return 
   */
  public Single<JsonArray> rxPubsubChannels(String pattern) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pubsubChannels(pattern, fut);
    }));
  }

  
Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
Params:
channels – List of channels
handler – Handler for the result of this call.
Returns:
/**
   * Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
   * @param channels List of channels
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pubsubNumsub(List<String> channels, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.pubsubNumsub(channels, handler);
    return this;
  }

    
Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
Params:
channels – List of channels
Returns:
Deprecated:
use rxPubsubNumsub instead/**
   * Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
   * @param channels List of channels
   * @return 
   * @deprecated use {@link #rxPubsubNumsub} instead
   */
  @Deprecated()
  public Observable<JsonArray> pubsubNumsubObservable(List<String> channels) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pubsubNumsub(channels, handler.toHandler());
    return handler;
  }

  
Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
Params:
channels – List of channels
Returns:
/**
   * Returns the number of subscribers (not counting clients subscribed to patterns) for the specified channels
   * @param channels List of channels
   * @return 
   */
  public Single<JsonArray> rxPubsubNumsub(List<String> channels) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pubsubNumsub(channels, fut);
    }));
  }

  
Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
Params:
handler – Handler for the result of this call.
Returns:
/**
   * Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pubsubNumpat(Handler<AsyncResult<Long>> handler) { 
    delegate.pubsubNumpat(handler);
    return this;
  }

    
Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
Returns:
Deprecated:
use rxPubsubNumpat instead/**
   * Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
   * @return 
   * @deprecated use {@link #rxPubsubNumpat} instead
   */
  @Deprecated()
  public Observable<Long> pubsubNumpatObservable() { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pubsubNumpat(handler.toHandler());
    return handler;
  }

  
Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
Returns:
/**
   * Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
   * @return 
   */
  public Single<Long> rxPubsubNumpat() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pubsubNumpat(fut);
    }));
  }

  
Get the time to live for a key in milliseconds
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get the time to live for a key in milliseconds
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pttl(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.pttl(key, handler);
    return this;
  }

    
Get the time to live for a key in milliseconds
Params:
key – Key string
Returns:
Deprecated:
use rxPttl instead/**
   * Get the time to live for a key in milliseconds
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxPttl} instead
   */
  @Deprecated()
  public Observable<Long> pttlObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    pttl(key, handler.toHandler());
    return handler;
  }

  
Get the time to live for a key in milliseconds
Params:
key – Key string
Returns:
/**
   * Get the time to live for a key in milliseconds
   * @param key Key string
   * @return 
   */
  public Single<Long> rxPttl(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pttl(key, fut);
    }));
  }

  
Post a message to a channel
Params:
channel – Channel key
message – Message to send to channel
handler – Handler for the result of this call.
Returns:
/**
   * Post a message to a channel
   * @param channel Channel key
   * @param message Message to send to channel
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient publish(String channel, String message, Handler<AsyncResult<Long>> handler) { 
    delegate.publish(channel, message, handler);
    return this;
  }

    
Post a message to a channel
Params:
channel – Channel key
message – Message to send to channel
Returns:
Deprecated:
use rxPublish instead/**
   * Post a message to a channel
   * @param channel Channel key
   * @param message Message to send to channel
   * @return 
   * @deprecated use {@link #rxPublish} instead
   */
  @Deprecated()
  public Observable<Long> publishObservable(String channel, String message) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    publish(channel, message, handler.toHandler());
    return handler;
  }

  
Post a message to a channel
Params:
channel – Channel key
message – Message to send to channel
Returns:
/**
   * Post a message to a channel
   * @param channel Channel key
   * @param message Message to send to channel
   * @return 
   */
  public Single<Long> rxPublish(String channel, String message) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      publish(channel, message, fut);
    }));
  }

  
Stop listening for messages posted to channels matching the given patterns
Params:
patterns – List of patterns to match against
handler – Handler for the result of this call.
Returns:
/**
   * Stop listening for messages posted to channels matching the given patterns
   * @param patterns List of patterns to match against
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient punsubscribe(List<String> patterns, Handler<AsyncResult<Void>> handler) { 
    delegate.punsubscribe(patterns, handler);
    return this;
  }

    
Stop listening for messages posted to channels matching the given patterns
Params:
patterns – List of patterns to match against
Returns:
Deprecated:
use rxPunsubscribe instead/**
   * Stop listening for messages posted to channels matching the given patterns
   * @param patterns List of patterns to match against
   * @return 
   * @deprecated use {@link #rxPunsubscribe} instead
   */
  @Deprecated()
  public Observable<Void> punsubscribeObservable(List<String> patterns) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    punsubscribe(patterns, handler.toHandler());
    return handler;
  }

  
Stop listening for messages posted to channels matching the given patterns
Params:
patterns – List of patterns to match against
Returns:
/**
   * Stop listening for messages posted to channels matching the given patterns
   * @param patterns List of patterns to match against
   * @return 
   */
  public Single<Void> rxPunsubscribe(List<String> patterns) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      punsubscribe(patterns, fut);
    }));
  }

  
Return a random key from the keyspace
Params:
handler – 
Returns:
/**
   * Return a random key from the keyspace
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient randomkey(Handler<AsyncResult<String>> handler) { 
    delegate.randomkey(handler);
    return this;
  }

    
Return a random key from the keyspace
Returns:
Deprecated:
use rxRandomkey instead/**
   * Return a random key from the keyspace
   * @return 
   * @deprecated use {@link #rxRandomkey} instead
   */
  @Deprecated()
  public Observable<String> randomkeyObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    randomkey(handler.toHandler());
    return handler;
  }

  
Return a random key from the keyspace
Returns:
/**
   * Return a random key from the keyspace
   * @return 
   */
  public Single<String> rxRandomkey() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      randomkey(fut);
    }));
  }

  
Rename a key
Params:
key – Key string to be renamed
newkey – New key string
handler – Handler for the result of this call.
Returns:
/**
   * Rename a key
   * @param key Key string to be renamed
   * @param newkey New key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient rename(String key, String newkey, Handler<AsyncResult<String>> handler) { 
    delegate.rename(key, newkey, handler);
    return this;
  }

    
Rename a key
Params:
key – Key string to be renamed
newkey – New key string
Returns:
Deprecated:
use rxRename instead/**
   * Rename a key
   * @param key Key string to be renamed
   * @param newkey New key string
   * @return 
   * @deprecated use {@link #rxRename} instead
   */
  @Deprecated()
  public Observable<String> renameObservable(String key, String newkey) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    rename(key, newkey, handler.toHandler());
    return handler;
  }

  
Rename a key
Params:
key – Key string to be renamed
newkey – New key string
Returns:
/**
   * Rename a key
   * @param key Key string to be renamed
   * @param newkey New key string
   * @return 
   */
  public Single<String> rxRename(String key, String newkey) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rename(key, newkey, fut);
    }));
  }

  
Rename a key, only if the new key does not exist
Params:
key – Key string to be renamed
newkey – New key string
handler – Handler for the result of this call.
Returns:
/**
   * Rename a key, only if the new key does not exist
   * @param key Key string to be renamed
   * @param newkey New key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient renamenx(String key, String newkey, Handler<AsyncResult<Long>> handler) { 
    delegate.renamenx(key, newkey, handler);
    return this;
  }

    
Rename a key, only if the new key does not exist
Params:
key – Key string to be renamed
newkey – New key string
Returns:
Deprecated:
use rxRenamenx instead/**
   * Rename a key, only if the new key does not exist
   * @param key Key string to be renamed
   * @param newkey New key string
   * @return 
   * @deprecated use {@link #rxRenamenx} instead
   */
  @Deprecated()
  public Observable<Long> renamenxObservable(String key, String newkey) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    renamenx(key, newkey, handler.toHandler());
    return handler;
  }

  
Rename a key, only if the new key does not exist
Params:
key – Key string to be renamed
newkey – New key string
Returns:
/**
   * Rename a key, only if the new key does not exist
   * @param key Key string to be renamed
   * @param newkey New key string
   * @return 
   */
  public Single<Long> rxRenamenx(String key, String newkey) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      renamenx(key, newkey, fut);
    }));
  }

  
Create a key using the provided serialized value, previously obtained using DUMP.
Params:
key – Key string
millis – Expiry time in milliseconds to set on the key
serialized – Serialized form of the key value as obtained using DUMP
handler – Handler for the result of this call.
Returns:
/**
   * Create a key using the provided serialized value, previously obtained using DUMP.
   * @param key Key string
   * @param millis Expiry time in milliseconds to set on the key
   * @param serialized Serialized form of the key value as obtained using DUMP
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient restore(String key, long millis, String serialized, Handler<AsyncResult<String>> handler) { 
    delegate.restore(key, millis, serialized, handler);
    return this;
  }

    
Create a key using the provided serialized value, previously obtained using DUMP.
Params:
key – Key string
millis – Expiry time in milliseconds to set on the key
serialized – Serialized form of the key value as obtained using DUMP
Returns:
Deprecated:
use rxRestore instead/**
   * Create a key using the provided serialized value, previously obtained using DUMP.
   * @param key Key string
   * @param millis Expiry time in milliseconds to set on the key
   * @param serialized Serialized form of the key value as obtained using DUMP
   * @return 
   * @deprecated use {@link #rxRestore} instead
   */
  @Deprecated()
  public Observable<String> restoreObservable(String key, long millis, String serialized) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    restore(key, millis, serialized, handler.toHandler());
    return handler;
  }

  
Create a key using the provided serialized value, previously obtained using DUMP.
Params:
key – Key string
millis – Expiry time in milliseconds to set on the key
serialized – Serialized form of the key value as obtained using DUMP
Returns:
/**
   * Create a key using the provided serialized value, previously obtained using DUMP.
   * @param key Key string
   * @param millis Expiry time in milliseconds to set on the key
   * @param serialized Serialized form of the key value as obtained using DUMP
   * @return 
   */
  public Single<String> rxRestore(String key, long millis, String serialized) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      restore(key, millis, serialized, fut);
    }));
  }

  
Return the role of the instance in the context of replication
Params:
handler – 
Returns:
/**
   * Return the role of the instance in the context of replication
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient role(Handler<AsyncResult<JsonArray>> handler) { 
    delegate.role(handler);
    return this;
  }

    
Return the role of the instance in the context of replication
Returns:
Deprecated:
use rxRole instead/**
   * Return the role of the instance in the context of replication
   * @return 
   * @deprecated use {@link #rxRole} instead
   */
  @Deprecated()
  public Observable<JsonArray> roleObservable() { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    role(handler.toHandler());
    return handler;
  }

  
Return the role of the instance in the context of replication
Returns:
/**
   * Return the role of the instance in the context of replication
   * @return 
   */
  public Single<JsonArray> rxRole() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      role(fut);
    }));
  }

  
Remove and get the last element in a list
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Remove and get the last element in a list
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient rpop(String key, Handler<AsyncResult<String>> handler) { 
    delegate.rpop(key, handler);
    return this;
  }

    
Remove and get the last element in a list
Params:
key – Key string
Returns:
Deprecated:
use rxRpop instead/**
   * Remove and get the last element in a list
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxRpop} instead
   */
  @Deprecated()
  public Observable<String> rpopObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    rpop(key, handler.toHandler());
    return handler;
  }

  
Remove and get the last element in a list
Params:
key – Key string
Returns:
/**
   * Remove and get the last element in a list
   * @param key Key string
   * @return 
   */
  public Single<String> rxRpop(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rpop(key, fut);
    }));
  }

  
Remove the last element in a list, append it to another list and return it
Params:
key – Key string identifying source list
destkey – Key string identifying destination list
handler – Handler for the result of this call.
Returns:
/**
   * Remove the last element in a list, append it to another list and return it
   * @param key Key string identifying source list
   * @param destkey Key string identifying destination list
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient rpoplpush(String key, String destkey, Handler<AsyncResult<String>> handler) { 
    delegate.rpoplpush(key, destkey, handler);
    return this;
  }

    
Remove the last element in a list, append it to another list and return it
Params:
key – Key string identifying source list
destkey – Key string identifying destination list
Returns:
Deprecated:
use rxRpoplpush instead/**
   * Remove the last element in a list, append it to another list and return it
   * @param key Key string identifying source list
   * @param destkey Key string identifying destination list
   * @return 
   * @deprecated use {@link #rxRpoplpush} instead
   */
  @Deprecated()
  public Observable<String> rpoplpushObservable(String key, String destkey) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    rpoplpush(key, destkey, handler.toHandler());
    return handler;
  }

  
Remove the last element in a list, append it to another list and return it
Params:
key – Key string identifying source list
destkey – Key string identifying destination list
Returns:
/**
   * Remove the last element in a list, append it to another list and return it
   * @param key Key string identifying source list
   * @param destkey Key string identifying destination list
   * @return 
   */
  public Single<String> rxRpoplpush(String key, String destkey) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rpoplpush(key, destkey, fut);
    }));
  }

  
Append one or multiple values to a list
Params:
key – Key string
values – List of values to add to the end of the list
handler – Handler for the result of this call.
Returns:
/**
   * Append one or multiple values to a list
   * @param key Key string
   * @param values List of values to add to the end of the list
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient rpushMany(String key, List<String> values, Handler<AsyncResult<Long>> handler) { 
    delegate.rpushMany(key, values, handler);
    return this;
  }

    
Append one or multiple values to a list
Params:
key – Key string
values – List of values to add to the end of the list
Returns:
Deprecated:
use rxRpushMany instead/**
   * Append one or multiple values to a list
   * @param key Key string
   * @param values List of values to add to the end of the list
   * @return 
   * @deprecated use {@link #rxRpushMany} instead
   */
  @Deprecated()
  public Observable<Long> rpushManyObservable(String key, List<String> values) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    rpushMany(key, values, handler.toHandler());
    return handler;
  }

  
Append one or multiple values to a list
Params:
key – Key string
values – List of values to add to the end of the list
Returns:
/**
   * Append one or multiple values to a list
   * @param key Key string
   * @param values List of values to add to the end of the list
   * @return 
   */
  public Single<Long> rxRpushMany(String key, List<String> values) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rpushMany(key, values, fut);
    }));
  }

  
Append one or multiple values to a list
Params:
key – Key string
value – Value to be added to the end of the list
handler – Handler for the result of this call.
Returns:
/**
   * Append one or multiple values to a list
   * @param key Key string
   * @param value Value to be added to the end of the list
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient rpush(String key, String value, Handler<AsyncResult<Long>> handler) { 
    delegate.rpush(key, value, handler);
    return this;
  }

    
Append one or multiple values to a list
Params:
key – Key string
value – Value to be added to the end of the list
Returns:
Deprecated:
use rxRpush instead/**
   * Append one or multiple values to a list
   * @param key Key string
   * @param value Value to be added to the end of the list
   * @return 
   * @deprecated use {@link #rxRpush} instead
   */
  @Deprecated()
  public Observable<Long> rpushObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    rpush(key, value, handler.toHandler());
    return handler;
  }

  
Append one or multiple values to a list
Params:
key – Key string
value – Value to be added to the end of the list
Returns:
/**
   * Append one or multiple values to a list
   * @param key Key string
   * @param value Value to be added to the end of the list
   * @return 
   */
  public Single<Long> rxRpush(String key, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rpush(key, value, fut);
    }));
  }

  
Append a value to a list, only if the list exists
Params:
key – Key string
value – Value to be added to the end of the list
handler – Handler for the result of this call.
Returns:
/**
   * Append a value to a list, only if the list exists
   * @param key Key string
   * @param value Value to be added to the end of the list
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient rpushx(String key, String value, Handler<AsyncResult<Long>> handler) { 
    delegate.rpushx(key, value, handler);
    return this;
  }

    
Append a value to a list, only if the list exists
Params:
key – Key string
value – Value to be added to the end of the list
Returns:
Deprecated:
use rxRpushx instead/**
   * Append a value to a list, only if the list exists
   * @param key Key string
   * @param value Value to be added to the end of the list
   * @return 
   * @deprecated use {@link #rxRpushx} instead
   */
  @Deprecated()
  public Observable<Long> rpushxObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    rpushx(key, value, handler.toHandler());
    return handler;
  }

  
Append a value to a list, only if the list exists
Params:
key – Key string
value – Value to be added to the end of the list
Returns:
/**
   * Append a value to a list, only if the list exists
   * @param key Key string
   * @param value Value to be added to the end of the list
   * @return 
   */
  public Single<Long> rxRpushx(String key, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rpushx(key, value, fut);
    }));
  }

  
Add a member to a set
Params:
key – Key string
member – Value to be added to the set
handler – Handler for the result of this call.
Returns:
/**
   * Add a member to a set
   * @param key Key string
   * @param member Value to be added to the set
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sadd(String key, String member, Handler<AsyncResult<Long>> handler) { 
    delegate.sadd(key, member, handler);
    return this;
  }

    
Add a member to a set
Params:
key – Key string
member – Value to be added to the set
Returns:
Deprecated:
use rxSadd instead/**
   * Add a member to a set
   * @param key Key string
   * @param member Value to be added to the set
   * @return 
   * @deprecated use {@link #rxSadd} instead
   */
  @Deprecated()
  public Observable<Long> saddObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sadd(key, member, handler.toHandler());
    return handler;
  }

  
Add a member to a set
Params:
key – Key string
member – Value to be added to the set
Returns:
/**
   * Add a member to a set
   * @param key Key string
   * @param member Value to be added to the set
   * @return 
   */
  public Single<Long> rxSadd(String key, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sadd(key, member, fut);
    }));
  }

  
Add one or more members to a set
Params:
key – Key string
members – Values to be added to the set
handler – Handler for the result of this call.
Returns:
/**
   * Add one or more members to a set
   * @param key Key string
   * @param members Values to be added to the set
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient saddMany(String key, List<String> members, Handler<AsyncResult<Long>> handler) { 
    delegate.saddMany(key, members, handler);
    return this;
  }

    
Add one or more members to a set
Params:
key – Key string
members – Values to be added to the set
Returns:
Deprecated:
use rxSaddMany instead/**
   * Add one or more members to a set
   * @param key Key string
   * @param members Values to be added to the set
   * @return 
   * @deprecated use {@link #rxSaddMany} instead
   */
  @Deprecated()
  public Observable<Long> saddManyObservable(String key, List<String> members) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    saddMany(key, members, handler.toHandler());
    return handler;
  }

  
Add one or more members to a set
Params:
key – Key string
members – Values to be added to the set
Returns:
/**
   * Add one or more members to a set
   * @param key Key string
   * @param members Values to be added to the set
   * @return 
   */
  public Single<Long> rxSaddMany(String key, List<String> members) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      saddMany(key, members, fut);
    }));
  }

  
Synchronously save the dataset to disk
Params:
handler – 
Returns:
/**
   * Synchronously save the dataset to disk
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient save(Handler<AsyncResult<String>> handler) { 
    delegate.save(handler);
    return this;
  }

    
Synchronously save the dataset to disk
Returns:
Deprecated:
use rxSave instead/**
   * Synchronously save the dataset to disk
   * @return 
   * @deprecated use {@link #rxSave} instead
   */
  @Deprecated()
  public Observable<String> saveObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    save(handler.toHandler());
    return handler;
  }

  
Synchronously save the dataset to disk
Returns:
/**
   * Synchronously save the dataset to disk
   * @return 
   */
  public Single<String> rxSave() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      save(fut);
    }));
  }

  
Get the number of members in a set
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get the number of members in a set
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient scard(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.scard(key, handler);
    return this;
  }

    
Get the number of members in a set
Params:
key – Key string
Returns:
Deprecated:
use rxScard instead/**
   * Get the number of members in a set
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxScard} instead
   */
  @Deprecated()
  public Observable<Long> scardObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    scard(key, handler.toHandler());
    return handler;
  }

  
Get the number of members in a set
Params:
key – Key string
Returns:
/**
   * Get the number of members in a set
   * @param key Key string
   * @return 
   */
  public Single<Long> rxScard(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      scard(key, fut);
    }));
  }

  
Check existence of script in the script cache.
Params:
script – SHA1 digest identifying a script in the script cache
handler – Handler for the result of this call.
Returns:
/**
   * Check existence of script in the script cache.
   * @param script SHA1 digest identifying a script in the script cache
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient scriptExists(String script, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.scriptExists(script, handler);
    return this;
  }

    
Check existence of script in the script cache.
Params:
script – SHA1 digest identifying a script in the script cache
Returns:
Deprecated:
use rxScriptExists instead/**
   * Check existence of script in the script cache.
   * @param script SHA1 digest identifying a script in the script cache
   * @return 
   * @deprecated use {@link #rxScriptExists} instead
   */
  @Deprecated()
  public Observable<JsonArray> scriptExistsObservable(String script) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    scriptExists(script, handler.toHandler());
    return handler;
  }

  
Check existence of script in the script cache.
Params:
script – SHA1 digest identifying a script in the script cache
Returns:
/**
   * Check existence of script in the script cache.
   * @param script SHA1 digest identifying a script in the script cache
   * @return 
   */
  public Single<JsonArray> rxScriptExists(String script) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      scriptExists(script, fut);
    }));
  }

  
Check existence of scripts in the script cache.
Params:
scripts – List of SHA1 digests identifying scripts in the script cache
handler – Handler for the result of this call.
Returns:
/**
   * Check existence of scripts in the script cache.
   * @param scripts List of SHA1 digests identifying scripts in the script cache
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient scriptExistsMany(List<String> scripts, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.scriptExistsMany(scripts, handler);
    return this;
  }

    
Check existence of scripts in the script cache.
Params:
scripts – List of SHA1 digests identifying scripts in the script cache
Returns:
Deprecated:
use rxScriptExistsMany instead/**
   * Check existence of scripts in the script cache.
   * @param scripts List of SHA1 digests identifying scripts in the script cache
   * @return 
   * @deprecated use {@link #rxScriptExistsMany} instead
   */
  @Deprecated()
  public Observable<JsonArray> scriptExistsManyObservable(List<String> scripts) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    scriptExistsMany(scripts, handler.toHandler());
    return handler;
  }

  
Check existence of scripts in the script cache.
Params:
scripts – List of SHA1 digests identifying scripts in the script cache
Returns:
/**
   * Check existence of scripts in the script cache.
   * @param scripts List of SHA1 digests identifying scripts in the script cache
   * @return 
   */
  public Single<JsonArray> rxScriptExistsMany(List<String> scripts) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      scriptExistsMany(scripts, fut);
    }));
  }

  
Remove all the scripts from the script cache.
Params:
handler – 
Returns:
/**
   * Remove all the scripts from the script cache.
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient scriptFlush(Handler<AsyncResult<String>> handler) { 
    delegate.scriptFlush(handler);
    return this;
  }

    
Remove all the scripts from the script cache.
Returns:
Deprecated:
use rxScriptFlush instead/**
   * Remove all the scripts from the script cache.
   * @return 
   * @deprecated use {@link #rxScriptFlush} instead
   */
  @Deprecated()
  public Observable<String> scriptFlushObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    scriptFlush(handler.toHandler());
    return handler;
  }

  
Remove all the scripts from the script cache.
Returns:
/**
   * Remove all the scripts from the script cache.
   * @return 
   */
  public Single<String> rxScriptFlush() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      scriptFlush(fut);
    }));
  }

  
Kill the script currently in execution.
Params:
handler – 
Returns:
/**
   * Kill the script currently in execution.
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient scriptKill(Handler<AsyncResult<String>> handler) { 
    delegate.scriptKill(handler);
    return this;
  }

    
Kill the script currently in execution.
Returns:
Deprecated:
use rxScriptKill instead/**
   * Kill the script currently in execution.
   * @return 
   * @deprecated use {@link #rxScriptKill} instead
   */
  @Deprecated()
  public Observable<String> scriptKillObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    scriptKill(handler.toHandler());
    return handler;
  }

  
Kill the script currently in execution.
Returns:
/**
   * Kill the script currently in execution.
   * @return 
   */
  public Single<String> rxScriptKill() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      scriptKill(fut);
    }));
  }

  
Load the specified Lua script into the script cache.
Params:
script – Lua script
handler – Handler for the result of this call.
Returns:
/**
   * Load the specified Lua script into the script cache.
   * @param script Lua script
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient scriptLoad(String script, Handler<AsyncResult<String>> handler) { 
    delegate.scriptLoad(script, handler);
    return this;
  }

    
Load the specified Lua script into the script cache.
Params:
script – Lua script
Returns:
Deprecated:
use rxScriptLoad instead/**
   * Load the specified Lua script into the script cache.
   * @param script Lua script
   * @return 
   * @deprecated use {@link #rxScriptLoad} instead
   */
  @Deprecated()
  public Observable<String> scriptLoadObservable(String script) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    scriptLoad(script, handler.toHandler());
    return handler;
  }

  
Load the specified Lua script into the script cache.
Params:
script – Lua script
Returns:
/**
   * Load the specified Lua script into the script cache.
   * @param script Lua script
   * @return 
   */
  public Single<String> rxScriptLoad(String script) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      scriptLoad(script, fut);
    }));
  }

  
Subtract multiple sets
Params:
key – Key identifying the set to compare with all other sets combined
cmpkeys – List of keys identifying sets to subtract from the key set
handler – Handler for the result of this call.
Returns:
/**
   * Subtract multiple sets
   * @param key Key identifying the set to compare with all other sets combined
   * @param cmpkeys List of keys identifying sets to subtract from the key set
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sdiff(String key, List<String> cmpkeys, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.sdiff(key, cmpkeys, handler);
    return this;
  }

    
Subtract multiple sets
Params:
key – Key identifying the set to compare with all other sets combined
cmpkeys – List of keys identifying sets to subtract from the key set
Returns:
Deprecated:
use rxSdiff instead/**
   * Subtract multiple sets
   * @param key Key identifying the set to compare with all other sets combined
   * @param cmpkeys List of keys identifying sets to subtract from the key set
   * @return 
   * @deprecated use {@link #rxSdiff} instead
   */
  @Deprecated()
  public Observable<JsonArray> sdiffObservable(String key, List<String> cmpkeys) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sdiff(key, cmpkeys, handler.toHandler());
    return handler;
  }

  
Subtract multiple sets
Params:
key – Key identifying the set to compare with all other sets combined
cmpkeys – List of keys identifying sets to subtract from the key set
Returns:
/**
   * Subtract multiple sets
   * @param key Key identifying the set to compare with all other sets combined
   * @param cmpkeys List of keys identifying sets to subtract from the key set
   * @return 
   */
  public Single<JsonArray> rxSdiff(String key, List<String> cmpkeys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sdiff(key, cmpkeys, fut);
    }));
  }

  
Subtract multiple sets and store the resulting set in a key
Params:
destkey – Destination key where the result should be stored
key – Key identifying the set to compare with all other sets combined
cmpkeys – List of keys identifying sets to subtract from the key set
handler – Handler for the result of this call.
Returns:
/**
   * Subtract multiple sets and store the resulting set in a key
   * @param destkey Destination key where the result should be stored
   * @param key Key identifying the set to compare with all other sets combined
   * @param cmpkeys List of keys identifying sets to subtract from the key set
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sdiffstore(String destkey, String key, List<String> cmpkeys, Handler<AsyncResult<Long>> handler) { 
    delegate.sdiffstore(destkey, key, cmpkeys, handler);
    return this;
  }

    
Subtract multiple sets and store the resulting set in a key
Params:
destkey – Destination key where the result should be stored
key – Key identifying the set to compare with all other sets combined
cmpkeys – List of keys identifying sets to subtract from the key set
Returns:
Deprecated:
use rxSdiffstore instead/**
   * Subtract multiple sets and store the resulting set in a key
   * @param destkey Destination key where the result should be stored
   * @param key Key identifying the set to compare with all other sets combined
   * @param cmpkeys List of keys identifying sets to subtract from the key set
   * @return 
   * @deprecated use {@link #rxSdiffstore} instead
   */
  @Deprecated()
  public Observable<Long> sdiffstoreObservable(String destkey, String key, List<String> cmpkeys) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sdiffstore(destkey, key, cmpkeys, handler.toHandler());
    return handler;
  }

  
Subtract multiple sets and store the resulting set in a key
Params:
destkey – Destination key where the result should be stored
key – Key identifying the set to compare with all other sets combined
cmpkeys – List of keys identifying sets to subtract from the key set
Returns:
/**
   * Subtract multiple sets and store the resulting set in a key
   * @param destkey Destination key where the result should be stored
   * @param key Key identifying the set to compare with all other sets combined
   * @param cmpkeys List of keys identifying sets to subtract from the key set
   * @return 
   */
  public Single<Long> rxSdiffstore(String destkey, String key, List<String> cmpkeys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sdiffstore(destkey, key, cmpkeys, fut);
    }));
  }

  
Change the selected database for the current connection
Params:
dbindex – Index identifying the new active database
handler – Handler for the result of this call.
Returns:
/**
   * Change the selected database for the current connection
   * @param dbindex Index identifying the new active database
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient select(int dbindex, Handler<AsyncResult<String>> handler) { 
    delegate.select(dbindex, handler);
    return this;
  }

    
Change the selected database for the current connection
Params:
dbindex – Index identifying the new active database
Returns:
Deprecated:
use rxSelect instead/**
   * Change the selected database for the current connection
   * @param dbindex Index identifying the new active database
   * @return 
   * @deprecated use {@link #rxSelect} instead
   */
  @Deprecated()
  public Observable<String> selectObservable(int dbindex) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    select(dbindex, handler.toHandler());
    return handler;
  }

  
Change the selected database for the current connection
Params:
dbindex – Index identifying the new active database
Returns:
/**
   * Change the selected database for the current connection
   * @param dbindex Index identifying the new active database
   * @return 
   */
  public Single<String> rxSelect(int dbindex) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      select(dbindex, fut);
    }));
  }

  
Set the string value of a key
Params:
key – Key of which value to set
value – New value for the key
handler – Handler for the result of this call.
Returns:
/**
   * Set the string value of a key
   * @param key Key of which value to set
   * @param value New value for the key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient set(String key, String value, Handler<AsyncResult<Void>> handler) { 
    delegate.set(key, value, handler);
    return this;
  }

    
Set the string value of a key
Params:
key – Key of which value to set
value – New value for the key
Returns:
Deprecated:
use rxSet instead/**
   * Set the string value of a key
   * @param key Key of which value to set
   * @param value New value for the key
   * @return 
   * @deprecated use {@link #rxSet} instead
   */
  @Deprecated()
  public Observable<Void> setObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    set(key, value, handler.toHandler());
    return handler;
  }

  
Set the string value of a key
Params:
key – Key of which value to set
value – New value for the key
Returns:
/**
   * Set the string value of a key
   * @param key Key of which value to set
   * @param value New value for the key
   * @return 
   */
  public Single<Void> rxSet(String key, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      set(key, value, fut);
    }));
  }

  
Set the string value of a key
Params:
key – Key of which value to set
value – New value for the key
options – Set options
handler – Handler for the result of this call.
Returns:
/**
   * Set the string value of a key
   * @param key Key of which value to set
   * @param value New value for the key
   * @param options Set options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient setWithOptions(String key, String value, SetOptions options, Handler<AsyncResult<String>> handler) { 
    delegate.setWithOptions(key, value, options, handler);
    return this;
  }

    
Set the string value of a key
Params:
key – Key of which value to set
value – New value for the key
options – Set options
Returns:
Deprecated:
use rxSetWithOptions instead/**
   * Set the string value of a key
   * @param key Key of which value to set
   * @param value New value for the key
   * @param options Set options
   * @return 
   * @deprecated use {@link #rxSetWithOptions} instead
   */
  @Deprecated()
  public Observable<String> setWithOptionsObservable(String key, String value, SetOptions options) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    setWithOptions(key, value, options, handler.toHandler());
    return handler;
  }

  
Set the string value of a key
Params:
key – Key of which value to set
value – New value for the key
options – Set options
Returns:
/**
   * Set the string value of a key
   * @param key Key of which value to set
   * @param value New value for the key
   * @param options Set options
   * @return 
   */
  public Single<String> rxSetWithOptions(String key, String value, SetOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      setWithOptions(key, value, options, fut);
    }));
  }

  
Set the binary string value of a key - without encoding as utf-8
Params:
key – Key of which value to set
value – New value for the key
handler – Handler for the result of this call.
Returns:
/**
   * Set the binary string value of a key - without encoding as utf-8
   * @param key Key of which value to set
   * @param value New value for the key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient setBinary(String key, io.vertx.rxjava.core.buffer.Buffer value, Handler<AsyncResult<Void>> handler) { 
    delegate.setBinary(key, value.getDelegate(), handler);
    return this;
  }

    
Set the binary string value of a key - without encoding as utf-8
Params:
key – Key of which value to set
value – New value for the key
Returns:
Deprecated:
use rxSetBinary instead/**
   * Set the binary string value of a key - without encoding as utf-8
   * @param key Key of which value to set
   * @param value New value for the key
   * @return 
   * @deprecated use {@link #rxSetBinary} instead
   */
  @Deprecated()
  public Observable<Void> setBinaryObservable(String key, io.vertx.rxjava.core.buffer.Buffer value) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    setBinary(key, value, handler.toHandler());
    return handler;
  }

  
Set the binary string value of a key - without encoding as utf-8
Params:
key – Key of which value to set
value – New value for the key
Returns:
/**
   * Set the binary string value of a key - without encoding as utf-8
   * @param key Key of which value to set
   * @param value New value for the key
   * @return 
   */
  public Single<Void> rxSetBinary(String key, io.vertx.rxjava.core.buffer.Buffer value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      setBinary(key, value, fut);
    }));
  }

  
Set the string value of a key
Params:
key – Key of which value to set
value – New value for the key
options – Set options
handler – Handler for the result of this call.
Returns:
/**
   * Set the string value of a key
   * @param key Key of which value to set
   * @param value New value for the key
   * @param options Set options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient setBinaryWithOptions(String key, io.vertx.rxjava.core.buffer.Buffer value, SetOptions options, Handler<AsyncResult<Void>> handler) { 
    delegate.setBinaryWithOptions(key, value.getDelegate(), options, handler);
    return this;
  }

    
Set the string value of a key
Params:
key – Key of which value to set
value – New value for the key
options – Set options
Returns:
Deprecated:
use rxSetBinaryWithOptions instead/**
   * Set the string value of a key
   * @param key Key of which value to set
   * @param value New value for the key
   * @param options Set options
   * @return 
   * @deprecated use {@link #rxSetBinaryWithOptions} instead
   */
  @Deprecated()
  public Observable<Void> setBinaryWithOptionsObservable(String key, io.vertx.rxjava.core.buffer.Buffer value, SetOptions options) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    setBinaryWithOptions(key, value, options, handler.toHandler());
    return handler;
  }

  
Set the string value of a key
Params:
key – Key of which value to set
value – New value for the key
options – Set options
Returns:
/**
   * Set the string value of a key
   * @param key Key of which value to set
   * @param value New value for the key
   * @param options Set options
   * @return 
   */
  public Single<Void> rxSetBinaryWithOptions(String key, io.vertx.rxjava.core.buffer.Buffer value, SetOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      setBinaryWithOptions(key, value, options, fut);
    }));
  }

  
Sets or clears the bit at offset in the string value stored at key
Params:
key – Key string
offset – Bit offset
bit – New value - must be 1 or 0
handler – Handler for the result of this call.
Returns:
/**
   * Sets or clears the bit at offset in the string value stored at key
   * @param key Key string
   * @param offset Bit offset
   * @param bit New value - must be 1 or 0
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient setbit(String key, long offset, int bit, Handler<AsyncResult<Long>> handler) { 
    delegate.setbit(key, offset, bit, handler);
    return this;
  }

    
Sets or clears the bit at offset in the string value stored at key
Params:
key – Key string
offset – Bit offset
bit – New value - must be 1 or 0
Returns:
Deprecated:
use rxSetbit instead/**
   * Sets or clears the bit at offset in the string value stored at key
   * @param key Key string
   * @param offset Bit offset
   * @param bit New value - must be 1 or 0
   * @return 
   * @deprecated use {@link #rxSetbit} instead
   */
  @Deprecated()
  public Observable<Long> setbitObservable(String key, long offset, int bit) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    setbit(key, offset, bit, handler.toHandler());
    return handler;
  }

  
Sets or clears the bit at offset in the string value stored at key
Params:
key – Key string
offset – Bit offset
bit – New value - must be 1 or 0
Returns:
/**
   * Sets or clears the bit at offset in the string value stored at key
   * @param key Key string
   * @param offset Bit offset
   * @param bit New value - must be 1 or 0
   * @return 
   */
  public Single<Long> rxSetbit(String key, long offset, int bit) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      setbit(key, offset, bit, fut);
    }));
  }

  
Set the value and expiration of a key
Params:
key – Key string
seconds – Number of seconds until the key expires
value – New value for key
handler – Handler for the result of this call.
Returns:
/**
   * Set the value and expiration of a key
   * @param key Key string
   * @param seconds Number of seconds until the key expires
   * @param value New value for key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient setex(String key, long seconds, String value, Handler<AsyncResult<String>> handler) { 
    delegate.setex(key, seconds, value, handler);
    return this;
  }

    
Set the value and expiration of a key
Params:
key – Key string
seconds – Number of seconds until the key expires
value – New value for key
Returns:
Deprecated:
use rxSetex instead/**
   * Set the value and expiration of a key
   * @param key Key string
   * @param seconds Number of seconds until the key expires
   * @param value New value for key
   * @return 
   * @deprecated use {@link #rxSetex} instead
   */
  @Deprecated()
  public Observable<String> setexObservable(String key, long seconds, String value) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    setex(key, seconds, value, handler.toHandler());
    return handler;
  }

  
Set the value and expiration of a key
Params:
key – Key string
seconds – Number of seconds until the key expires
value – New value for key
Returns:
/**
   * Set the value and expiration of a key
   * @param key Key string
   * @param seconds Number of seconds until the key expires
   * @param value New value for key
   * @return 
   */
  public Single<String> rxSetex(String key, long seconds, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      setex(key, seconds, value, fut);
    }));
  }

  
Set the value of a key, only if the key does not exist
Params:
key – Key of which value to set
value – New value for the key
handler – Handler for the result of this call.
Returns:
/**
   * Set the value of a key, only if the key does not exist
   * @param key Key of which value to set
   * @param value New value for the key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient setnx(String key, String value, Handler<AsyncResult<Long>> handler) { 
    delegate.setnx(key, value, handler);
    return this;
  }

    
Set the value of a key, only if the key does not exist
Params:
key – Key of which value to set
value – New value for the key
Returns:
Deprecated:
use rxSetnx instead/**
   * Set the value of a key, only if the key does not exist
   * @param key Key of which value to set
   * @param value New value for the key
   * @return 
   * @deprecated use {@link #rxSetnx} instead
   */
  @Deprecated()
  public Observable<Long> setnxObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    setnx(key, value, handler.toHandler());
    return handler;
  }

  
Set the value of a key, only if the key does not exist
Params:
key – Key of which value to set
value – New value for the key
Returns:
/**
   * Set the value of a key, only if the key does not exist
   * @param key Key of which value to set
   * @param value New value for the key
   * @return 
   */
  public Single<Long> rxSetnx(String key, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      setnx(key, value, fut);
    }));
  }

  
Overwrite part of a string at key starting at the specified offset
Params:
key – Key string
offset – Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
value – Value to overwrite with
handler – Handler for the result of this call.
Returns:
/**
   * Overwrite part of a string at key starting at the specified offset
   * @param key Key string
   * @param offset Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
   * @param value Value to overwrite with
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient setrange(String key, int offset, String value, Handler<AsyncResult<Long>> handler) { 
    delegate.setrange(key, offset, value, handler);
    return this;
  }

    
Overwrite part of a string at key starting at the specified offset
Params:
key – Key string
offset – Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
value – Value to overwrite with
Returns:
Deprecated:
use rxSetrange instead/**
   * Overwrite part of a string at key starting at the specified offset
   * @param key Key string
   * @param offset Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
   * @param value Value to overwrite with
   * @return 
   * @deprecated use {@link #rxSetrange} instead
   */
  @Deprecated()
  public Observable<Long> setrangeObservable(String key, int offset, String value) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    setrange(key, offset, value, handler.toHandler());
    return handler;
  }

  
Overwrite part of a string at key starting at the specified offset
Params:
key – Key string
offset – Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
value – Value to overwrite with
Returns:
/**
   * Overwrite part of a string at key starting at the specified offset
   * @param key Key string
   * @param offset Offset - the maximum offset that you can set is 2^29 -1 (536870911), as Redis Strings are limited to 512 megabytes
   * @param value Value to overwrite with
   * @return 
   */
  public Single<Long> rxSetrange(String key, int offset, String value) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      setrange(key, offset, value, fut);
    }));
  }

  
Intersect multiple sets
Params:
keys – List of keys to perform intersection on
handler – Handler for the result of this call.
Returns:
/**
   * Intersect multiple sets
   * @param keys List of keys to perform intersection on
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sinter(List<String> keys, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.sinter(keys, handler);
    return this;
  }

    
Intersect multiple sets
Params:
keys – List of keys to perform intersection on
Returns:
Deprecated:
use rxSinter instead/**
   * Intersect multiple sets
   * @param keys List of keys to perform intersection on
   * @return 
   * @deprecated use {@link #rxSinter} instead
   */
  @Deprecated()
  public Observable<JsonArray> sinterObservable(List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sinter(keys, handler.toHandler());
    return handler;
  }

  
Intersect multiple sets
Params:
keys – List of keys to perform intersection on
Returns:
/**
   * Intersect multiple sets
   * @param keys List of keys to perform intersection on
   * @return 
   */
  public Single<JsonArray> rxSinter(List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sinter(keys, fut);
    }));
  }

  
Intersect multiple sets and store the resulting set in a key
Params:
destkey – Key where to store the results
keys – List of keys to perform intersection on
handler – Handler for the result of this call.
Returns:
/**
   * Intersect multiple sets and store the resulting set in a key
   * @param destkey Key where to store the results
   * @param keys List of keys to perform intersection on
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sinterstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler) { 
    delegate.sinterstore(destkey, keys, handler);
    return this;
  }

    
Intersect multiple sets and store the resulting set in a key
Params:
destkey – Key where to store the results
keys – List of keys to perform intersection on
Returns:
Deprecated:
use rxSinterstore instead/**
   * Intersect multiple sets and store the resulting set in a key
   * @param destkey Key where to store the results
   * @param keys List of keys to perform intersection on
   * @return 
   * @deprecated use {@link #rxSinterstore} instead
   */
  @Deprecated()
  public Observable<Long> sinterstoreObservable(String destkey, List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sinterstore(destkey, keys, handler.toHandler());
    return handler;
  }

  
Intersect multiple sets and store the resulting set in a key
Params:
destkey – Key where to store the results
keys – List of keys to perform intersection on
Returns:
/**
   * Intersect multiple sets and store the resulting set in a key
   * @param destkey Key where to store the results
   * @param keys List of keys to perform intersection on
   * @return 
   */
  public Single<Long> rxSinterstore(String destkey, List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sinterstore(destkey, keys, fut);
    }));
  }

  
Determine if a given value is a member of a set
Params:
key – Key string
member – Member to look for
handler – Handler for the result of this call.
Returns:
/**
   * Determine if a given value is a member of a set
   * @param key Key string
   * @param member Member to look for
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sismember(String key, String member, Handler<AsyncResult<Long>> handler) { 
    delegate.sismember(key, member, handler);
    return this;
  }

    
Determine if a given value is a member of a set
Params:
key – Key string
member – Member to look for
Returns:
Deprecated:
use rxSismember instead/**
   * Determine if a given value is a member of a set
   * @param key Key string
   * @param member Member to look for
   * @return 
   * @deprecated use {@link #rxSismember} instead
   */
  @Deprecated()
  public Observable<Long> sismemberObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sismember(key, member, handler.toHandler());
    return handler;
  }

  
Determine if a given value is a member of a set
Params:
key – Key string
member – Member to look for
Returns:
/**
   * Determine if a given value is a member of a set
   * @param key Key string
   * @param member Member to look for
   * @return 
   */
  public Single<Long> rxSismember(String key, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sismember(key, member, fut);
    }));
  }

  
Make the server a slave of another instance
Params:
host – Host to become this server's master
port – Port of our new master
handler – Handler for the result of this call.
Returns:
/**
   * Make the server a slave of another instance
   * @param host Host to become this server's master
   * @param port Port of our new master
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient slaveof(String host, int port, Handler<AsyncResult<String>> handler) { 
    delegate.slaveof(host, port, handler);
    return this;
  }

    
Make the server a slave of another instance
Params:
host – Host to become this server's master
port – Port of our new master
Returns:
Deprecated:
use rxSlaveof instead/**
   * Make the server a slave of another instance
   * @param host Host to become this server's master
   * @param port Port of our new master
   * @return 
   * @deprecated use {@link #rxSlaveof} instead
   */
  @Deprecated()
  public Observable<String> slaveofObservable(String host, int port) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    slaveof(host, port, handler.toHandler());
    return handler;
  }

  
Make the server a slave of another instance
Params:
host – Host to become this server's master
port – Port of our new master
Returns:
/**
   * Make the server a slave of another instance
   * @param host Host to become this server's master
   * @param port Port of our new master
   * @return 
   */
  public Single<String> rxSlaveof(String host, int port) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      slaveof(host, port, fut);
    }));
  }

  
Make this server a master
Params:
handler – Handler for the result of this call.
Returns:
/**
   * Make this server a master
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient slaveofNoone(Handler<AsyncResult<String>> handler) { 
    delegate.slaveofNoone(handler);
    return this;
  }

    
Make this server a master
Returns:
Deprecated:
use rxSlaveofNoone instead/**
   * Make this server a master
   * @return 
   * @deprecated use {@link #rxSlaveofNoone} instead
   */
  @Deprecated()
  public Observable<String> slaveofNooneObservable() { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    slaveofNoone(handler.toHandler());
    return handler;
  }

  
Make this server a master
Returns:
/**
   * Make this server a master
   * @return 
   */
  public Single<String> rxSlaveofNoone() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      slaveofNoone(fut);
    }));
  }

  
Read the Redis slow queries log
Params:
limit – Number of log entries to return. If value is less than zero all entries are returned
handler – Handler for the result of this call.
Returns:
/**
   * Read the Redis slow queries log
   * @param limit Number of log entries to return. If value is less than zero all entries are returned
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient slowlogGet(int limit, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.slowlogGet(limit, handler);
    return this;
  }

    
Read the Redis slow queries log
Params:
limit – Number of log entries to return. If value is less than zero all entries are returned
Returns:
Deprecated:
use rxSlowlogGet instead/**
   * Read the Redis slow queries log
   * @param limit Number of log entries to return. If value is less than zero all entries are returned
   * @return 
   * @deprecated use {@link #rxSlowlogGet} instead
   */
  @Deprecated()
  public Observable<JsonArray> slowlogGetObservable(int limit) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    slowlogGet(limit, handler.toHandler());
    return handler;
  }

  
Read the Redis slow queries log
Params:
limit – Number of log entries to return. If value is less than zero all entries are returned
Returns:
/**
   * Read the Redis slow queries log
   * @param limit Number of log entries to return. If value is less than zero all entries are returned
   * @return 
   */
  public Single<JsonArray> rxSlowlogGet(int limit) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      slowlogGet(limit, fut);
    }));
  }

  
Get the length of the Redis slow queries log
Params:
handler – Handler for the result of this call.
Returns:
/**
   * Get the length of the Redis slow queries log
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient slowlogLen(Handler<AsyncResult<Long>> handler) { 
    delegate.slowlogLen(handler);
    return this;
  }

    
Get the length of the Redis slow queries log
Returns:
Deprecated:
use rxSlowlogLen instead/**
   * Get the length of the Redis slow queries log
   * @return 
   * @deprecated use {@link #rxSlowlogLen} instead
   */
  @Deprecated()
  public Observable<Long> slowlogLenObservable() { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    slowlogLen(handler.toHandler());
    return handler;
  }

  
Get the length of the Redis slow queries log
Returns:
/**
   * Get the length of the Redis slow queries log
   * @return 
   */
  public Single<Long> rxSlowlogLen() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      slowlogLen(fut);
    }));
  }

  
Reset the Redis slow queries log
Params:
handler – Handler for the result of this call.
Returns:
/**
   * Reset the Redis slow queries log
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient slowlogReset(Handler<AsyncResult<Void>> handler) { 
    delegate.slowlogReset(handler);
    return this;
  }

    
Reset the Redis slow queries log
Returns:
Deprecated:
use rxSlowlogReset instead/**
   * Reset the Redis slow queries log
   * @return 
   * @deprecated use {@link #rxSlowlogReset} instead
   */
  @Deprecated()
  public Observable<Void> slowlogResetObservable() { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    slowlogReset(handler.toHandler());
    return handler;
  }

  
Reset the Redis slow queries log
Returns:
/**
   * Reset the Redis slow queries log
   * @return 
   */
  public Single<Void> rxSlowlogReset() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      slowlogReset(fut);
    }));
  }

  
Get all the members in a set
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get all the members in a set
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient smembers(String key, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.smembers(key, handler);
    return this;
  }

    
Get all the members in a set
Params:
key – Key string
Returns:
Deprecated:
use rxSmembers instead/**
   * Get all the members in a set
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxSmembers} instead
   */
  @Deprecated()
  public Observable<JsonArray> smembersObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    smembers(key, handler.toHandler());
    return handler;
  }

  
Get all the members in a set
Params:
key – Key string
Returns:
/**
   * Get all the members in a set
   * @param key Key string
   * @return 
   */
  public Single<JsonArray> rxSmembers(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      smembers(key, fut);
    }));
  }

  
Move a member from one set to another
Params:
key – Key of source set currently containing the member
destkey – Key identifying the destination set
member – Member to move
handler – Handler for the result of this call.
Returns:
/**
   * Move a member from one set to another
   * @param key Key of source set currently containing the member
   * @param destkey Key identifying the destination set
   * @param member Member to move
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient smove(String key, String destkey, String member, Handler<AsyncResult<Long>> handler) { 
    delegate.smove(key, destkey, member, handler);
    return this;
  }

    
Move a member from one set to another
Params:
key – Key of source set currently containing the member
destkey – Key identifying the destination set
member – Member to move
Returns:
Deprecated:
use rxSmove instead/**
   * Move a member from one set to another
   * @param key Key of source set currently containing the member
   * @param destkey Key identifying the destination set
   * @param member Member to move
   * @return 
   * @deprecated use {@link #rxSmove} instead
   */
  @Deprecated()
  public Observable<Long> smoveObservable(String key, String destkey, String member) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    smove(key, destkey, member, handler.toHandler());
    return handler;
  }

  
Move a member from one set to another
Params:
key – Key of source set currently containing the member
destkey – Key identifying the destination set
member – Member to move
Returns:
/**
   * Move a member from one set to another
   * @param key Key of source set currently containing the member
   * @param destkey Key identifying the destination set
   * @param member Member to move
   * @return 
   */
  public Single<Long> rxSmove(String key, String destkey, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      smove(key, destkey, member, fut);
    }));
  }

  
Sort the elements in a list, set or sorted set
Params:
key – Key string
options – Sort options
handler – Handler for the result of this call.
Returns:
/**
   * Sort the elements in a list, set or sorted set
   * @param key Key string
   * @param options Sort options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sort(String key, SortOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.sort(key, options, handler);
    return this;
  }

    
Sort the elements in a list, set or sorted set
Params:
key – Key string
options – Sort options
Returns:
Deprecated:
use rxSort instead/**
   * Sort the elements in a list, set or sorted set
   * @param key Key string
   * @param options Sort options
   * @return 
   * @deprecated use {@link #rxSort} instead
   */
  @Deprecated()
  public Observable<JsonArray> sortObservable(String key, SortOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sort(key, options, handler.toHandler());
    return handler;
  }

  
Sort the elements in a list, set or sorted set
Params:
key – Key string
options – Sort options
Returns:
/**
   * Sort the elements in a list, set or sorted set
   * @param key Key string
   * @param options Sort options
   * @return 
   */
  public Single<JsonArray> rxSort(String key, SortOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sort(key, options, fut);
    }));
  }

  
Remove and return a random member from a set
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Remove and return a random member from a set
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient spop(String key, Handler<AsyncResult<String>> handler) { 
    delegate.spop(key, handler);
    return this;
  }

    
Remove and return a random member from a set
Params:
key – Key string
Returns:
Deprecated:
use rxSpop instead/**
   * Remove and return a random member from a set
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxSpop} instead
   */
  @Deprecated()
  public Observable<String> spopObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    spop(key, handler.toHandler());
    return handler;
  }

  
Remove and return a random member from a set
Params:
key – Key string
Returns:
/**
   * Remove and return a random member from a set
   * @param key Key string
   * @return 
   */
  public Single<String> rxSpop(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      spop(key, fut);
    }));
  }

  
Remove and return random members from a set
Params:
key – Key string
count – Number of members to remove
handler – Handler for the result of this call.
Returns:
/**
   * Remove and return random members from a set
   * @param key Key string
   * @param count Number of members to remove
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient spopMany(String key, int count, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.spopMany(key, count, handler);
    return this;
  }

    
Remove and return random members from a set
Params:
key – Key string
count – Number of members to remove
Returns:
Deprecated:
use rxSpopMany instead/**
   * Remove and return random members from a set
   * @param key Key string
   * @param count Number of members to remove
   * @return 
   * @deprecated use {@link #rxSpopMany} instead
   */
  @Deprecated()
  public Observable<JsonArray> spopManyObservable(String key, int count) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    spopMany(key, count, handler.toHandler());
    return handler;
  }

  
Remove and return random members from a set
Params:
key – Key string
count – Number of members to remove
Returns:
/**
   * Remove and return random members from a set
   * @param key Key string
   * @param count Number of members to remove
   * @return 
   */
  public Single<JsonArray> rxSpopMany(String key, int count) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      spopMany(key, count, fut);
    }));
  }

  
Get one or multiple random members from a set
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get one or multiple random members from a set
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient srandmember(String key, Handler<AsyncResult<String>> handler) { 
    delegate.srandmember(key, handler);
    return this;
  }

    
Get one or multiple random members from a set
Params:
key – Key string
Returns:
Deprecated:
use rxSrandmember instead/**
   * Get one or multiple random members from a set
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxSrandmember} instead
   */
  @Deprecated()
  public Observable<String> srandmemberObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    srandmember(key, handler.toHandler());
    return handler;
  }

  
Get one or multiple random members from a set
Params:
key – Key string
Returns:
/**
   * Get one or multiple random members from a set
   * @param key Key string
   * @return 
   */
  public Single<String> rxSrandmember(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      srandmember(key, fut);
    }));
  }

  
Get one or multiple random members from a set
Params:
key – Key string
count – Number of members to get
handler – Handler for the result of this call.
Returns:
/**
   * Get one or multiple random members from a set
   * @param key Key string
   * @param count Number of members to get
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient srandmemberCount(String key, int count, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.srandmemberCount(key, count, handler);
    return this;
  }

    
Get one or multiple random members from a set
Params:
key – Key string
count – Number of members to get
Returns:
Deprecated:
use rxSrandmemberCount instead/**
   * Get one or multiple random members from a set
   * @param key Key string
   * @param count Number of members to get
   * @return 
   * @deprecated use {@link #rxSrandmemberCount} instead
   */
  @Deprecated()
  public Observable<JsonArray> srandmemberCountObservable(String key, int count) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    srandmemberCount(key, count, handler.toHandler());
    return handler;
  }

  
Get one or multiple random members from a set
Params:
key – Key string
count – Number of members to get
Returns:
/**
   * Get one or multiple random members from a set
   * @param key Key string
   * @param count Number of members to get
   * @return 
   */
  public Single<JsonArray> rxSrandmemberCount(String key, int count) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      srandmemberCount(key, count, fut);
    }));
  }

  
Remove one member from a set
Params:
key – Key string
member – Member to remove
handler – Handler for the result of this call.
Returns:
/**
   * Remove one member from a set
   * @param key Key string
   * @param member Member to remove
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient srem(String key, String member, Handler<AsyncResult<Long>> handler) { 
    delegate.srem(key, member, handler);
    return this;
  }

    
Remove one member from a set
Params:
key – Key string
member – Member to remove
Returns:
Deprecated:
use rxSrem instead/**
   * Remove one member from a set
   * @param key Key string
   * @param member Member to remove
   * @return 
   * @deprecated use {@link #rxSrem} instead
   */
  @Deprecated()
  public Observable<Long> sremObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    srem(key, member, handler.toHandler());
    return handler;
  }

  
Remove one member from a set
Params:
key – Key string
member – Member to remove
Returns:
/**
   * Remove one member from a set
   * @param key Key string
   * @param member Member to remove
   * @return 
   */
  public Single<Long> rxSrem(String key, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      srem(key, member, fut);
    }));
  }

  
Remove one or more members from a set
Params:
key – Key string
members – Members to remove
handler – Handler for the result of this call.
Returns:
/**
   * Remove one or more members from a set
   * @param key Key string
   * @param members Members to remove
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler) { 
    delegate.sremMany(key, members, handler);
    return this;
  }

    
Remove one or more members from a set
Params:
key – Key string
members – Members to remove
Returns:
Deprecated:
use rxSremMany instead/**
   * Remove one or more members from a set
   * @param key Key string
   * @param members Members to remove
   * @return 
   * @deprecated use {@link #rxSremMany} instead
   */
  @Deprecated()
  public Observable<Long> sremManyObservable(String key, List<String> members) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sremMany(key, members, handler.toHandler());
    return handler;
  }

  
Remove one or more members from a set
Params:
key – Key string
members – Members to remove
Returns:
/**
   * Remove one or more members from a set
   * @param key Key string
   * @param members Members to remove
   * @return 
   */
  public Single<Long> rxSremMany(String key, List<String> members) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sremMany(key, members, fut);
    }));
  }

  
Get the length of the value stored in a key
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get the length of the value stored in a key
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient strlen(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.strlen(key, handler);
    return this;
  }

    
Get the length of the value stored in a key
Params:
key – Key string
Returns:
Deprecated:
use rxStrlen instead/**
   * Get the length of the value stored in a key
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxStrlen} instead
   */
  @Deprecated()
  public Observable<Long> strlenObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    strlen(key, handler.toHandler());
    return handler;
  }

  
Get the length of the value stored in a key
Params:
key – Key string
Returns:
/**
   * Get the length of the value stored in a key
   * @param key Key string
   * @return 
   */
  public Single<Long> rxStrlen(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      strlen(key, fut);
    }));
  }

  
Listen for messages published to the given channels
Params:
channel – Channel to subscribe to
handler – Handler for the result of this call.
Returns:
/**
   * Listen for messages published to the given channels
   * @param channel Channel to subscribe to
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient subscribe(String channel, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.subscribe(channel, handler);
    return this;
  }

    
Listen for messages published to the given channels
Params:
channel – Channel to subscribe to
Returns:
Deprecated:
use rxSubscribe instead/**
   * Listen for messages published to the given channels
   * @param channel Channel to subscribe to
   * @return 
   * @deprecated use {@link #rxSubscribe} instead
   */
  @Deprecated()
  public Observable<JsonArray> subscribeObservable(String channel) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    subscribe(channel, handler.toHandler());
    return handler;
  }

  
Listen for messages published to the given channels
Params:
channel – Channel to subscribe to
Returns:
/**
   * Listen for messages published to the given channels
   * @param channel Channel to subscribe to
   * @return 
   */
  public Single<JsonArray> rxSubscribe(String channel) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      subscribe(channel, fut);
    }));
  }

  
Listen for messages published to the given channels
Params:
channels – List of channels to subscribe to
handler – Handler for the result of this call.
Returns:
/**
   * Listen for messages published to the given channels
   * @param channels List of channels to subscribe to
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient subscribeMany(List<String> channels, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.subscribeMany(channels, handler);
    return this;
  }

    
Listen for messages published to the given channels
Params:
channels – List of channels to subscribe to
Returns:
Deprecated:
use rxSubscribeMany instead/**
   * Listen for messages published to the given channels
   * @param channels List of channels to subscribe to
   * @return 
   * @deprecated use {@link #rxSubscribeMany} instead
   */
  @Deprecated()
  public Observable<JsonArray> subscribeManyObservable(List<String> channels) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    subscribeMany(channels, handler.toHandler());
    return handler;
  }

  
Listen for messages published to the given channels
Params:
channels – List of channels to subscribe to
Returns:
/**
   * Listen for messages published to the given channels
   * @param channels List of channels to subscribe to
   * @return 
   */
  public Single<JsonArray> rxSubscribeMany(List<String> channels) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      subscribeMany(channels, fut);
    }));
  }

  
Add multiple sets
Params:
keys – List of keys identifying sets to add up
handler – Handler for the result of this call.
Returns:
/**
   * Add multiple sets
   * @param keys List of keys identifying sets to add up
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sunion(List<String> keys, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.sunion(keys, handler);
    return this;
  }

    
Add multiple sets
Params:
keys – List of keys identifying sets to add up
Returns:
Deprecated:
use rxSunion instead/**
   * Add multiple sets
   * @param keys List of keys identifying sets to add up
   * @return 
   * @deprecated use {@link #rxSunion} instead
   */
  @Deprecated()
  public Observable<JsonArray> sunionObservable(List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sunion(keys, handler.toHandler());
    return handler;
  }

  
Add multiple sets
Params:
keys – List of keys identifying sets to add up
Returns:
/**
   * Add multiple sets
   * @param keys List of keys identifying sets to add up
   * @return 
   */
  public Single<JsonArray> rxSunion(List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sunion(keys, fut);
    }));
  }

  
Add multiple sets and store the resulting set in a key
Params:
destkey – Destination key
keys – List of keys identifying sets to add up
handler – Handler for the result of this call.
Returns:
/**
   * Add multiple sets and store the resulting set in a key
   * @param destkey Destination key
   * @param keys List of keys identifying sets to add up
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sunionstore(String destkey, List<String> keys, Handler<AsyncResult<Long>> handler) { 
    delegate.sunionstore(destkey, keys, handler);
    return this;
  }

    
Add multiple sets and store the resulting set in a key
Params:
destkey – Destination key
keys – List of keys identifying sets to add up
Returns:
Deprecated:
use rxSunionstore instead/**
   * Add multiple sets and store the resulting set in a key
   * @param destkey Destination key
   * @param keys List of keys identifying sets to add up
   * @return 
   * @deprecated use {@link #rxSunionstore} instead
   */
  @Deprecated()
  public Observable<Long> sunionstoreObservable(String destkey, List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sunionstore(destkey, keys, handler.toHandler());
    return handler;
  }

  
Add multiple sets and store the resulting set in a key
Params:
destkey – Destination key
keys – List of keys identifying sets to add up
Returns:
/**
   * Add multiple sets and store the resulting set in a key
   * @param destkey Destination key
   * @param keys List of keys identifying sets to add up
   * @return 
   */
  public Single<Long> rxSunionstore(String destkey, List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sunionstore(destkey, keys, fut);
    }));
  }

  
Internal command used for replication
Params:
handler – 
Returns:
/**
   * Internal command used for replication
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sync(Handler<AsyncResult<Void>> handler) { 
    delegate.sync(handler);
    return this;
  }

    
Internal command used for replication
Returns:
Deprecated:
use rxSync instead/**
   * Internal command used for replication
   * @return 
   * @deprecated use {@link #rxSync} instead
   */
  @Deprecated()
  public Observable<Void> syncObservable() { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sync(handler.toHandler());
    return handler;
  }

  
Internal command used for replication
Returns:
/**
   * Internal command used for replication
   * @return 
   */
  public Single<Void> rxSync() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sync(fut);
    }));
  }

  
Return the current server time
Params:
handler – 
Returns:
/**
   * Return the current server time
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient time(Handler<AsyncResult<JsonArray>> handler) { 
    delegate.time(handler);
    return this;
  }

    
Return the current server time
Returns:
Deprecated:
use rxTime instead/**
   * Return the current server time
   * @return 
   * @deprecated use {@link #rxTime} instead
   */
  @Deprecated()
  public Observable<JsonArray> timeObservable() { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    time(handler.toHandler());
    return handler;
  }

  
Return the current server time
Returns:
/**
   * Return the current server time
   * @return 
   */
  public Single<JsonArray> rxTime() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      time(fut);
    }));
  }

  
Return a RedisTransaction instance
Returns:
transaction instance/**
   * Return a RedisTransaction instance
   * @return transaction instance
   */
  public io.vertx.rxjava.redis.RedisTransaction transaction() { 
    io.vertx.rxjava.redis.RedisTransaction ret = io.vertx.rxjava.redis.RedisTransaction.newInstance(delegate.transaction());
    return ret;
  }

  
Get the time to live for a key
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get the time to live for a key
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient ttl(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.ttl(key, handler);
    return this;
  }

    
Get the time to live for a key
Params:
key – Key string
Returns:
Deprecated:
use rxTtl instead/**
   * Get the time to live for a key
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxTtl} instead
   */
  @Deprecated()
  public Observable<Long> ttlObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    ttl(key, handler.toHandler());
    return handler;
  }

  
Get the time to live for a key
Params:
key – Key string
Returns:
/**
   * Get the time to live for a key
   * @param key Key string
   * @return 
   */
  public Single<Long> rxTtl(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      ttl(key, fut);
    }));
  }

  
Determine the type stored at key
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Determine the type stored at key
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient type(String key, Handler<AsyncResult<String>> handler) { 
    delegate.type(key, handler);
    return this;
  }

    
Determine the type stored at key
Params:
key – Key string
Returns:
Deprecated:
use rxType instead/**
   * Determine the type stored at key
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxType} instead
   */
  @Deprecated()
  public Observable<String> typeObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    type(key, handler.toHandler());
    return handler;
  }

  
Determine the type stored at key
Params:
key – Key string
Returns:
/**
   * Determine the type stored at key
   * @param key Key string
   * @return 
   */
  public Single<String> rxType(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      type(key, fut);
    }));
  }

  
Stop listening for messages posted to the given channels
Params:
channels – List of channels to subscribe to
handler – Handler for the result of this call.
Returns:
/**
   * Stop listening for messages posted to the given channels
   * @param channels List of channels to subscribe to
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient unsubscribe(List<String> channels, Handler<AsyncResult<Void>> handler) { 
    delegate.unsubscribe(channels, handler);
    return this;
  }

    
Stop listening for messages posted to the given channels
Params:
channels – List of channels to subscribe to
Returns:
Deprecated:
use rxUnsubscribe instead/**
   * Stop listening for messages posted to the given channels
   * @param channels List of channels to subscribe to
   * @return 
   * @deprecated use {@link #rxUnsubscribe} instead
   */
  @Deprecated()
  public Observable<Void> unsubscribeObservable(List<String> channels) { 
    io.vertx.rx.java.ObservableFuture<Void> handler = io.vertx.rx.java.RxHelper.observableFuture();
    unsubscribe(channels, handler.toHandler());
    return handler;
  }

  
Stop listening for messages posted to the given channels
Params:
channels – List of channels to subscribe to
Returns:
/**
   * Stop listening for messages posted to the given channels
   * @param channels List of channels to subscribe to
   * @return 
   */
  public Single<Void> rxUnsubscribe(List<String> channels) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      unsubscribe(channels, fut);
    }));
  }

  
Wait for the synchronous replication of all the write commands sent in the context of the current connection.
Params:
numSlaves – 
timeout – 
handler – Handler for the result of this call.
Returns:
/**
   * Wait for the synchronous replication of all the write commands sent in the context of the current connection.
   * @param numSlaves 
   * @param timeout 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient wait(long numSlaves, long timeout, Handler<AsyncResult<String>> handler) { 
    delegate.wait(numSlaves, timeout, handler);
    return this;
  }

    
Wait for the synchronous replication of all the write commands sent in the context of the current connection.
Params:
numSlaves – 
timeout – 
Returns:
Deprecated:
use rxWait instead/**
   * Wait for the synchronous replication of all the write commands sent in the context of the current connection.
   * @param numSlaves 
   * @param timeout 
   * @return 
   * @deprecated use {@link #rxWait} instead
   */
  @Deprecated()
  public Observable<String> waitObservable(long numSlaves, long timeout) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    wait(numSlaves, timeout, handler.toHandler());
    return handler;
  }

  
Wait for the synchronous replication of all the write commands sent in the context of the current connection.
Params:
numSlaves – 
timeout – 
Returns:
/**
   * Wait for the synchronous replication of all the write commands sent in the context of the current connection.
   * @param numSlaves 
   * @param timeout 
   * @return 
   */
  public Single<String> rxWait(long numSlaves, long timeout) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      wait(numSlaves, timeout, fut);
    }));
  }

  
Add one or more members to a sorted set, or update its score if it already exists
Params:
key – Key string
score – Score used for sorting
member – New member key
handler – Handler for the result of this call.
Returns:
/**
   * Add one or more members to a sorted set, or update its score if it already exists
   * @param key Key string
   * @param score Score used for sorting
   * @param member New member key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zadd(String key, double score, String member, Handler<AsyncResult<Long>> handler) { 
    delegate.zadd(key, score, member, handler);
    return this;
  }

    
Add one or more members to a sorted set, or update its score if it already exists
Params:
key – Key string
score – Score used for sorting
member – New member key
Returns:
Deprecated:
use rxZadd instead/**
   * Add one or more members to a sorted set, or update its score if it already exists
   * @param key Key string
   * @param score Score used for sorting
   * @param member New member key
   * @return 
   * @deprecated use {@link #rxZadd} instead
   */
  @Deprecated()
  public Observable<Long> zaddObservable(String key, double score, String member) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zadd(key, score, member, handler.toHandler());
    return handler;
  }

  
Add one or more members to a sorted set, or update its score if it already exists
Params:
key – Key string
score – Score used for sorting
member – New member key
Returns:
/**
   * Add one or more members to a sorted set, or update its score if it already exists
   * @param key Key string
   * @param score Score used for sorting
   * @param member New member key
   * @return 
   */
  public Single<Long> rxZadd(String key, double score, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zadd(key, score, member, fut);
    }));
  }

  
Add one or more members to a sorted set, or update its score if it already exists
Params:
key – Key string
members – New member keys and their scores
handler – Handler for the result of this call.
Returns:
/**
   * Add one or more members to a sorted set, or update its score if it already exists
   * @param key Key string
   * @param members New member keys and their scores
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zaddMany(String key, Map<String, Double> members, Handler<AsyncResult<Long>> handler) { 
    delegate.zaddMany(key, members, handler);
    return this;
  }

    
Add one or more members to a sorted set, or update its score if it already exists
Params:
key – Key string
members – New member keys and their scores
Returns:
Deprecated:
use rxZaddMany instead/**
   * Add one or more members to a sorted set, or update its score if it already exists
   * @param key Key string
   * @param members New member keys and their scores
   * @return 
   * @deprecated use {@link #rxZaddMany} instead
   */
  @Deprecated()
  public Observable<Long> zaddManyObservable(String key, Map<String, Double> members) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zaddMany(key, members, handler.toHandler());
    return handler;
  }

  
Add one or more members to a sorted set, or update its score if it already exists
Params:
key – Key string
members – New member keys and their scores
Returns:
/**
   * Add one or more members to a sorted set, or update its score if it already exists
   * @param key Key string
   * @param members New member keys and their scores
   * @return 
   */
  public Single<Long> rxZaddMany(String key, Map<String, Double> members) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zaddMany(key, members, fut);
    }));
  }

  
Get the number of members in a sorted set
Params:
key – Key string
handler – Handler for the result of this call.
Returns:
/**
   * Get the number of members in a sorted set
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zcard(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.zcard(key, handler);
    return this;
  }

    
Get the number of members in a sorted set
Params:
key – Key string
Returns:
Deprecated:
use rxZcard instead/**
   * Get the number of members in a sorted set
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxZcard} instead
   */
  @Deprecated()
  public Observable<Long> zcardObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zcard(key, handler.toHandler());
    return handler;
  }

  
Get the number of members in a sorted set
Params:
key – Key string
Returns:
/**
   * Get the number of members in a sorted set
   * @param key Key string
   * @return 
   */
  public Single<Long> rxZcard(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zcard(key, fut);
    }));
  }

  
Count the members in a sorted set with scores within the given values
Params:
key – Key string
min – Minimum score
max – Maximum score
handler – Handler for the result of this call.
Returns:
/**
   * Count the members in a sorted set with scores within the given values
   * @param key Key string
   * @param min Minimum score
   * @param max Maximum score
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zcount(String key, double min, double max, Handler<AsyncResult<Long>> handler) { 
    delegate.zcount(key, min, max, handler);
    return this;
  }

    
Count the members in a sorted set with scores within the given values
Params:
key – Key string
min – Minimum score
max – Maximum score
Returns:
Deprecated:
use rxZcount instead/**
   * Count the members in a sorted set with scores within the given values
   * @param key Key string
   * @param min Minimum score
   * @param max Maximum score
   * @return 
   * @deprecated use {@link #rxZcount} instead
   */
  @Deprecated()
  public Observable<Long> zcountObservable(String key, double min, double max) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zcount(key, min, max, handler.toHandler());
    return handler;
  }

  
Count the members in a sorted set with scores within the given values
Params:
key – Key string
min – Minimum score
max – Maximum score
Returns:
/**
   * Count the members in a sorted set with scores within the given values
   * @param key Key string
   * @param min Minimum score
   * @param max Maximum score
   * @return 
   */
  public Single<Long> rxZcount(String key, double min, double max) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zcount(key, min, max, fut);
    }));
  }

  
Increment the score of a member in a sorted set
Params:
key – Key string
increment – Increment amount
member – Member key
handler – Handler for the result of this call.
Returns:
/**
   * Increment the score of a member in a sorted set
   * @param key Key string
   * @param increment Increment amount
   * @param member Member key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zincrby(String key, double increment, String member, Handler<AsyncResult<String>> handler) { 
    delegate.zincrby(key, increment, member, handler);
    return this;
  }

    
Increment the score of a member in a sorted set
Params:
key – Key string
increment – Increment amount
member – Member key
Returns:
Deprecated:
use rxZincrby instead/**
   * Increment the score of a member in a sorted set
   * @param key Key string
   * @param increment Increment amount
   * @param member Member key
   * @return 
   * @deprecated use {@link #rxZincrby} instead
   */
  @Deprecated()
  public Observable<String> zincrbyObservable(String key, double increment, String member) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zincrby(key, increment, member, handler.toHandler());
    return handler;
  }

  
Increment the score of a member in a sorted set
Params:
key – Key string
increment – Increment amount
member – Member key
Returns:
/**
   * Increment the score of a member in a sorted set
   * @param key Key string
   * @param increment Increment amount
   * @param member Member key
   * @return 
   */
  public Single<String> rxZincrby(String key, double increment, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zincrby(key, increment, member, fut);
    }));
  }

  
Intersect multiple sorted sets and store the resulting sorted set in a new key
Params:
destkey – Destination key
sets – List of keys identifying sorted sets to intersect
options – Aggregation options
handler – Handler for the result of this call.
Returns:
/**
   * Intersect multiple sorted sets and store the resulting sorted set in a new key
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets to intersect
   * @param options Aggregation options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zinterstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler) { 
    delegate.zinterstore(destkey, sets, options, handler);
    return this;
  }

    
Intersect multiple sorted sets and store the resulting sorted set in a new key
Params:
destkey – Destination key
sets – List of keys identifying sorted sets to intersect
options – Aggregation options
Returns:
Deprecated:
use rxZinterstore instead/**
   * Intersect multiple sorted sets and store the resulting sorted set in a new key
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets to intersect
   * @param options Aggregation options
   * @return 
   * @deprecated use {@link #rxZinterstore} instead
   */
  @Deprecated()
  public Observable<Long> zinterstoreObservable(String destkey, List<String> sets, AggregateOptions options) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zinterstore(destkey, sets, options, handler.toHandler());
    return handler;
  }

  
Intersect multiple sorted sets and store the resulting sorted set in a new key
Params:
destkey – Destination key
sets – List of keys identifying sorted sets to intersect
options – Aggregation options
Returns:
/**
   * Intersect multiple sorted sets and store the resulting sorted set in a new key
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets to intersect
   * @param options Aggregation options
   * @return 
   */
  public Single<Long> rxZinterstore(String destkey, List<String> sets, AggregateOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zinterstore(destkey, sets, options, fut);
    }));
  }

  
Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
Params:
destkey – Destination key
sets – List of keys identifying sorted sets to intersect
options – Aggregation options
handler – Handler for the result of this call.
Returns:
/**
   * Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets to intersect
   * @param options Aggregation options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zinterstoreWeighed(String destkey, Map<String, Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler) { 
    delegate.zinterstoreWeighed(destkey, sets, options, handler);
    return this;
  }

    
Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
Params:
destkey – Destination key
sets – List of keys identifying sorted sets to intersect
options – Aggregation options
Returns:
Deprecated:
use rxZinterstoreWeighed instead/**
   * Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets to intersect
   * @param options Aggregation options
   * @return 
   * @deprecated use {@link #rxZinterstoreWeighed} instead
   */
  @Deprecated()
  public Observable<Long> zinterstoreWeighedObservable(String destkey, Map<String, Double> sets, AggregateOptions options) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zinterstoreWeighed(destkey, sets, options, handler.toHandler());
    return handler;
  }

  
Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
Params:
destkey – Destination key
sets – List of keys identifying sorted sets to intersect
options – Aggregation options
Returns:
/**
   * Intersect multiple sorted sets and store the resulting sorted set in a new key using weights for scoring
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets to intersect
   * @param options Aggregation options
   * @return 
   */
  public Single<Long> rxZinterstoreWeighed(String destkey, Map<String, Double> sets, AggregateOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zinterstoreWeighed(destkey, sets, options, fut);
    }));
  }

  
Count the number of members in a sorted set between a given lexicographical range
Params:
key – Key string
min – Pattern to compare against for minimum value
max – Pattern to compare against for maximum value
handler – Handler for the result of this call.
Returns:
/**
   * Count the number of members in a sorted set between a given lexicographical range
   * @param key Key string
   * @param min Pattern to compare against for minimum value
   * @param max Pattern to compare against for maximum value
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zlexcount(String key, String min, String max, Handler<AsyncResult<Long>> handler) { 
    delegate.zlexcount(key, min, max, handler);
    return this;
  }

    
Count the number of members in a sorted set between a given lexicographical range
Params:
key – Key string
min – Pattern to compare against for minimum value
max – Pattern to compare against for maximum value
Returns:
Deprecated:
use rxZlexcount instead/**
   * Count the number of members in a sorted set between a given lexicographical range
   * @param key Key string
   * @param min Pattern to compare against for minimum value
   * @param max Pattern to compare against for maximum value
   * @return 
   * @deprecated use {@link #rxZlexcount} instead
   */
  @Deprecated()
  public Observable<Long> zlexcountObservable(String key, String min, String max) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zlexcount(key, min, max, handler.toHandler());
    return handler;
  }

  
Count the number of members in a sorted set between a given lexicographical range
Params:
key – Key string
min – Pattern to compare against for minimum value
max – Pattern to compare against for maximum value
Returns:
/**
   * Count the number of members in a sorted set between a given lexicographical range
   * @param key Key string
   * @param min Pattern to compare against for minimum value
   * @param max Pattern to compare against for maximum value
   * @return 
   */
  public Single<Long> rxZlexcount(String key, String min, String max) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zlexcount(key, min, max, fut);
    }));
  }

  
Return a range of members in a sorted set, by index
Params:
key – Key string
start – Start index for the range
stop – Stop index for the range - inclusive
handler – Handler for the result of this call.
Returns:
/**
   * Return a range of members in a sorted set, by index
   * @param key Key string
   * @param start Start index for the range
   * @param stop Stop index for the range - inclusive
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zrange(String key, long start, long stop, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.zrange(key, start, stop, handler);
    return this;
  }

    
Return a range of members in a sorted set, by index
Params:
key – Key string
start – Start index for the range
stop – Stop index for the range - inclusive
Returns:
Deprecated:
use rxZrange instead/**
   * Return a range of members in a sorted set, by index
   * @param key Key string
   * @param start Start index for the range
   * @param stop Stop index for the range - inclusive
   * @return 
   * @deprecated use {@link #rxZrange} instead
   */
  @Deprecated()
  public Observable<JsonArray> zrangeObservable(String key, long start, long stop) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrange(key, start, stop, handler.toHandler());
    return handler;
  }

  
Return a range of members in a sorted set, by index
Params:
key – Key string
start – Start index for the range
stop – Stop index for the range - inclusive
Returns:
/**
   * Return a range of members in a sorted set, by index
   * @param key Key string
   * @param start Start index for the range
   * @param stop Stop index for the range - inclusive
   * @return 
   */
  public Single<JsonArray> rxZrange(String key, long start, long stop) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrange(key, start, stop, fut);
    }));
  }

  
Return a range of members in a sorted set, by index
Params:
key – Key string
start – Start index for the range
stop – Stop index for the range - inclusive
options – Range options
handler – Handler for the result of this call.
Returns:
/**
   * Return a range of members in a sorted set, by index
   * @param key Key string
   * @param start Start index for the range
   * @param stop Stop index for the range - inclusive
   * @param options Range options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zrangeWithOptions(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.zrangeWithOptions(key, start, stop, options, handler);
    return this;
  }

    
Return a range of members in a sorted set, by index
Params:
key – Key string
start – Start index for the range
stop – Stop index for the range - inclusive
options – Range options
Returns:
Deprecated:
use rxZrangeWithOptions instead/**
   * Return a range of members in a sorted set, by index
   * @param key Key string
   * @param start Start index for the range
   * @param stop Stop index for the range - inclusive
   * @param options Range options
   * @return 
   * @deprecated use {@link #rxZrangeWithOptions} instead
   */
  @Deprecated()
  public Observable<JsonArray> zrangeWithOptionsObservable(String key, long start, long stop, RangeOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrangeWithOptions(key, start, stop, options, handler.toHandler());
    return handler;
  }

  
Return a range of members in a sorted set, by index
Params:
key – Key string
start – Start index for the range
stop – Stop index for the range - inclusive
options – Range options
Returns:
/**
   * Return a range of members in a sorted set, by index
   * @param key Key string
   * @param start Start index for the range
   * @param stop Stop index for the range - inclusive
   * @param options Range options
   * @return 
   */
  public Single<JsonArray> rxZrangeWithOptions(String key, long start, long stop, RangeOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrangeWithOptions(key, start, stop, options, fut);
    }));
  }

  
Return a range of members in a sorted set, by lexicographical range
Params:
key – Key string
min – Pattern representing a minimum allowed value
max – Pattern representing a maximum allowed value
options – Limit options where limit can be specified
handler – Handler for the result of this call.
Returns:
/**
   * Return a range of members in a sorted set, by lexicographical range
   * @param key Key string
   * @param min Pattern representing a minimum allowed value
   * @param max Pattern representing a maximum allowed value
   * @param options Limit options where limit can be specified
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zrangebylex(String key, String min, String max, LimitOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.zrangebylex(key, min, max, options, handler);
    return this;
  }

    
Return a range of members in a sorted set, by lexicographical range
Params:
key – Key string
min – Pattern representing a minimum allowed value
max – Pattern representing a maximum allowed value
options – Limit options where limit can be specified
Returns:
Deprecated:
use rxZrangebylex instead/**
   * Return a range of members in a sorted set, by lexicographical range
   * @param key Key string
   * @param min Pattern representing a minimum allowed value
   * @param max Pattern representing a maximum allowed value
   * @param options Limit options where limit can be specified
   * @return 
   * @deprecated use {@link #rxZrangebylex} instead
   */
  @Deprecated()
  public Observable<JsonArray> zrangebylexObservable(String key, String min, String max, LimitOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrangebylex(key, min, max, options, handler.toHandler());
    return handler;
  }

  
Return a range of members in a sorted set, by lexicographical range
Params:
key – Key string
min – Pattern representing a minimum allowed value
max – Pattern representing a maximum allowed value
options – Limit options where limit can be specified
Returns:
/**
   * Return a range of members in a sorted set, by lexicographical range
   * @param key Key string
   * @param min Pattern representing a minimum allowed value
   * @param max Pattern representing a maximum allowed value
   * @param options Limit options where limit can be specified
   * @return 
   */
  public Single<JsonArray> rxZrangebylex(String key, String min, String max, LimitOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrangebylex(key, min, max, options, fut);
    }));
  }

  
Return a range of members in a sorted set, by score
Params:
key – Key string
min – Pattern defining a minimum value
max – Pattern defining a maximum value
options – Range and limit options
handler – Handler for the result of this call.
Returns:
/**
   * Return a range of members in a sorted set, by score
   * @param key Key string
   * @param min Pattern defining a minimum value
   * @param max Pattern defining a maximum value
   * @param options Range and limit options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zrangebyscore(String key, String min, String max, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.zrangebyscore(key, min, max, options, handler);
    return this;
  }

    
Return a range of members in a sorted set, by score
Params:
key – Key string
min – Pattern defining a minimum value
max – Pattern defining a maximum value
options – Range and limit options
Returns:
Deprecated:
use rxZrangebyscore instead/**
   * Return a range of members in a sorted set, by score
   * @param key Key string
   * @param min Pattern defining a minimum value
   * @param max Pattern defining a maximum value
   * @param options Range and limit options
   * @return 
   * @deprecated use {@link #rxZrangebyscore} instead
   */
  @Deprecated()
  public Observable<JsonArray> zrangebyscoreObservable(String key, String min, String max, RangeLimitOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrangebyscore(key, min, max, options, handler.toHandler());
    return handler;
  }

  
Return a range of members in a sorted set, by score
Params:
key – Key string
min – Pattern defining a minimum value
max – Pattern defining a maximum value
options – Range and limit options
Returns:
/**
   * Return a range of members in a sorted set, by score
   * @param key Key string
   * @param min Pattern defining a minimum value
   * @param max Pattern defining a maximum value
   * @param options Range and limit options
   * @return 
   */
  public Single<JsonArray> rxZrangebyscore(String key, String min, String max, RangeLimitOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrangebyscore(key, min, max, options, fut);
    }));
  }

  
Determine the index of a member in a sorted set
Params:
key – Key string
member – Member in the sorted set identified by key
handler – Handler for the result of this call.
Returns:
/**
   * Determine the index of a member in a sorted set
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zrank(String key, String member, Handler<AsyncResult<Long>> handler) { 
    delegate.zrank(key, member, handler);
    return this;
  }

    
Determine the index of a member in a sorted set
Params:
key – Key string
member – Member in the sorted set identified by key
Returns:
Deprecated:
use rxZrank instead/**
   * Determine the index of a member in a sorted set
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   * @deprecated use {@link #rxZrank} instead
   */
  @Deprecated()
  public Observable<Long> zrankObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrank(key, member, handler.toHandler());
    return handler;
  }

  
Determine the index of a member in a sorted set
Params:
key – Key string
member – Member in the sorted set identified by key
Returns:
/**
   * Determine the index of a member in a sorted set
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   */
  public Single<Long> rxZrank(String key, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrank(key, member, fut);
    }));
  }

  
Remove one member from a sorted set
Params:
key – Key string
member – Member in the sorted set identified by key
handler – Handler for the result of this call.
Returns:
/**
   * Remove one member from a sorted set
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zrem(String key, String member, Handler<AsyncResult<Long>> handler) { 
    delegate.zrem(key, member, handler);
    return this;
  }

    
Remove one member from a sorted set
Params:
key – Key string
member – Member in the sorted set identified by key
Returns:
Deprecated:
use rxZrem instead/**
   * Remove one member from a sorted set
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   * @deprecated use {@link #rxZrem} instead
   */
  @Deprecated()
  public Observable<Long> zremObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrem(key, member, handler.toHandler());
    return handler;
  }

  
Remove one member from a sorted set
Params:
key – Key string
member – Member in the sorted set identified by key
Returns:
/**
   * Remove one member from a sorted set
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   */
  public Single<Long> rxZrem(String key, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrem(key, member, fut);
    }));
  }

  
Remove one or more members from a sorted set
Params:
key – Key string
members – Members in the sorted set identified by key
handler – Handler for the result of this call.
Returns:
/**
   * Remove one or more members from a sorted set
   * @param key Key string
   * @param members Members in the sorted set identified by key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zremMany(String key, List<String> members, Handler<AsyncResult<Long>> handler) { 
    delegate.zremMany(key, members, handler);
    return this;
  }

    
Remove one or more members from a sorted set
Params:
key – Key string
members – Members in the sorted set identified by key
Returns:
Deprecated:
use rxZremMany instead/**
   * Remove one or more members from a sorted set
   * @param key Key string
   * @param members Members in the sorted set identified by key
   * @return 
   * @deprecated use {@link #rxZremMany} instead
   */
  @Deprecated()
  public Observable<Long> zremManyObservable(String key, List<String> members) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zremMany(key, members, handler.toHandler());
    return handler;
  }

  
Remove one or more members from a sorted set
Params:
key – Key string
members – Members in the sorted set identified by key
Returns:
/**
   * Remove one or more members from a sorted set
   * @param key Key string
   * @param members Members in the sorted set identified by key
   * @return 
   */
  public Single<Long> rxZremMany(String key, List<String> members) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zremMany(key, members, fut);
    }));
  }

  
Remove all members in a sorted set between the given lexicographical range
Params:
key – Key string
min – Pattern defining a minimum value
max – Pattern defining a maximum value
handler – Handler for the result of this call.
Returns:
/**
   * Remove all members in a sorted set between the given lexicographical range
   * @param key Key string
   * @param min Pattern defining a minimum value
   * @param max Pattern defining a maximum value
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zremrangebylex(String key, String min, String max, Handler<AsyncResult<Long>> handler) { 
    delegate.zremrangebylex(key, min, max, handler);
    return this;
  }

    
Remove all members in a sorted set between the given lexicographical range
Params:
key – Key string
min – Pattern defining a minimum value
max – Pattern defining a maximum value
Returns:
Deprecated:
use rxZremrangebylex instead/**
   * Remove all members in a sorted set between the given lexicographical range
   * @param key Key string
   * @param min Pattern defining a minimum value
   * @param max Pattern defining a maximum value
   * @return 
   * @deprecated use {@link #rxZremrangebylex} instead
   */
  @Deprecated()
  public Observable<Long> zremrangebylexObservable(String key, String min, String max) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zremrangebylex(key, min, max, handler.toHandler());
    return handler;
  }

  
Remove all members in a sorted set between the given lexicographical range
Params:
key – Key string
min – Pattern defining a minimum value
max – Pattern defining a maximum value
Returns:
/**
   * Remove all members in a sorted set between the given lexicographical range
   * @param key Key string
   * @param min Pattern defining a minimum value
   * @param max Pattern defining a maximum value
   * @return 
   */
  public Single<Long> rxZremrangebylex(String key, String min, String max) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zremrangebylex(key, min, max, fut);
    }));
  }

  
Remove all members in a sorted set within the given indexes
Params:
key – Key string
start – Start index
stop – Stop index
handler – Handler for the result of this call.
Returns:
/**
   * Remove all members in a sorted set within the given indexes
   * @param key Key string
   * @param start Start index
   * @param stop Stop index
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zremrangebyrank(String key, long start, long stop, Handler<AsyncResult<Long>> handler) { 
    delegate.zremrangebyrank(key, start, stop, handler);
    return this;
  }

    
Remove all members in a sorted set within the given indexes
Params:
key – Key string
start – Start index
stop – Stop index
Returns:
Deprecated:
use rxZremrangebyrank instead/**
   * Remove all members in a sorted set within the given indexes
   * @param key Key string
   * @param start Start index
   * @param stop Stop index
   * @return 
   * @deprecated use {@link #rxZremrangebyrank} instead
   */
  @Deprecated()
  public Observable<Long> zremrangebyrankObservable(String key, long start, long stop) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zremrangebyrank(key, start, stop, handler.toHandler());
    return handler;
  }

  
Remove all members in a sorted set within the given indexes
Params:
key – Key string
start – Start index
stop – Stop index
Returns:
/**
   * Remove all members in a sorted set within the given indexes
   * @param key Key string
   * @param start Start index
   * @param stop Stop index
   * @return 
   */
  public Single<Long> rxZremrangebyrank(String key, long start, long stop) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zremrangebyrank(key, start, stop, fut);
    }));
  }

  
Remove all members in a sorted set within the given scores
Params:
key – Key string
min – Pattern defining a minimum value
max – Pattern defining a maximum value
handler – 
Returns:
/**
   * Remove all members in a sorted set within the given scores
   * @param key Key string
   * @param min Pattern defining a minimum value
   * @param max Pattern defining a maximum value
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zremrangebyscore(String key, String min, String max, Handler<AsyncResult<Long>> handler) { 
    delegate.zremrangebyscore(key, min, max, handler);
    return this;
  }

    
Remove all members in a sorted set within the given scores
Params:
key – Key string
min – Pattern defining a minimum value
max – Pattern defining a maximum value
Returns:
Deprecated:
use rxZremrangebyscore instead/**
   * Remove all members in a sorted set within the given scores
   * @param key Key string
   * @param min Pattern defining a minimum value
   * @param max Pattern defining a maximum value
   * @return 
   * @deprecated use {@link #rxZremrangebyscore} instead
   */
  @Deprecated()
  public Observable<Long> zremrangebyscoreObservable(String key, String min, String max) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zremrangebyscore(key, min, max, handler.toHandler());
    return handler;
  }

  
Remove all members in a sorted set within the given scores
Params:
key – Key string
min – Pattern defining a minimum value
max – Pattern defining a maximum value
Returns:
/**
   * Remove all members in a sorted set within the given scores
   * @param key Key string
   * @param min Pattern defining a minimum value
   * @param max Pattern defining a maximum value
   * @return 
   */
  public Single<Long> rxZremrangebyscore(String key, String min, String max) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zremrangebyscore(key, min, max, fut);
    }));
  }

  
Return a range of members in a sorted set, by index, with scores ordered from high to low
Params:
key – Key string
start – Start index for the range
stop – Stop index for the range - inclusive
options – Range options
handler – Handler for the result of this call.
Returns:
/**
   * Return a range of members in a sorted set, by index, with scores ordered from high to low
   * @param key Key string
   * @param start Start index for the range
   * @param stop Stop index for the range - inclusive
   * @param options Range options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zrevrange(String key, long start, long stop, RangeOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.zrevrange(key, start, stop, options, handler);
    return this;
  }

    
Return a range of members in a sorted set, by index, with scores ordered from high to low
Params:
key – Key string
start – Start index for the range
stop – Stop index for the range - inclusive
options – Range options
Returns:
Deprecated:
use rxZrevrange instead/**
   * Return a range of members in a sorted set, by index, with scores ordered from high to low
   * @param key Key string
   * @param start Start index for the range
   * @param stop Stop index for the range - inclusive
   * @param options Range options
   * @return 
   * @deprecated use {@link #rxZrevrange} instead
   */
  @Deprecated()
  public Observable<JsonArray> zrevrangeObservable(String key, long start, long stop, RangeOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrevrange(key, start, stop, options, handler.toHandler());
    return handler;
  }

  
Return a range of members in a sorted set, by index, with scores ordered from high to low
Params:
key – Key string
start – Start index for the range
stop – Stop index for the range - inclusive
options – Range options
Returns:
/**
   * Return a range of members in a sorted set, by index, with scores ordered from high to low
   * @param key Key string
   * @param start Start index for the range
   * @param stop Stop index for the range - inclusive
   * @param options Range options
   * @return 
   */
  public Single<JsonArray> rxZrevrange(String key, long start, long stop, RangeOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrevrange(key, start, stop, options, fut);
    }));
  }

  
Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
Params:
key – Key string
max – Pattern defining a maximum value
min – Pattern defining a minimum value
options – Limit options
handler – Handler for the result of this call.
Returns:
/**
   * Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
   * @param key Key string
   * @param max Pattern defining a maximum value
   * @param min Pattern defining a minimum value
   * @param options Limit options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zrevrangebylex(String key, String max, String min, LimitOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.zrevrangebylex(key, max, min, options, handler);
    return this;
  }

    
Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
Params:
key – Key string
max – Pattern defining a maximum value
min – Pattern defining a minimum value
options – Limit options
Returns:
Deprecated:
use rxZrevrangebylex instead/**
   * Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
   * @param key Key string
   * @param max Pattern defining a maximum value
   * @param min Pattern defining a minimum value
   * @param options Limit options
   * @return 
   * @deprecated use {@link #rxZrevrangebylex} instead
   */
  @Deprecated()
  public Observable<JsonArray> zrevrangebylexObservable(String key, String max, String min, LimitOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrevrangebylex(key, max, min, options, handler.toHandler());
    return handler;
  }

  
Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
Params:
key – Key string
max – Pattern defining a maximum value
min – Pattern defining a minimum value
options – Limit options
Returns:
/**
   * Return a range of members in a sorted set, by score, between the given lexicographical range with scores ordered from high to low
   * @param key Key string
   * @param max Pattern defining a maximum value
   * @param min Pattern defining a minimum value
   * @param options Limit options
   * @return 
   */
  public Single<JsonArray> rxZrevrangebylex(String key, String max, String min, LimitOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrevrangebylex(key, max, min, options, fut);
    }));
  }

  
Return a range of members in a sorted set, by score, with scores ordered from high to low
Params:
key – Key string
max – Pattern defining a maximum value
min – Pattern defining a minimum value
options – Range and limit options
handler – Handler for the result of this call.
Returns:
/**
   * Return a range of members in a sorted set, by score, with scores ordered from high to low
   * @param key Key string
   * @param max Pattern defining a maximum value
   * @param min Pattern defining a minimum value
   * @param options Range and limit options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zrevrangebyscore(String key, String max, String min, RangeLimitOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.zrevrangebyscore(key, max, min, options, handler);
    return this;
  }

    
Return a range of members in a sorted set, by score, with scores ordered from high to low
Params:
key – Key string
max – Pattern defining a maximum value
min – Pattern defining a minimum value
options – Range and limit options
Returns:
Deprecated:
use rxZrevrangebyscore instead/**
   * Return a range of members in a sorted set, by score, with scores ordered from high to low
   * @param key Key string
   * @param max Pattern defining a maximum value
   * @param min Pattern defining a minimum value
   * @param options Range and limit options
   * @return 
   * @deprecated use {@link #rxZrevrangebyscore} instead
   */
  @Deprecated()
  public Observable<JsonArray> zrevrangebyscoreObservable(String key, String max, String min, RangeLimitOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrevrangebyscore(key, max, min, options, handler.toHandler());
    return handler;
  }

  
Return a range of members in a sorted set, by score, with scores ordered from high to low
Params:
key – Key string
max – Pattern defining a maximum value
min – Pattern defining a minimum value
options – Range and limit options
Returns:
/**
   * Return a range of members in a sorted set, by score, with scores ordered from high to low
   * @param key Key string
   * @param max Pattern defining a maximum value
   * @param min Pattern defining a minimum value
   * @param options Range and limit options
   * @return 
   */
  public Single<JsonArray> rxZrevrangebyscore(String key, String max, String min, RangeLimitOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrevrangebyscore(key, max, min, options, fut);
    }));
  }

  
Determine the index of a member in a sorted set, with scores ordered from high to low
Params:
key – Key string
member – Member in the sorted set identified by key
handler – Handler for the result of this call.
Returns:
/**
   * Determine the index of a member in a sorted set, with scores ordered from high to low
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zrevrank(String key, String member, Handler<AsyncResult<Long>> handler) { 
    delegate.zrevrank(key, member, handler);
    return this;
  }

    
Determine the index of a member in a sorted set, with scores ordered from high to low
Params:
key – Key string
member – Member in the sorted set identified by key
Returns:
Deprecated:
use rxZrevrank instead/**
   * Determine the index of a member in a sorted set, with scores ordered from high to low
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   * @deprecated use {@link #rxZrevrank} instead
   */
  @Deprecated()
  public Observable<Long> zrevrankObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrevrank(key, member, handler.toHandler());
    return handler;
  }

  
Determine the index of a member in a sorted set, with scores ordered from high to low
Params:
key – Key string
member – Member in the sorted set identified by key
Returns:
/**
   * Determine the index of a member in a sorted set, with scores ordered from high to low
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   */
  public Single<Long> rxZrevrank(String key, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrevrank(key, member, fut);
    }));
  }

  
Get the score associated with the given member in a sorted set
Params:
key – Key string
member – Member in the sorted set identified by key
handler – Handler for the result of this call.
Returns:
/**
   * Get the score associated with the given member in a sorted set
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zscore(String key, String member, Handler<AsyncResult<String>> handler) { 
    delegate.zscore(key, member, handler);
    return this;
  }

    
Get the score associated with the given member in a sorted set
Params:
key – Key string
member – Member in the sorted set identified by key
Returns:
Deprecated:
use rxZscore instead/**
   * Get the score associated with the given member in a sorted set
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   * @deprecated use {@link #rxZscore} instead
   */
  @Deprecated()
  public Observable<String> zscoreObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zscore(key, member, handler.toHandler());
    return handler;
  }

  
Get the score associated with the given member in a sorted set
Params:
key – Key string
member – Member in the sorted set identified by key
Returns:
/**
   * Get the score associated with the given member in a sorted set
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   */
  public Single<String> rxZscore(String key, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zscore(key, member, fut);
    }));
  }

  
Add multiple sorted sets and store the resulting sorted set in a new key
Params:
destkey – Destination key
sets – List of keys identifying sorted sets
options – Aggregation options
handler – Handler for the result of this call.
Returns:
/**
   * Add multiple sorted sets and store the resulting sorted set in a new key
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets
   * @param options Aggregation options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zunionstore(String destkey, List<String> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler) { 
    delegate.zunionstore(destkey, sets, options, handler);
    return this;
  }

    
Add multiple sorted sets and store the resulting sorted set in a new key
Params:
destkey – Destination key
sets – List of keys identifying sorted sets
options – Aggregation options
Returns:
Deprecated:
use rxZunionstore instead/**
   * Add multiple sorted sets and store the resulting sorted set in a new key
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets
   * @param options Aggregation options
   * @return 
   * @deprecated use {@link #rxZunionstore} instead
   */
  @Deprecated()
  public Observable<Long> zunionstoreObservable(String destkey, List<String> sets, AggregateOptions options) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zunionstore(destkey, sets, options, handler.toHandler());
    return handler;
  }

  
Add multiple sorted sets and store the resulting sorted set in a new key
Params:
destkey – Destination key
sets – List of keys identifying sorted sets
options – Aggregation options
Returns:
/**
   * Add multiple sorted sets and store the resulting sorted set in a new key
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets
   * @param options Aggregation options
   * @return 
   */
  public Single<Long> rxZunionstore(String destkey, List<String> sets, AggregateOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zunionstore(destkey, sets, options, fut);
    }));
  }

  
Add multiple sorted sets using weights, and store the resulting sorted set in a new key
Params:
key – Destination key
sets – Map containing set-key:weight pairs
options – Aggregation options
handler – Handler for the result of this call.
Returns:
/**
   * Add multiple sorted sets using weights, and store the resulting sorted set in a new key
   * @param key Destination key
   * @param sets Map containing set-key:weight pairs
   * @param options Aggregation options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zunionstoreWeighed(String key, Map<String, Double> sets, AggregateOptions options, Handler<AsyncResult<Long>> handler) { 
    delegate.zunionstoreWeighed(key, sets, options, handler);
    return this;
  }

    
Add multiple sorted sets using weights, and store the resulting sorted set in a new key
Params:
key – Destination key
sets – Map containing set-key:weight pairs
options – Aggregation options
Returns:
Deprecated:
use rxZunionstoreWeighed instead/**
   * Add multiple sorted sets using weights, and store the resulting sorted set in a new key
   * @param key Destination key
   * @param sets Map containing set-key:weight pairs
   * @param options Aggregation options
   * @return 
   * @deprecated use {@link #rxZunionstoreWeighed} instead
   */
  @Deprecated()
  public Observable<Long> zunionstoreWeighedObservable(String key, Map<String, Double> sets, AggregateOptions options) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zunionstoreWeighed(key, sets, options, handler.toHandler());
    return handler;
  }

  
Add multiple sorted sets using weights, and store the resulting sorted set in a new key
Params:
key – Destination key
sets – Map containing set-key:weight pairs
options – Aggregation options
Returns:
/**
   * Add multiple sorted sets using weights, and store the resulting sorted set in a new key
   * @param key Destination key
   * @param sets Map containing set-key:weight pairs
   * @param options Aggregation options
   * @return 
   */
  public Single<Long> rxZunionstoreWeighed(String key, Map<String, Double> sets, AggregateOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zunionstoreWeighed(key, sets, options, fut);
    }));
  }

  
Incrementally iterate the keys space
Params:
cursor – Cursor id
options – Scan options
handler – Handler for the result of this call.
Returns:
/**
   * Incrementally iterate the keys space
   * @param cursor Cursor id
   * @param options Scan options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient scan(String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.scan(cursor, options, handler);
    return this;
  }

    
Incrementally iterate the keys space
Params:
cursor – Cursor id
options – Scan options
Returns:
Deprecated:
use rxScan instead/**
   * Incrementally iterate the keys space
   * @param cursor Cursor id
   * @param options Scan options
   * @return 
   * @deprecated use {@link #rxScan} instead
   */
  @Deprecated()
  public Observable<JsonArray> scanObservable(String cursor, ScanOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    scan(cursor, options, handler.toHandler());
    return handler;
  }

  
Incrementally iterate the keys space
Params:
cursor – Cursor id
options – Scan options
Returns:
/**
   * Incrementally iterate the keys space
   * @param cursor Cursor id
   * @param options Scan options
   * @return 
   */
  public Single<JsonArray> rxScan(String cursor, ScanOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      scan(cursor, options, fut);
    }));
  }

  
Incrementally iterate Set elements
Params:
key – Key string
cursor – Cursor id
options – Scan options
handler – Handler for the result of this call.
Returns:
/**
   * Incrementally iterate Set elements
   * @param key Key string
   * @param cursor Cursor id
   * @param options Scan options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient sscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.sscan(key, cursor, options, handler);
    return this;
  }

    
Incrementally iterate Set elements
Params:
key – Key string
cursor – Cursor id
options – Scan options
Returns:
Deprecated:
use rxSscan instead/**
   * Incrementally iterate Set elements
   * @param key Key string
   * @param cursor Cursor id
   * @param options Scan options
   * @return 
   * @deprecated use {@link #rxSscan} instead
   */
  @Deprecated()
  public Observable<JsonArray> sscanObservable(String key, String cursor, ScanOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    sscan(key, cursor, options, handler.toHandler());
    return handler;
  }

  
Incrementally iterate Set elements
Params:
key – Key string
cursor – Cursor id
options – Scan options
Returns:
/**
   * Incrementally iterate Set elements
   * @param key Key string
   * @param cursor Cursor id
   * @param options Scan options
   * @return 
   */
  public Single<JsonArray> rxSscan(String key, String cursor, ScanOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sscan(key, cursor, options, fut);
    }));
  }

  
Incrementally iterate hash fields and associated values
Params:
key – Key string
cursor – Cursor id
options – Scan options
handler – Handler for the result of this call.
Returns:
/**
   * Incrementally iterate hash fields and associated values
   * @param key Key string
   * @param cursor Cursor id
   * @param options Scan options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.hscan(key, cursor, options, handler);
    return this;
  }

    
Incrementally iterate hash fields and associated values
Params:
key – Key string
cursor – Cursor id
options – Scan options
Returns:
Deprecated:
use rxHscan instead/**
   * Incrementally iterate hash fields and associated values
   * @param key Key string
   * @param cursor Cursor id
   * @param options Scan options
   * @return 
   * @deprecated use {@link #rxHscan} instead
   */
  @Deprecated()
  public Observable<JsonArray> hscanObservable(String key, String cursor, ScanOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hscan(key, cursor, options, handler.toHandler());
    return handler;
  }

  
Incrementally iterate hash fields and associated values
Params:
key – Key string
cursor – Cursor id
options – Scan options
Returns:
/**
   * Incrementally iterate hash fields and associated values
   * @param key Key string
   * @param cursor Cursor id
   * @param options Scan options
   * @return 
   */
  public Single<JsonArray> rxHscan(String key, String cursor, ScanOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hscan(key, cursor, options, fut);
    }));
  }

  
Incrementally iterate sorted sets elements and associated scores
Params:
key – Key string
cursor – Cursor id
options – Scan options
handler – Handler for the result of this call.
Returns:
/**
   * Incrementally iterate sorted sets elements and associated scores
   * @param key Key string
   * @param cursor Cursor id
   * @param options Scan options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient zscan(String key, String cursor, ScanOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.zscan(key, cursor, options, handler);
    return this;
  }

    
Incrementally iterate sorted sets elements and associated scores
Params:
key – Key string
cursor – Cursor id
options – Scan options
Returns:
Deprecated:
use rxZscan instead/**
   * Incrementally iterate sorted sets elements and associated scores
   * @param key Key string
   * @param cursor Cursor id
   * @param options Scan options
   * @return 
   * @deprecated use {@link #rxZscan} instead
   */
  @Deprecated()
  public Observable<JsonArray> zscanObservable(String key, String cursor, ScanOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    zscan(key, cursor, options, handler.toHandler());
    return handler;
  }

  
Incrementally iterate sorted sets elements and associated scores
Params:
key – Key string
cursor – Cursor id
options – Scan options
Returns:
/**
   * Incrementally iterate sorted sets elements and associated scores
   * @param key Key string
   * @param cursor Cursor id
   * @param options Scan options
   * @return 
   */
  public Single<JsonArray> rxZscan(String key, String cursor, ScanOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zscan(key, cursor, options, fut);
    }));
  }

  
Add one or more geospatial items in the geospatial index represented using a sorted set.
Params:
key – Key string
longitude – longitude
latitude – latitude
member – member
handler – Handler for the result of this call.
Returns:
/**
   * Add one or more geospatial items in the geospatial index represented using a sorted set.
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param member member
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient geoadd(String key, double longitude, double latitude, String member, Handler<AsyncResult<Long>> handler) { 
    delegate.geoadd(key, longitude, latitude, member, handler);
    return this;
  }

    
Add one or more geospatial items in the geospatial index represented using a sorted set.
Params:
key – Key string
longitude – longitude
latitude – latitude
member – member
Returns:
Deprecated:
use rxGeoadd instead/**
   * Add one or more geospatial items in the geospatial index represented using a sorted set.
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param member member
   * @return 
   * @deprecated use {@link #rxGeoadd} instead
   */
  @Deprecated()
  public Observable<Long> geoaddObservable(String key, double longitude, double latitude, String member) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    geoadd(key, longitude, latitude, member, handler.toHandler());
    return handler;
  }

  
Add one or more geospatial items in the geospatial index represented using a sorted set.
Params:
key – Key string
longitude – longitude
latitude – latitude
member – member
Returns:
/**
   * Add one or more geospatial items in the geospatial index represented using a sorted set.
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param member member
   * @return 
   */
  public Single<Long> rxGeoadd(String key, double longitude, double latitude, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geoadd(key, longitude, latitude, member, fut);
    }));
  }

  
Add one or more geospatial items in the geospatial index represented using a sorted set.
Params:
key – Key string
members – list of <lon, lat, member>
handler – Handler for the result of this call.
Returns:
/**
   * Add one or more geospatial items in the geospatial index represented using a sorted set.
   * @param key Key string
   * @param members list of &lt;lon, lat, member&gt;
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient geoaddMany(String key, List<GeoMember> members, Handler<AsyncResult<Long>> handler) { 
    delegate.geoaddMany(key, members, handler);
    return this;
  }

    
Add one or more geospatial items in the geospatial index represented using a sorted set.
Params:
key – Key string
members – list of <lon, lat, member>
Returns:
Deprecated:
use rxGeoaddMany instead/**
   * Add one or more geospatial items in the geospatial index represented using a sorted set.
   * @param key Key string
   * @param members list of &lt;lon, lat, member&gt;
   * @return 
   * @deprecated use {@link #rxGeoaddMany} instead
   */
  @Deprecated()
  public Observable<Long> geoaddManyObservable(String key, List<GeoMember> members) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    geoaddMany(key, members, handler.toHandler());
    return handler;
  }

  
Add one or more geospatial items in the geospatial index represented using a sorted set.
Params:
key – Key string
members – list of <lon, lat, member>
Returns:
/**
   * Add one or more geospatial items in the geospatial index represented using a sorted set.
   * @param key Key string
   * @param members list of &lt;lon, lat, member&gt;
   * @return 
   */
  public Single<Long> rxGeoaddMany(String key, List<GeoMember> members) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geoaddMany(key, members, fut);
    }));
  }

  
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
Params:
key – Key string
member – member
handler – Handler for the result of this call.
Returns:
/**
   * Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
   * a geospatial index (where elements were added using GEOADD).
   * @param key Key string
   * @param member member
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient geohash(String key, String member, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.geohash(key, member, handler);
    return this;
  }

    
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
Params:
key – Key string
member – member
Returns:
Deprecated:
use rxGeohash instead/**
   * Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
   * a geospatial index (where elements were added using GEOADD).
   * @param key Key string
   * @param member member
   * @return 
   * @deprecated use {@link #rxGeohash} instead
   */
  @Deprecated()
  public Observable<JsonArray> geohashObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    geohash(key, member, handler.toHandler());
    return handler;
  }

  
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
Params:
key – Key string
member – member
Returns:
/**
   * Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
   * a geospatial index (where elements were added using GEOADD).
   * @param key Key string
   * @param member member
   * @return 
   */
  public Single<JsonArray> rxGeohash(String key, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geohash(key, member, fut);
    }));
  }

  
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
Params:
key – Key string
members – list of members
handler – Handler for the result of this call.
Returns:
/**
   * Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
   * a geospatial index (where elements were added using GEOADD).
   * @param key Key string
   * @param members list of members
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient geohashMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.geohashMany(key, members, handler);
    return this;
  }

    
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
Params:
key – Key string
members – list of members
Returns:
Deprecated:
use rxGeohashMany instead/**
   * Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
   * a geospatial index (where elements were added using GEOADD).
   * @param key Key string
   * @param members list of members
   * @return 
   * @deprecated use {@link #rxGeohashMany} instead
   */
  @Deprecated()
  public Observable<JsonArray> geohashManyObservable(String key, List<String> members) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    geohashMany(key, members, handler.toHandler());
    return handler;
  }

  
Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
a geospatial index (where elements were added using GEOADD).
Params:
key – Key string
members – list of members
Returns:
/**
   * Return valid Geohash strings representing the position of one or more elements in a sorted set value representing
   * a geospatial index (where elements were added using GEOADD).
   * @param key Key string
   * @param members list of members
   * @return 
   */
  public Single<JsonArray> rxGeohashMany(String key, List<String> members) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geohashMany(key, members, fut);
    }));
  }

  
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
Params:
key – Key string
member – member
handler – Handler for the result of this call.
Returns:
/**
   * Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
   * sorted set at key.
   * @param key Key string
   * @param member member
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient geopos(String key, String member, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.geopos(key, member, handler);
    return this;
  }

    
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
Params:
key – Key string
member – member
Returns:
Deprecated:
use rxGeopos instead/**
   * Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
   * sorted set at key.
   * @param key Key string
   * @param member member
   * @return 
   * @deprecated use {@link #rxGeopos} instead
   */
  @Deprecated()
  public Observable<JsonArray> geoposObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    geopos(key, member, handler.toHandler());
    return handler;
  }

  
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
Params:
key – Key string
member – member
Returns:
/**
   * Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
   * sorted set at key.
   * @param key Key string
   * @param member member
   * @return 
   */
  public Single<JsonArray> rxGeopos(String key, String member) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geopos(key, member, fut);
    }));
  }

  
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
Params:
key – Key string
members – list of members
handler – Handler for the result of this call.
Returns:
/**
   * Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
   * sorted set at key.
   * @param key Key string
   * @param members list of members
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient geoposMany(String key, List<String> members, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.geoposMany(key, members, handler);
    return this;
  }

    
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
Params:
key – Key string
members – list of members
Returns:
Deprecated:
use rxGeoposMany instead/**
   * Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
   * sorted set at key.
   * @param key Key string
   * @param members list of members
   * @return 
   * @deprecated use {@link #rxGeoposMany} instead
   */
  @Deprecated()
  public Observable<JsonArray> geoposManyObservable(String key, List<String> members) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    geoposMany(key, members, handler.toHandler());
    return handler;
  }

  
Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
sorted set at key.
Params:
key – Key string
members – list of members
Returns:
/**
   * Return the positions (longitude,latitude) of all the specified members of the geospatial index represented by the
   * sorted set at key.
   * @param key Key string
   * @param members list of members
   * @return 
   */
  public Single<JsonArray> rxGeoposMany(String key, List<String> members) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geoposMany(key, members, fut);
    }));
  }

  
Return the distance between two members in the geospatial index represented by the sorted set.
Params:
key – Key string
member1 – member 1
member2 – member 2
handler – Handler for the result of this call.
Returns:
/**
   * Return the distance between two members in the geospatial index represented by the sorted set.
   * @param key Key string
   * @param member1 member 1
   * @param member2 member 2
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient geodist(String key, String member1, String member2, Handler<AsyncResult<String>> handler) { 
    delegate.geodist(key, member1, member2, handler);
    return this;
  }

    
Return the distance between two members in the geospatial index represented by the sorted set.
Params:
key – Key string
member1 – member 1
member2 – member 2
Returns:
Deprecated:
use rxGeodist instead/**
   * Return the distance between two members in the geospatial index represented by the sorted set.
   * @param key Key string
   * @param member1 member 1
   * @param member2 member 2
   * @return 
   * @deprecated use {@link #rxGeodist} instead
   */
  @Deprecated()
  public Observable<String> geodistObservable(String key, String member1, String member2) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    geodist(key, member1, member2, handler.toHandler());
    return handler;
  }

  
Return the distance between two members in the geospatial index represented by the sorted set.
Params:
key – Key string
member1 – member 1
member2 – member 2
Returns:
/**
   * Return the distance between two members in the geospatial index represented by the sorted set.
   * @param key Key string
   * @param member1 member 1
   * @param member2 member 2
   * @return 
   */
  public Single<String> rxGeodist(String key, String member1, String member2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geodist(key, member1, member2, fut);
    }));
  }

  
Return the distance between two members in the geospatial index represented by the sorted set.
Params:
key – Key string
member1 – member 1
member2 – member 2
unit – geo unit
handler – Handler for the result of this call.
Returns:
/**
   * Return the distance between two members in the geospatial index represented by the sorted set.
   * @param key Key string
   * @param member1 member 1
   * @param member2 member 2
   * @param unit geo unit
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient geodistWithUnit(String key, String member1, String member2, GeoUnit unit, Handler<AsyncResult<String>> handler) { 
    delegate.geodistWithUnit(key, member1, member2, unit, handler);
    return this;
  }

    
Return the distance between two members in the geospatial index represented by the sorted set.
Params:
key – Key string
member1 – member 1
member2 – member 2
unit – geo unit
Returns:
Deprecated:
use rxGeodistWithUnit instead/**
   * Return the distance between two members in the geospatial index represented by the sorted set.
   * @param key Key string
   * @param member1 member 1
   * @param member2 member 2
   * @param unit geo unit
   * @return 
   * @deprecated use {@link #rxGeodistWithUnit} instead
   */
  @Deprecated()
  public Observable<String> geodistWithUnitObservable(String key, String member1, String member2, GeoUnit unit) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    geodistWithUnit(key, member1, member2, unit, handler.toHandler());
    return handler;
  }

  
Return the distance between two members in the geospatial index represented by the sorted set.
Params:
key – Key string
member1 – member 1
member2 – member 2
unit – geo unit
Returns:
/**
   * Return the distance between two members in the geospatial index represented by the sorted set.
   * @param key Key string
   * @param member1 member 1
   * @param member2 member 2
   * @param unit geo unit
   * @return 
   */
  public Single<String> rxGeodistWithUnit(String key, String member1, String member2, GeoUnit unit) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geodistWithUnit(key, member1, member2, unit, fut);
    }));
  }

  
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
Params:
key – Key string
longitude – longitude
latitude – latitude
radius – radius
unit – geo unit
handler – Handler for the result of this call.
Returns:
/**
   * Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
   * of the area specified with the center location and the maximum distance from the center (the radius).
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param radius radius
   * @param unit geo unit
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.georadius(key, longitude, latitude, radius, unit, handler);
    return this;
  }

    
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
Params:
key – Key string
longitude – longitude
latitude – latitude
radius – radius
unit – geo unit
Returns:
Deprecated:
use rxGeoradius instead/**
   * Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
   * of the area specified with the center location and the maximum distance from the center (the radius).
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param radius radius
   * @param unit geo unit
   * @return 
   * @deprecated use {@link #rxGeoradius} instead
   */
  @Deprecated()
  public Observable<JsonArray> georadiusObservable(String key, double longitude, double latitude, double radius, GeoUnit unit) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    georadius(key, longitude, latitude, radius, unit, handler.toHandler());
    return handler;
  }

  
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
Params:
key – Key string
longitude – longitude
latitude – latitude
radius – radius
unit – geo unit
Returns:
/**
   * Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
   * of the area specified with the center location and the maximum distance from the center (the radius).
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param radius radius
   * @param unit geo unit
   * @return 
   */
  public Single<JsonArray> rxGeoradius(String key, double longitude, double latitude, double radius, GeoUnit unit) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      georadius(key, longitude, latitude, radius, unit, fut);
    }));
  }

  
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
Params:
key – Key string
longitude – longitude
latitude – latitude
radius – radius
unit – geo unit
options – geo radius options
handler – Handler for the result of this call.
Returns:
/**
   * Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
   * of the area specified with the center location and the maximum distance from the center (the radius).
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param radius radius
   * @param unit geo unit
   * @param options geo radius options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient georadiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.georadiusWithOptions(key, longitude, latitude, radius, unit, options, handler);
    return this;
  }

    
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
Params:
key – Key string
longitude – longitude
latitude – latitude
radius – radius
unit – geo unit
options – geo radius options
Returns:
Deprecated:
use rxGeoradiusWithOptions instead/**
   * Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
   * of the area specified with the center location and the maximum distance from the center (the radius).
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param radius radius
   * @param unit geo unit
   * @param options geo radius options
   * @return 
   * @deprecated use {@link #rxGeoradiusWithOptions} instead
   */
  @Deprecated()
  public Observable<JsonArray> georadiusWithOptionsObservable(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    georadiusWithOptions(key, longitude, latitude, radius, unit, options, handler.toHandler());
    return handler;
  }

  
Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
of the area specified with the center location and the maximum distance from the center (the radius).
Params:
key – Key string
longitude – longitude
latitude – latitude
radius – radius
unit – geo unit
options – geo radius options
Returns:
/**
   * Return the members of a sorted set populated with geospatial information using GEOADD, which are within the borders
   * of the area specified with the center location and the maximum distance from the center (the radius).
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param radius radius
   * @param unit geo unit
   * @param options geo radius options
   * @return 
   */
  public Single<JsonArray> rxGeoradiusWithOptions(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      georadiusWithOptions(key, longitude, latitude, radius, unit, options, fut);
    }));
  }

  
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
Params:
key – Key string
member – member
radius – radius
unit – geo unit
handler – Handler for the result of this call.
Returns:
/**
   * This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
   * to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
   * index represented by the sorted set.
   * @param key Key string
   * @param member member
   * @param radius radius
   * @param unit geo unit
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient georadiusbymember(String key, String member, double radius, GeoUnit unit, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.georadiusbymember(key, member, radius, unit, handler);
    return this;
  }

    
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
Params:
key – Key string
member – member
radius – radius
unit – geo unit
Returns:
Deprecated:
use rxGeoradiusbymember instead/**
   * This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
   * to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
   * index represented by the sorted set.
   * @param key Key string
   * @param member member
   * @param radius radius
   * @param unit geo unit
   * @return 
   * @deprecated use {@link #rxGeoradiusbymember} instead
   */
  @Deprecated()
  public Observable<JsonArray> georadiusbymemberObservable(String key, String member, double radius, GeoUnit unit) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    georadiusbymember(key, member, radius, unit, handler.toHandler());
    return handler;
  }

  
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
Params:
key – Key string
member – member
radius – radius
unit – geo unit
Returns:
/**
   * This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
   * to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
   * index represented by the sorted set.
   * @param key Key string
   * @param member member
   * @param radius radius
   * @param unit geo unit
   * @return 
   */
  public Single<JsonArray> rxGeoradiusbymember(String key, String member, double radius, GeoUnit unit) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      georadiusbymember(key, member, radius, unit, fut);
    }));
  }

  
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
Params:
key – Key string
member – member
radius – radius
unit – geo unit
options – geo radius options
handler – Handler for the result of this call.
Returns:
/**
   * This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
   * to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
   * index represented by the sorted set.
   * @param key Key string
   * @param member member
   * @param radius radius
   * @param unit geo unit
   * @param options geo radius options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient georadiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.georadiusbymemberWithOptions(key, member, radius, unit, options, handler);
    return this;
  }

    
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
Params:
key – Key string
member – member
radius – radius
unit – geo unit
options – geo radius options
Returns:
Deprecated:
use rxGeoradiusbymemberWithOptions instead/**
   * This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
   * to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
   * index represented by the sorted set.
   * @param key Key string
   * @param member member
   * @param radius radius
   * @param unit geo unit
   * @param options geo radius options
   * @return 
   * @deprecated use {@link #rxGeoradiusbymemberWithOptions} instead
   */
  @Deprecated()
  public Observable<JsonArray> georadiusbymemberWithOptionsObservable(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    georadiusbymemberWithOptions(key, member, radius, unit, options, handler.toHandler());
    return handler;
  }

  
This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
index represented by the sorted set.
Params:
key – Key string
member – member
radius – radius
unit – geo unit
options – geo radius options
Returns:
/**
   * This command is exactly like GEORADIUS with the sole difference that instead of taking, as the center of the area
   * to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial
   * index represented by the sorted set.
   * @param key Key string
   * @param member member
   * @param radius radius
   * @param unit geo unit
   * @param options geo radius options
   * @return 
   */
  public Single<JsonArray> rxGeoradiusbymemberWithOptions(String key, String member, double radius, GeoUnit unit, GeoRadiusOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      georadiusbymemberWithOptions(key, member, radius, unit, options, fut);
    }));
  }

  
Instruct the server whether to reply to commands.
Params:
options – 
handler – 
Returns:
/**
   * Instruct the server whether to reply to commands.
   * @param options 
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clientReply(ClientReplyOptions options, Handler<AsyncResult<String>> handler) { 
    delegate.clientReply(options, handler);
    return this;
  }

    
Instruct the server whether to reply to commands.
Params:
options – 
Returns:
Deprecated:
use rxClientReply instead/**
   * Instruct the server whether to reply to commands.
   * @param options 
   * @return 
   * @deprecated use {@link #rxClientReply} instead
   */
  @Deprecated()
  public Observable<String> clientReplyObservable(ClientReplyOptions options) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    clientReply(options, handler.toHandler());
    return handler;
  }

  
Instruct the server whether to reply to commands.
Params:
options – 
Returns:
/**
   * Instruct the server whether to reply to commands.
   * @param options 
   * @return 
   */
  public Single<String> rxClientReply(ClientReplyOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      clientReply(options, fut);
    }));
  }

  
Get the length of the value of a hash field.
Params:
key – Key String
field – field
handler – 
Returns:
/**
   * Get the length of the value of a hash field.
   * @param key Key String
   * @param field field
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hstrlen(String key, String field, Handler<AsyncResult<Long>> handler) { 
    delegate.hstrlen(key, field, handler);
    return this;
  }

    
Get the length of the value of a hash field.
Params:
key – Key String
field – field
Returns:
Deprecated:
use rxHstrlen instead/**
   * Get the length of the value of a hash field.
   * @param key Key String
   * @param field field
   * @return 
   * @deprecated use {@link #rxHstrlen} instead
   */
  @Deprecated()
  public Observable<Long> hstrlenObservable(String key, String field) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    hstrlen(key, field, handler.toHandler());
    return handler;
  }

  
Get the length of the value of a hash field.
Params:
key – Key String
field – field
Returns:
/**
   * Get the length of the value of a hash field.
   * @param key Key String
   * @param field field
   * @return 
   */
  public Single<Long> rxHstrlen(String key, String field) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hstrlen(key, field, fut);
    }));
  }

  
Alters the last access time of a key(s). Returns the number of existing keys specified.
Params:
key – Key String
handler – 
Returns:
/**
   * Alters the last access time of a key(s). Returns the number of existing keys specified.
   * @param key Key String
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient touch(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.touch(key, handler);
    return this;
  }

    
Alters the last access time of a key(s). Returns the number of existing keys specified.
Params:
key – Key String
Returns:
Deprecated:
use rxTouch instead/**
   * Alters the last access time of a key(s). Returns the number of existing keys specified.
   * @param key Key String
   * @return 
   * @deprecated use {@link #rxTouch} instead
   */
  @Deprecated()
  public Observable<Long> touchObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    touch(key, handler.toHandler());
    return handler;
  }

  
Alters the last access time of a key(s). Returns the number of existing keys specified.
Params:
key – Key String
Returns:
/**
   * Alters the last access time of a key(s). Returns the number of existing keys specified.
   * @param key Key String
   * @return 
   */
  public Single<Long> rxTouch(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      touch(key, fut);
    }));
  }

  
Alters the last access time of a key(s). Returns the number of existing keys specified.
Params:
keys – list of keys
handler – 
Returns:
/**
   * Alters the last access time of a key(s). Returns the number of existing keys specified.
   * @param keys list of keys
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient touchMany(List<String> keys, Handler<AsyncResult<Long>> handler) { 
    delegate.touchMany(keys, handler);
    return this;
  }

    
Alters the last access time of a key(s). Returns the number of existing keys specified.
Params:
keys – list of keys
Returns:
Deprecated:
use rxTouchMany instead/**
   * Alters the last access time of a key(s). Returns the number of existing keys specified.
   * @param keys list of keys
   * @return 
   * @deprecated use {@link #rxTouchMany} instead
   */
  @Deprecated()
  public Observable<Long> touchManyObservable(List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    touchMany(keys, handler.toHandler());
    return handler;
  }

  
Alters the last access time of a key(s). Returns the number of existing keys specified.
Params:
keys – list of keys
Returns:
/**
   * Alters the last access time of a key(s). Returns the number of existing keys specified.
   * @param keys list of keys
   * @return 
   */
  public Single<Long> rxTouchMany(List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      touchMany(keys, fut);
    }));
  }

  
Set the debug mode for executed scripts.
Params:
scriptDebugOptions – the option
handler – 
Returns:
/**
   * Set the debug mode for executed scripts.
   * @param scriptDebugOptions the option
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient scriptDebug(ScriptDebugOptions scriptDebugOptions, Handler<AsyncResult<String>> handler) { 
    delegate.scriptDebug(scriptDebugOptions, handler);
    return this;
  }

    
Set the debug mode for executed scripts.
Params:
scriptDebugOptions – the option
Returns:
Deprecated:
use rxScriptDebug instead/**
   * Set the debug mode for executed scripts.
   * @param scriptDebugOptions the option
   * @return 
   * @deprecated use {@link #rxScriptDebug} instead
   */
  @Deprecated()
  public Observable<String> scriptDebugObservable(ScriptDebugOptions scriptDebugOptions) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    scriptDebug(scriptDebugOptions, handler.toHandler());
    return handler;
  }

  
Set the debug mode for executed scripts.
Params:
scriptDebugOptions – the option
Returns:
/**
   * Set the debug mode for executed scripts.
   * @param scriptDebugOptions the option
   * @return 
   */
  public Single<String> rxScriptDebug(ScriptDebugOptions scriptDebugOptions) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      scriptDebug(scriptDebugOptions, fut);
    }));
  }

  
Perform arbitrary bitfield integer operations on strings.
Params:
key – Key string
bitFieldOptions – 
handler – 
Returns:
/**
   * Perform arbitrary bitfield integer operations on strings.
   * @param key Key string
   * @param bitFieldOptions 
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient bitfield(String key, BitFieldOptions bitFieldOptions, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.bitfield(key, bitFieldOptions, handler);
    return this;
  }

    
Perform arbitrary bitfield integer operations on strings.
Params:
key – Key string
bitFieldOptions – 
Returns:
Deprecated:
use rxBitfield instead/**
   * Perform arbitrary bitfield integer operations on strings.
   * @param key Key string
   * @param bitFieldOptions 
   * @return 
   * @deprecated use {@link #rxBitfield} instead
   */
  @Deprecated()
  public Observable<JsonArray> bitfieldObservable(String key, BitFieldOptions bitFieldOptions) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitfield(key, bitFieldOptions, handler.toHandler());
    return handler;
  }

  
Perform arbitrary bitfield integer operations on strings.
Params:
key – Key string
bitFieldOptions – 
Returns:
/**
   * Perform arbitrary bitfield integer operations on strings.
   * @param key Key string
   * @param bitFieldOptions 
   * @return 
   */
  public Single<JsonArray> rxBitfield(String key, BitFieldOptions bitFieldOptions) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitfield(key, bitFieldOptions, fut);
    }));
  }

  
Perform arbitrary bitfield integer operations on strings.
Params:
key – Key string
commands – 
overflow – 
handler – 
Returns:
/**
   * Perform arbitrary bitfield integer operations on strings.
   * @param key Key string
   * @param commands 
   * @param overflow 
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient bitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow, Handler<AsyncResult<JsonArray>> handler) { 
    delegate.bitfieldWithOverflow(key, commands, overflow, handler);
    return this;
  }

    
Perform arbitrary bitfield integer operations on strings.
Params:
key – Key string
commands – 
overflow – 
Returns:
Deprecated:
use rxBitfieldWithOverflow instead/**
   * Perform arbitrary bitfield integer operations on strings.
   * @param key Key string
   * @param commands 
   * @param overflow 
   * @return 
   * @deprecated use {@link #rxBitfieldWithOverflow} instead
   */
  @Deprecated()
  public Observable<JsonArray> bitfieldWithOverflowObservable(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow) { 
    io.vertx.rx.java.ObservableFuture<JsonArray> handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitfieldWithOverflow(key, commands, overflow, handler.toHandler());
    return handler;
  }

  
Perform arbitrary bitfield integer operations on strings.
Params:
key – Key string
commands – 
overflow – 
Returns:
/**
   * Perform arbitrary bitfield integer operations on strings.
   * @param key Key string
   * @param commands 
   * @param overflow 
   * @return 
   */
  public Single<JsonArray> rxBitfieldWithOverflow(String key, BitFieldOptions commands, BitFieldOverflowOptions overflow) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitfieldWithOverflow(key, commands, overflow, fut);
    }));
  }

  
Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
Params:
key – Key to delete
handler – Handler for the result of this call.
Returns:
/**
   * Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
   * @param key Key to delete
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient unlink(String key, Handler<AsyncResult<Long>> handler) { 
    delegate.unlink(key, handler);
    return this;
  }

    
Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
Params:
key – Key to delete
Returns:
Deprecated:
use rxUnlink instead/**
   * Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
   * @param key Key to delete
   * @return 
   * @deprecated use {@link #rxUnlink} instead
   */
  @Deprecated()
  public Observable<Long> unlinkObservable(String key) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    unlink(key, handler.toHandler());
    return handler;
  }

  
Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
Params:
key – Key to delete
Returns:
/**
   * Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
   * @param key Key to delete
   * @return 
   */
  public Single<Long> rxUnlink(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      unlink(key, fut);
    }));
  }

  
Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
Params:
keys – List of keys to delete
handler – Handler for the result of this call.
Returns:
/**
   * Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
   * @param keys List of keys to delete
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient unlinkMany(List<String> keys, Handler<AsyncResult<Long>> handler) { 
    delegate.unlinkMany(keys, handler);
    return this;
  }

    
Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
Params:
keys – List of keys to delete
Returns:
Deprecated:
use rxUnlinkMany instead/**
   * Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
   * @param keys List of keys to delete
   * @return 
   * @deprecated use {@link #rxUnlinkMany} instead
   */
  @Deprecated()
  public Observable<Long> unlinkManyObservable(List<String> keys) { 
    io.vertx.rx.java.ObservableFuture<Long> handler = io.vertx.rx.java.RxHelper.observableFuture();
    unlinkMany(keys, handler.toHandler());
    return handler;
  }

  
Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
Params:
keys – List of keys to delete
Returns:
/**
   * Delete multiple keys asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
   * @param keys List of keys to delete
   * @return 
   */
  public Single<Long> rxUnlinkMany(List<String> keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      unlinkMany(keys, fut);
    }));
  }

  
Swaps two Redis databases
Params:
index1 – index of first database to swap
index2 – index of second database to swap
handler – Handler for the result of this call.
Returns:
/**
   * Swaps two Redis databases
   * @param index1 index of first database to swap
   * @param index2 index of second database to swap
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient swapdb(int index1, int index2, Handler<AsyncResult<String>> handler) { 
    delegate.swapdb(index1, index2, handler);
    return this;
  }

    
Swaps two Redis databases
Params:
index1 – index of first database to swap
index2 – index of second database to swap
Returns:
Deprecated:
use rxSwapdb instead/**
   * Swaps two Redis databases
   * @param index1 index of first database to swap
   * @param index2 index of second database to swap
   * @return 
   * @deprecated use {@link #rxSwapdb} instead
   */
  @Deprecated()
  public Observable<String> swapdbObservable(int index1, int index2) { 
    io.vertx.rx.java.ObservableFuture<String> handler = io.vertx.rx.java.RxHelper.observableFuture();
    swapdb(index1, index2, handler.toHandler());
    return handler;
  }

  
Swaps two Redis databases
Params:
index1 – index of first database to swap
index2 – index of second database to swap
Returns:
/**
   * Swaps two Redis databases
   * @param index1 index of first database to swap
   * @param index2 index of second database to swap
   * @return 
   */
  public Single<String> rxSwapdb(int index1, int index2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      swapdb(index1, index2, fut);
    }));
  }


  public static  RedisClient newInstance(io.vertx.redis.RedisClient arg) {
    return arg != null ? new RedisClient(arg) : null;
  }
}