io.vertx.rxjava.redis.RedisClient Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of vertx-rx-java Show documentation
There is a newer version: 5.0.0.CR2
/*
 * 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 rx.Observable;
import rx.Single;
import io.vertx.rx.java.RxHelper;
import io.vertx.rx.java.WriteStreamSubscriber;
import io.vertx.rx.java.SingleOnSubscribeAdapter;
import java.util.Map;
import java.util.Set;
import java.util.List;
import java.util.Iterator;
import java.util.function.Function;
import java.util.stream.Collectors;
import io.vertx.core.Handler;
import io.vertx.core.AsyncResult;
import io.vertx.core.json.JsonObject;
import io.vertx.core.json.JsonArray;
import io.vertx.lang.rx.RxGen;
import io.vertx.lang.rx.TypeArg;
import io.vertx.lang.rx.MappingIterator;

/**
 * This factory is deprecated use {@link io.vertx.rxjava.redis.client.Redis} instead,
 * or for a typed API {@link io.vertx.rxjava.redis.client.RedisAPI}.
 *
 * 
 * NOTE: This class has been automatically generated from the {@link io.vertx.redis.RedisClient original} non RX-ified interface using Vert.x codegen.
 */

@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 TypeArg __TYPE_ARG = new 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 RedisClient(Object delegate) {
    this.delegate = (io.vertx.redis.RedisClient)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)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)io.vertx.redis.RedisClient.create(vertx.getDelegate(), config));
    return ret;
  }

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

    /**
   * Close the client - when it is fully closed the handler will be called.
   * @return 
   * @deprecated use {@link #rxClose} instead
   */
  @Deprecated()
  public Observable closeObservable() { 
    io.vertx.rx.java.ObservableFuture 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.
   * @return 
   */
  public Single rxClose() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      close(fut);
    }));
  }

  /**
   * 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> handler) { 
    delegate.append(key, value, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.auth(password, handler);
    return this;
  }

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

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

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

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

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

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

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

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

  /**
   * 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> handler) { 
    delegate.bitcount(key, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.bitcountRange(key, start, end, handler);
    return this;
  }

    /**
   * 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 bitcountRangeObservable(String key, long start, long end) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitcountRange(key, start, end, handler.toHandler());
    return handler;
  }

  /**
   * Count set bits in a string
   * @param key Key string
   * @param start Start index
   * @param end End index
   * @return 
   */
  public Single 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
   * @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(io.vertx.redis.op.BitOperation operation, String destkey, List keys, Handler> handler) { 
    delegate.bitop(operation, destkey, keys, handler);
    return this;
  }

    /**
   * 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 bitopObservable(io.vertx.redis.op.BitOperation operation, String destkey, List keys) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitop(operation, destkey, keys, handler.toHandler());
    return handler;
  }

  /**
   * 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 rxBitop(io.vertx.redis.op.BitOperation operation, String destkey, List 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
   * @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> handler) { 
    delegate.bitpos(key, bit, handler);
    return this;
  }

    /**
   * 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 bitposObservable(String key, int bit) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitpos(key, bit, handler.toHandler());
    return handler;
  }

  /**
   * 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 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.
   * @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> 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.
   * @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 bitposFromObservable(String key, int bit, int start) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key string
   * @param bit What bit value to look for - must be 1, or 0
   * @param start Start offset
   * @return 
   */
  public Single 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
   * @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> 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
   * @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 bitposRangeObservable(String key, int bit, int start, int stop) { 
    io.vertx.rx.java.ObservableFuture 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
   * @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 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
   * @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> handler) { 
    delegate.blpop(key, seconds, handler);
    return this;
  }

    /**
   * 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 blpopObservable(String key, int seconds) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string identifying a list to watch
   * @param seconds Timeout in seconds
   * @return 
   */
  public Single 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
   * @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 keys, int seconds, Handler> 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
   * @param keys List of key strings identifying lists to watch
   * @param seconds Timeout in seconds
   * @return 
   * @deprecated use {@link #rxBlpopMany} instead
   */
  @Deprecated()
  public Observable blpopManyObservable(List keys, int seconds) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param keys List of key strings identifying lists to watch
   * @param seconds Timeout in seconds
   * @return 
   */
  public Single rxBlpopMany(List 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
   * @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> handler) { 
    delegate.brpop(key, seconds, handler);
    return this;
  }

    /**
   * 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 brpopObservable(String key, int seconds) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string identifying a list to watch
   * @param seconds Timeout in seconds
   * @return 
   */
  public Single 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
   * @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 keys, int seconds, Handler> 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
   * @param keys List of key strings identifying lists to watch
   * @param seconds Timeout in seconds
   * @return 
   * @deprecated use {@link #rxBrpopMany} instead
   */
  @Deprecated()
  public Observable brpopManyObservable(List keys, int seconds) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param keys List of key strings identifying lists to watch
   * @param seconds Timeout in seconds
   * @return 
   */
  public Single rxBrpopMany(List 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
   * @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> 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
   * @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 brpoplpushObservable(String key, String destkey, int seconds) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string identifying the source list
   * @param destkey Key string identifying the destination list
   * @param seconds Timeout in seconds
   * @return 
   */
  public Single 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
   * @param filter Filter options
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clientKill(io.vertx.redis.op.KillFilter filter, Handler> handler) { 
    delegate.clientKill(filter, handler);
    return this;
  }

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

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

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

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

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

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

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

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

  /**
   * 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> handler) { 
    delegate.clientPause(millis, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.clientSetname(name, handler);
    return this;
  }

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

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

  /**
   * 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 slots, Handler> handler) { 
    delegate.clusterAddslots(slots, handler);
    return this;
  }

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

  /**
   * Assign new hash slots to receiving node.
   * @param slots 
   * @return 
   */
  public Single rxClusterAddslots(List 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.
   * @param nodeId 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterCountFailureReports(String nodeId, Handler> handler) { 
    delegate.clusterCountFailureReports(nodeId, handler);
    return this;
  }

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

  /**
   * Return the number of failure reports active for a given node.
   * @param nodeId 
   * @return 
   */
  public Single 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.
   * @param slot 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterCountkeysinslot(long slot, Handler> handler) { 
    delegate.clusterCountkeysinslot(slot, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.clusterDelslots(slot, handler);
    return this;
  }

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

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

  /**
   * 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 slots, Handler> handler) { 
    delegate.clusterDelslotsMany(slots, handler);
    return this;
  }

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

  /**
   * Set hash slots as unbound in receiving node.
   * @param slots 
   * @return 
   */
  public Single rxClusterDelslotsMany(List 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.
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterFailover(Handler> handler) { 
    delegate.clusterFailover(handler);
    return this;
  }

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

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

  /**
   * 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(io.vertx.redis.op.FailoverOptions options, Handler> handler) { 
    delegate.clusterFailOverWithOptions(options, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.clusterForget(nodeId, handler);
    return this;
  }

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

  /**
   * Remove a node from the nodes table.
   * @param nodeId 
   * @return 
   */
  public Single 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.
   * @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> handler) { 
    delegate.clusterGetkeysinslot(slot, count, handler);
    return this;
  }

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

  /**
   * Return local key names in the specified hash slot.
   * @param slot 
   * @param count 
   * @return 
   */
  public Single 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.
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterInfo(Handler> handler) { 
    delegate.clusterInfo(handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.clusterKeyslot(key, handler);
    return this;
  }

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

  /**
   * Returns the hash slot of the specified key.
   * @param key 
   * @return 
   */
  public Single 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.
   * @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> handler) { 
    delegate.clusterMeet(ip, port, handler);
    return this;
  }

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

  /**
   * Force a node cluster to handshake with another node.
   * @param ip 
   * @param port 
   * @return 
   */
  public Single 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.
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterNodes(Handler> handler) { 
    delegate.clusterNodes(handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.clusterReplicate(nodeId, handler);
    return this;
  }

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

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

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

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

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

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

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

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

  /**
   * 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> handler) { 
    delegate.clusterSaveconfig(handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.clusterSetConfigEpoch(epoch, handler);
    return this;
  }

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

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

  /**
   * 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, io.vertx.redis.op.SlotCmd subcommand, Handler> handler) { 
    delegate.clusterSetslot(slot, subcommand, handler);
    return this;
  }

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

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

  /**
   * 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, io.vertx.redis.op.SlotCmd subcommand, String nodeId, Handler> handler) { 
    delegate.clusterSetslotWithNode(slot, subcommand, nodeId, handler);
    return this;
  }

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

  /**
   * Bind an hash slot to a specific node.
   * @param slot 
   * @param subcommand 
   * @param nodeId 
   * @return 
   */
  public Single rxClusterSetslotWithNode(long slot, io.vertx.redis.op.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.
   * @param nodeId 
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clusterSlaves(String nodeId, Handler> handler) { 
    delegate.clusterSlaves(nodeId, handler);
    return this;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /**
   * 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 commands, Handler> handler) { 
    delegate.commandInfo(commands, handler);
    return this;
  }

    /**
   * 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 commandInfoObservable(List commands) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    commandInfo(commands, handler.toHandler());
    return handler;
  }

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

  /**
   * 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> handler) { 
    delegate.configGet(parameter, handler);
    return this;
  }

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

  /**
   * Get the value of a configuration parameter
   * @param parameter Configuration parameter
   * @return 
   */
  public Single 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
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient configRewrite(Handler> handler) { 
    delegate.configRewrite(handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.configSet(parameter, value, handler);
    return this;
  }

    /**
   * 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 configSetObservable(String parameter, String value) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    configSet(parameter, value, handler.toHandler());
    return handler;
  }

  /**
   * Set a configuration parameter to the given value
   * @param parameter Configuration parameter
   * @param value New value
   * @return 
   */
  public Single 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
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient configResetstat(Handler> handler) { 
    delegate.configResetstat(handler);
    return this;
  }

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

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

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

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

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

  /**
   * 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> handler) { 
    delegate.debugObject(key, handler);
    return this;
  }

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

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

  /**
   * Make the server crash
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient debugSegfault(Handler> handler) { 
    delegate.debugSegfault(handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.decr(key, handler);
    return this;
  }

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

  /**
   * Decrement the integer value of a key by one
   * @param key Key string
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.decrby(key, decrement, handler);
    return this;
  }

    /**
   * 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 decrbyObservable(String key, long decrement) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param decrement Value by which to decrement
   * @return 
   */
  public Single rxDecrby(String key, long decrement) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      decrby(key, decrement, fut);
    }));
  }

  /**
   * 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> handler) { 
    delegate.del(key, handler);
    return this;
  }

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

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

  /**
   * 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 keys, Handler> handler) { 
    delegate.delMany(keys, handler);
    return this;
  }

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

  /**
   * Delete many keys
   * @param keys List of keys to delete
   * @return 
   */
  public Single rxDelMany(List 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.
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient dump(String key, Handler> handler) { 
    delegate.dump(key, handler);
    return this;
  }

    /**
   * 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 dumpObservable(String key) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key string
   * @return 
   */
  public Single rxDump(String key) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      dump(key, fut);
    }));
  }

  /**
   * 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> handler) { 
    delegate.echo(message, handler);
    return this;
  }

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

  /**
   * Echo the given string
   * @param message String to echo
   * @return 
   */
  public Single 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.
   * @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 keys, List args, Handler> 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.
   * @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 evalObservable(String script, List keys, List args) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param script Lua script to evaluate
   * @param keys List of keys
   * @param args List of argument values
   * @return 
   */
  public Single rxEval(String script, List keys, List 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.
   * @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 keys, List values, Handler> 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.
   * @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 evalshaObservable(String sha1, List keys, List values) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param sha1 SHA1 digest of the script cached on the server
   * @param keys List of keys
   * @param values List of values
   * @return 
   */
  public Single rxEvalsha(String sha1, List keys, List 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.
   * @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 keys, List args, Handler> 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.
   * @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 evalScriptObservable(io.vertx.rxjava.redis.Script script, List keys, List args) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param script Lua script and its SHA1 digest
   * @param keys List of keys
   * @param args List of argument values
   * @return 
   */
  public Single rxEvalScript(io.vertx.rxjava.redis.Script script, List keys, List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      evalScript(script, keys, args, fut);
    }));
  }

  /**
   * 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> handler) { 
    delegate.exists(key, handler);
    return this;
  }

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

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

  /**
   * 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 keys, Handler> handler) { 
    delegate.existsMany(keys, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.expire(key, seconds, handler);
    return this;
  }

    /**
   * 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 expireObservable(String key, long seconds) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    expire(key, seconds, handler.toHandler());
    return handler;
  }

  /**
   * Set a key's time to live in seconds
   * @param key Key string
   * @param seconds Time to live in seconds
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.expireat(key, seconds, handler);
    return this;
  }

    /**
   * 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 expireatObservable(String key, long seconds) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    expireat(key, seconds, handler.toHandler());
    return handler;
  }

  /**
   * 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 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
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient flushall(Handler> handler) { 
    delegate.flushall(handler);
    return this;
  }

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

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

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

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

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

  /**
   * 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> handler) { 
    delegate.get(key, handler);
    return this;
  }

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

  /**
   * Get the value of a key
   * @param key Key string
   * @return 
   */
  public Single 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
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient getBinary(String key, Handler> handler) { 
    delegate.getBinary(key, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.core.buffer.Buffer.newInstance((io.vertx.core.buffer.Buffer)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
   * @param key Key string
   * @return 
   * @deprecated use {@link #rxGetBinary} instead
   */
  @Deprecated()
  public Observable getBinaryObservable(String key) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    getBinary(key, handler.toHandler());
    return handler;
  }

  /**
   * Get the value of a key - without decoding as utf-8
   * @param key Key string
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.getbit(key, offset, handler);
    return this;
  }

    /**
   * 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 getbitObservable(String key, long offset) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param offset Offset in bits
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.getrange(key, start, end, handler);
    return this;
  }

    /**
   * 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 getrangeObservable(String key, long start, long end) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param start Start offset
   * @param end End offset - inclusive
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.getset(key, value, handler);
    return this;
  }

    /**
   * 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 getsetObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key of which value to set
   * @param value New value for the key
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.hdel(key, field, handler);
    return this;
  }

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

  /**
   * Delete one or more hash fields
   * @param key Key string
   * @param field Field name
   * @return 
   */
  public Single 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
   * @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 fields, Handler> handler) { 
    delegate.hdelMany(key, fields, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.hexists(key, field, handler);
    return this;
  }

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

  /**
   * Determine if a hash field exists
   * @param key Key string
   * @param field Field name
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.hget(key, field, handler);
    return this;
  }

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

  /**
   * Get the value of a hash field
   * @param key Key string
   * @param field Field name
   * @return 
   */
  public Single 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
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hgetall(String key, Handler> handler) { 
    delegate.hgetall(key, handler);
    return this;
  }

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

  /**
   * Get all the fields and values in a hash
   * @param key Key string
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.hincrby(key, field, increment, handler);
    return this;
  }

    /**
   * 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 hincrbyObservable(String key, String field, long increment) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param field Field name
   * @param increment Value by which to increment
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.hincrbyfloat(key, field, increment, handler);
    return this;
  }

    /**
   * 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 hincrbyfloatObservable(String key, String field, double increment) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param field Field name
   * @param increment Value by which to increment
   * @return 
   */
  public Single 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
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hkeys(String key, Handler> handler) { 
    delegate.hkeys(key, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.hlen(key, handler);
    return this;
  }

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

  /**
   * Get the number of fields in a hash
   * @param key Key string
   * @return 
   */
  public Single 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
   * @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 fields, Handler> handler) { 
    delegate.hmget(key, fields, handler);
    return this;
  }

    /**
   * 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 hmgetObservable(String key, List fields) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hmget(key, fields, handler.toHandler());
    return handler;
  }

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

  /**
   * 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> handler) { 
    delegate.hmset(key, values, handler);
    return this;
  }

    /**
   * 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 hmsetObservable(String key, JsonObject values) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hmset(key, values, handler.toHandler());
    return handler;
  }

  /**
   * Set multiple hash fields to multiple values
   * @param key Key string
   * @param values Map of field:value pairs
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.hset(key, field, value, handler);
    return this;
  }

    /**
   * 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 hsetObservable(String key, String field, String value) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hset(key, field, value, handler.toHandler());
    return handler;
  }

  /**
   * Set the string value of a hash field
   * @param key Key string
   * @param field Field name
   * @param value New value
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.hsetnx(key, field, value, handler);
    return this;
  }

    /**
   * 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 hsetnxObservable(String key, String field, String value) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param field Field name
   * @param value New value
   * @return 
   */
  public Single 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
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hvals(String key, Handler> handler) { 
    delegate.hvals(key, handler);
    return this;
  }

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

  /**
   * Get all the values in a hash
   * @param key Key string
   * @return 
   */
  public Single 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
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient incr(String key, Handler> handler) { 
    delegate.incr(key, handler);
    return this;
  }

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

  /**
   * Increment the integer value of a key by one
   * @param key Key string
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.incrby(key, increment, handler);
    return this;
  }

    /**
   * 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 incrbyObservable(String key, long increment) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param increment Value by which to increment
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.incrbyfloat(key, increment, handler);
    return this;
  }

    /**
   * 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 incrbyfloatObservable(String key, double increment) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param increment Value by which to increment
   * @return 
   */
  public Single 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
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient info(Handler> handler) { 
    delegate.info(handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.infoSection(section, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.keys(pattern, handler);
    return this;
  }

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

  /**
   * Find all keys matching the given pattern
   * @param pattern Pattern to limit the keys returned
   * @return 
   */
  public Single 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
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient lastsave(Handler> handler) { 
    delegate.lastsave(handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.lindex(key, index, handler);
    return this;
  }

    /**
   * 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 lindexObservable(String key, int index) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lindex(key, index, handler.toHandler());
    return handler;
  }

  /**
   * Get an element from a list by its index
   * @param key Key string
   * @param index Index of list element to get
   * @return 
   */
  public Single 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
   * @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, io.vertx.redis.op.InsertOptions option, String pivot, String value, Handler> handler) { 
    delegate.linsert(key, option, pivot, value, handler);
    return this;
  }

    /**
   * 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 linsertObservable(String key, io.vertx.redis.op.InsertOptions option, String pivot, String value) { 
    io.vertx.rx.java.ObservableFuture 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
   * @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 rxLinsert(String key, io.vertx.redis.op.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
   * @param key String key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient llen(String key, Handler> handler) { 
    delegate.llen(key, handler);
    return this;
  }

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

  /**
   * Get the length of a list
   * @param key String key
   * @return 
   */
  public Single 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
   * @param key String key
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient lpop(String key, Handler> handler) { 
    delegate.lpop(key, handler);
    return this;
  }

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

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

  /**
   * 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 values, Handler> handler) { 
    delegate.lpushMany(key, values, handler);
    return this;
  }

    /**
   * 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 lpushManyObservable(String key, List values) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lpushMany(key, values, handler.toHandler());
    return handler;
  }

  /**
   * 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 rxLpushMany(String key, List values) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lpushMany(key, values, fut);
    }));
  }

  /**
   * 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> handler) { 
    delegate.lpush(key, value, handler);
    return this;
  }

    /**
   * 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 lpushObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lpush(key, value, handler.toHandler());
    return handler;
  }

  /**
   * 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 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
   * @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> handler) { 
    delegate.lpushx(key, value, handler);
    return this;
  }

    /**
   * 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 lpushxObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param value Value to add at the beginning of the list
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.lrange(key, from, to, handler);
    return this;
  }

    /**
   * 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 lrangeObservable(String key, long from, long to) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lrange(key, from, to, handler.toHandler());
    return handler;
  }

  /**
   * Get a range of elements from a list
   * @param key Key string
   * @param from Start index
   * @param to Stop index
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.lrem(key, count, value, handler);
    return this;
  }

    /**
   * 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 lremObservable(String key, long count, String value) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lrem(key, count, value, handler.toHandler());
    return handler;
  }

  /**
   * 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 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
   * @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> handler) { 
    delegate.lset(key, index, value, handler);
    return this;
  }

    /**
   * 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 lsetObservable(String key, long index, String value) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param index Position within list
   * @param value New value
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.ltrim(key, from, to, handler);
    return this;
  }

    /**
   * 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 ltrimObservable(String key, long from, long to) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    ltrim(key, from, to, handler.toHandler());
    return handler;
  }

  /**
   * Trim a list to the specified range
   * @param key Key string
   * @param from Start index
   * @param to Stop index
   * @return 
   */
  public Single 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
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient mget(String key, Handler> handler) { 
    delegate.mget(key, handler);
    return this;
  }

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

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

  /**
   * 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 keys, Handler> handler) { 
    delegate.mgetMany(keys, handler);
    return this;
  }

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

  /**
   * Get the values of all the given keys
   * @param keys List of keys to get
   * @return 
   */
  public Single rxMgetMany(List 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.
   * @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, io.vertx.redis.op.MigrateOptions options, Handler> handler) { 
    delegate.migrate(host, port, key, destdb, timeout, options, handler);
    return this;
  }

    /**
   * 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 migrateObservable(String host, int port, String key, int destdb, long timeout, io.vertx.redis.op.MigrateOptions options) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @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 rxMigrate(String host, int port, String key, int destdb, long timeout, io.vertx.redis.op.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
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient monitor(Handler> handler) { 
    delegate.monitor(handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.move(key, destdb, handler);
    return this;
  }

    /**
   * 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 moveObservable(String key, int destdb) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    move(key, destdb, handler.toHandler());
    return handler;
  }

  /**
   * Move a key to another database
   * @param key Key to migrate
   * @param destdb Destination database index
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.mset(keyvals, handler);
    return this;
  }

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

  /**
   * Set multiple keys to multiple values
   * @param keyvals Key value pairs to set
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.msetnx(keyvals, handler);
    return this;
  }

    /**
   * 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 msetnxObservable(JsonObject keyvals) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param keyvals Key value pairs to set
   * @return 
   */
  public Single rxMsetnx(JsonObject keyvals) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      msetnx(keyvals, fut);
    }));
  }

  /**
   * 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, io.vertx.redis.op.ObjectCmd cmd, Handler> handler) { 
    delegate.object(key, cmd, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.persist(key, handler);
    return this;
  }

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

  /**
   * Remove the expiration from a key
   * @param key Key string
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.pexpire(key, millis, handler);
    return this;
  }

    /**
   * 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 pexpireObservable(String key, long millis) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pexpire(key, millis, handler.toHandler());
    return handler;
  }

  /**
   * Set a key's time to live in milliseconds
   * @param key String key
   * @param millis Time to live in milliseconds
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.pexpireat(key, millis, handler);
    return this;
  }

    /**
   * 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 pexpireatObservable(String key, long millis) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param millis Expiry time as Unix timestamp in milliseconds
   * @return 
   */
  public Single 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.
   * @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> handler) { 
    delegate.pfadd(key, element, handler);
    return this;
  }

    /**
   * 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 pfaddObservable(String key, String element) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfadd(key, element, handler.toHandler());
    return handler;
  }

  /**
   * Adds the specified element to the specified HyperLogLog.
   * @param key Key string
   * @param element Element to add
   * @return 
   */
  public Single 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.
   * @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 elements, Handler> handler) { 
    delegate.pfaddMany(key, elements, handler);
    return this;
  }

    /**
   * 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 pfaddManyObservable(String key, List elements) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfaddMany(key, elements, handler.toHandler());
    return handler;
  }

  /**
   * Adds the specified elements to the specified HyperLogLog.
   * @param key Key string
   * @param elements Elementa to add
   * @return 
   */
  public Single rxPfaddMany(String key, List 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.
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pfcount(String key, Handler> handler) { 
    delegate.pfcount(key, handler);
    return this;
  }

    /**
   * 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 pfcountObservable(String key) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key string
   * @return 
   */
  public Single 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).
   * @param keys List of keys
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pfcountMany(List keys, Handler> handler) { 
    delegate.pfcountMany(keys, handler);
    return this;
  }

    /**
   * 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 pfcountManyObservable(List keys) { 
    io.vertx.rx.java.ObservableFuture 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).
   * @param keys List of keys
   * @return 
   */
  public Single rxPfcountMany(List keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pfcountMany(keys, fut);
    }));
  }

  /**
   * 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 keys, Handler> handler) { 
    delegate.pfmerge(destkey, keys, handler);
    return this;
  }

    /**
   * 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 pfmergeObservable(String destkey, List keys) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfmerge(destkey, keys, handler.toHandler());
    return handler;
  }

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

  /**
   * Ping the server
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient ping(Handler> handler) { 
    delegate.ping(handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.psetex(key, millis, value, handler);
    return this;
  }

    /**
   * 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 psetexObservable(String key, long millis, String value) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param millis Number of milliseconds until the key expires
   * @param value New value for key
   * @return 
   */
  public Single 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
   * @param pattern Pattern string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient psubscribe(String pattern, Handler> handler) { 
    delegate.psubscribe(pattern, handler);
    return this;
  }

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

  /**
   * Listen for messages published to channels matching the given pattern
   * @param pattern Pattern string
   * @return 
   */
  public Single 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
   * @param patterns List of patterns
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient psubscribeMany(List patterns, Handler> handler) { 
    delegate.psubscribeMany(patterns, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.pubsubChannels(pattern, handler);
    return this;
  }

    /**
   * 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 pubsubChannelsObservable(String pattern) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pubsubChannels(pattern, handler.toHandler());
    return handler;
  }

  /**
   * 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 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
   * @param channels List of channels
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pubsubNumsub(List channels, Handler> handler) { 
    delegate.pubsubNumsub(channels, handler);
    return this;
  }

    /**
   * 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 pubsubNumsubObservable(List channels) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param channels List of channels
   * @return 
   */
  public Single rxPubsubNumsub(List 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)
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient pubsubNumpat(Handler> handler) { 
    delegate.pubsubNumpat(handler);
    return this;
  }

    /**
   * Returns the number of subscriptions to patterns (that are performed using the PSUBSCRIBE command)
   * @return 
   * @deprecated use {@link #rxPubsubNumpat} instead
   */
  @Deprecated()
  public Observable pubsubNumpatObservable() { 
    io.vertx.rx.java.ObservableFuture 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)
   * @return 
   */
  public Single rxPubsubNumpat() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pubsubNumpat(fut);
    }));
  }

  /**
   * 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> handler) { 
    delegate.pttl(key, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.publish(channel, message, handler);
    return this;
  }

    /**
   * 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 publishObservable(String channel, String message) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    publish(channel, message, handler.toHandler());
    return handler;
  }

  /**
   * Post a message to a channel
   * @param channel Channel key
   * @param message Message to send to channel
   * @return 
   */
  public Single 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
   * @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 patterns, Handler> handler) { 
    delegate.punsubscribe(patterns, handler);
    return this;
  }

    /**
   * 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 punsubscribeObservable(List patterns) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    punsubscribe(patterns, handler.toHandler());
    return handler;
  }

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

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

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

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

  /**
   * 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> handler) { 
    delegate.rename(key, newkey, handler);
    return this;
  }

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

  /**
   * Rename a key
   * @param key Key string to be renamed
   * @param newkey New key string
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.renamenx(key, newkey, handler);
    return this;
  }

    /**
   * 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 renamenxObservable(String key, String newkey) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string to be renamed
   * @param newkey New key string
   * @return 
   */
  public Single 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.
   * @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> handler) { 
    delegate.restore(key, millis, serialized, handler);
    return this;
  }

    /**
   * 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 restoreObservable(String key, long millis, String serialized) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @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 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
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient role(Handler> handler) { 
    delegate.role(handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.rpop(key, handler);
    return this;
  }

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

  /**
   * Remove and get the last element in a list
   * @param key Key string
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.rpoplpush(key, destkey, handler);
    return this;
  }

    /**
   * 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 rpoplpushObservable(String key, String destkey) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string identifying source list
   * @param destkey Key string identifying destination list
   * @return 
   */
  public Single 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
   * @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 values, Handler> handler) { 
    delegate.rpushMany(key, values, handler);
    return this;
  }

    /**
   * 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 rpushManyObservable(String key, List values) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    rpushMany(key, values, handler.toHandler());
    return handler;
  }

  /**
   * 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 rxRpushMany(String key, List values) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rpushMany(key, values, fut);
    }));
  }

  /**
   * 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> handler) { 
    delegate.rpush(key, value, handler);
    return this;
  }

    /**
   * 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 rpushObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    rpush(key, value, handler.toHandler());
    return handler;
  }

  /**
   * 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 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
   * @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> handler) { 
    delegate.rpushx(key, value, handler);
    return this;
  }

    /**
   * 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 rpushxObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param value Value to be added to the end of the list
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.sadd(key, member, handler);
    return this;
  }

    /**
   * 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 saddObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sadd(key, member, handler.toHandler());
    return handler;
  }

  /**
   * Add a member to a set
   * @param key Key string
   * @param member Value to be added to the set
   * @return 
   */
  public Single 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
   * @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 members, Handler> handler) { 
    delegate.saddMany(key, members, handler);
    return this;
  }

    /**
   * 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 saddManyObservable(String key, List members) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    saddMany(key, members, handler.toHandler());
    return handler;
  }

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

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

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

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

  /**
   * 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> handler) { 
    delegate.scard(key, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.scriptExists(script, handler);
    return this;
  }

    /**
   * 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 scriptExistsObservable(String script) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    scriptExists(script, handler.toHandler());
    return handler;
  }

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

  /**
   * 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 scripts, Handler> handler) { 
    delegate.scriptExistsMany(scripts, handler);
    return this;
  }

    /**
   * 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 scriptExistsManyObservable(List scripts) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    scriptExistsMany(scripts, handler.toHandler());
    return handler;
  }

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

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

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

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

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

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

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

  /**
   * 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> handler) { 
    delegate.scriptLoad(script, handler);
    return this;
  }

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

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

  /**
   * 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 cmpkeys, Handler> handler) { 
    delegate.sdiff(key, cmpkeys, handler);
    return this;
  }

    /**
   * 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 sdiffObservable(String key, List cmpkeys) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sdiff(key, cmpkeys, handler.toHandler());
    return handler;
  }

  /**
   * 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 rxSdiff(String key, List 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
   * @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 cmpkeys, Handler> handler) { 
    delegate.sdiffstore(destkey, key, cmpkeys, handler);
    return this;
  }

    /**
   * 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 sdiffstoreObservable(String destkey, String key, List cmpkeys) { 
    io.vertx.rx.java.ObservableFuture 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
   * @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 rxSdiffstore(String destkey, String key, List cmpkeys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sdiffstore(destkey, key, cmpkeys, fut);
    }));
  }

  /**
   * 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> handler) { 
    delegate.select(dbindex, handler);
    return this;
  }

    /**
   * 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 selectObservable(int dbindex) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    select(dbindex, handler.toHandler());
    return handler;
  }

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

  /**
   * 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> handler) { 
    delegate.set(key, value, handler);
    return this;
  }

    /**
   * 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 setObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    set(key, value, handler.toHandler());
    return handler;
  }

  /**
   * 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 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
   * @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, io.vertx.redis.op.SetOptions options, Handler> handler) { 
    delegate.setWithOptions(key, value, options, handler);
    return this;
  }

    /**
   * 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 setWithOptionsObservable(String key, String value, io.vertx.redis.op.SetOptions options) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    setWithOptions(key, value, options, handler.toHandler());
    return handler;
  }

  /**
   * 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 rxSetWithOptions(String key, String value, io.vertx.redis.op.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
   * @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> handler) { 
    delegate.setBinary(key, value.getDelegate(), handler);
    return this;
  }

    /**
   * 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 setBinaryObservable(String key, io.vertx.rxjava.core.buffer.Buffer value) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key of which value to set
   * @param value New value for the key
   * @return 
   */
  public Single 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
   * @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, io.vertx.redis.op.SetOptions options, Handler> handler) { 
    delegate.setBinaryWithOptions(key, value.getDelegate(), options, handler);
    return this;
  }

    /**
   * 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 setBinaryWithOptionsObservable(String key, io.vertx.rxjava.core.buffer.Buffer value, io.vertx.redis.op.SetOptions options) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    setBinaryWithOptions(key, value, options, handler.toHandler());
    return handler;
  }

  /**
   * 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 rxSetBinaryWithOptions(String key, io.vertx.rxjava.core.buffer.Buffer value, io.vertx.redis.op.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
   * @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> handler) { 
    delegate.setbit(key, offset, bit, handler);
    return this;
  }

    /**
   * 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 setbitObservable(String key, long offset, int bit) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param offset Bit offset
   * @param bit New value - must be 1 or 0
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.setex(key, seconds, value, handler);
    return this;
  }

    /**
   * 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 setexObservable(String key, long seconds, String value) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    setex(key, seconds, value, handler.toHandler());
    return handler;
  }

  /**
   * 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 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
   * @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> handler) { 
    delegate.setnx(key, value, handler);
    return this;
  }

    /**
   * 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 setnxObservable(String key, String value) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key of which value to set
   * @param value New value for the key
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.setrange(key, offset, value, handler);
    return this;
  }

    /**
   * 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 setrangeObservable(String key, int offset, String value) { 
    io.vertx.rx.java.ObservableFuture 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
   * @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 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
   * @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 keys, Handler> handler) { 
    delegate.sinter(keys, handler);
    return this;
  }

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

  /**
   * Intersect multiple sets
   * @param keys List of keys to perform intersection on
   * @return 
   */
  public Single rxSinter(List 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
   * @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 keys, Handler> handler) { 
    delegate.sinterstore(destkey, keys, handler);
    return this;
  }

    /**
   * 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 sinterstoreObservable(String destkey, List keys) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param destkey Key where to store the results
   * @param keys List of keys to perform intersection on
   * @return 
   */
  public Single rxSinterstore(String destkey, List 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
   * @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> handler) { 
    delegate.sismember(key, member, handler);
    return this;
  }

    /**
   * 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 sismemberObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param member Member to look for
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.slaveof(host, port, handler);
    return this;
  }

    /**
   * 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 slaveofObservable(String host, int port) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    slaveof(host, port, handler.toHandler());
    return handler;
  }

  /**
   * 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 rxSlaveof(String host, int port) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      slaveof(host, port, fut);
    }));
  }

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

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

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

  /**
   * 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> handler) { 
    delegate.slowlogGet(limit, handler);
    return this;
  }

    /**
   * 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 slowlogGetObservable(int limit) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    slowlogGet(limit, handler.toHandler());
    return handler;
  }

  /**
   * 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 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
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient slowlogLen(Handler> handler) { 
    delegate.slowlogLen(handler);
    return this;
  }

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

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

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

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

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

  /**
   * 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> handler) { 
    delegate.smembers(key, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.smove(key, destkey, member, handler);
    return this;
  }

    /**
   * 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 smoveObservable(String key, String destkey, String member) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    smove(key, destkey, member, handler.toHandler());
    return handler;
  }

  /**
   * 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 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
   * @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, io.vertx.redis.op.SortOptions options, Handler> handler) { 
    delegate.sort(key, options, handler);
    return this;
  }

    /**
   * 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 sortObservable(String key, io.vertx.redis.op.SortOptions options) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sort(key, options, handler.toHandler());
    return handler;
  }

  /**
   * Sort the elements in a list, set or sorted set
   * @param key Key string
   * @param options Sort options
   * @return 
   */
  public Single rxSort(String key, io.vertx.redis.op.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
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient spop(String key, Handler> handler) { 
    delegate.spop(key, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.spopMany(key, count, handler);
    return this;
  }

    /**
   * 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 spopManyObservable(String key, int count) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    spopMany(key, count, handler.toHandler());
    return handler;
  }

  /**
   * Remove and return random members from a set
   * @param key Key string
   * @param count Number of members to remove
   * @return 
   */
  public Single 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
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient srandmember(String key, Handler> handler) { 
    delegate.srandmember(key, handler);
    return this;
  }

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

  /**
   * Get one or multiple random members from a set
   * @param key Key string
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.srandmemberCount(key, count, handler);
    return this;
  }

    /**
   * 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 srandmemberCountObservable(String key, int count) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    srandmemberCount(key, count, handler.toHandler());
    return handler;
  }

  /**
   * Get one or multiple random members from a set
   * @param key Key string
   * @param count Number of members to get
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.srem(key, member, handler);
    return this;
  }

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

  /**
   * Remove one member from a set
   * @param key Key string
   * @param member Member to remove
   * @return 
   */
  public Single 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
   * @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 members, Handler> handler) { 
    delegate.sremMany(key, members, handler);
    return this;
  }

    /**
   * 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 sremManyObservable(String key, List members) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sremMany(key, members, handler.toHandler());
    return handler;
  }

  /**
   * Remove one or more members from a set
   * @param key Key string
   * @param members Members to remove
   * @return 
   */
  public Single rxSremMany(String key, List 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
   * @param key Key string
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient strlen(String key, Handler> handler) { 
    delegate.strlen(key, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.subscribe(channel, handler);
    return this;
  }

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

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

  /**
   * 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 channels, Handler> handler) { 
    delegate.subscribeMany(channels, handler);
    return this;
  }

    /**
   * 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 subscribeManyObservable(List channels) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    subscribeMany(channels, handler.toHandler());
    return handler;
  }

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

  /**
   * 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 keys, Handler> handler) { 
    delegate.sunion(keys, handler);
    return this;
  }

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

  /**
   * Add multiple sets
   * @param keys List of keys identifying sets to add up
   * @return 
   */
  public Single rxSunion(List 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
   * @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 keys, Handler> handler) { 
    delegate.sunionstore(destkey, keys, handler);
    return this;
  }

    /**
   * 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 sunionstoreObservable(String destkey, List keys) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param destkey Destination key
   * @param keys List of keys identifying sets to add up
   * @return 
   */
  public Single rxSunionstore(String destkey, List keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sunionstore(destkey, keys, fut);
    }));
  }

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

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

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

  /**
   * Return the current server time
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient time(Handler> handler) { 
    delegate.time(handler);
    return this;
  }

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

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

  /**
   * 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((io.vertx.redis.RedisTransaction)delegate.transaction());
    return ret;
  }

  /**
   * 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> handler) { 
    delegate.ttl(key, handler);
    return this;
  }

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

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

  /**
   * 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> handler) { 
    delegate.type(key, handler);
    return this;
  }

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

  /**
   * Determine the type stored at key
   * @param key Key string
   * @return 
   */
  public Single 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
   * @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 channels, Handler> handler) { 
    delegate.unsubscribe(channels, handler);
    return this;
  }

    /**
   * 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 unsubscribeObservable(List channels) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    unsubscribe(channels, handler.toHandler());
    return handler;
  }

  /**
   * Stop listening for messages posted to the given channels
   * @param channels List of channels to subscribe to
   * @return 
   */
  public Single rxUnsubscribe(List 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.
   * @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> 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.
   * @param numSlaves 
   * @param timeout 
   * @return 
   * @deprecated use {@link #rxWait} instead
   */
  @Deprecated()
  public Observable waitObservable(long numSlaves, long timeout) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param numSlaves 
   * @param timeout 
   * @return 
   */
  public Single 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
   * @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> 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
   * @param key Key string
   * @param score Score used for sorting
   * @param member New member key
   * @return 
   * @deprecated use {@link #rxZadd} instead
   */
  @Deprecated()
  public Observable zaddObservable(String key, double score, String member) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param score Score used for sorting
   * @param member New member key
   * @return 
   */
  public Single 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
   * @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, java.util.Map members, Handler> 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
   * @param key Key string
   * @param members New member keys and their scores
   * @return 
   * @deprecated use {@link #rxZaddMany} instead
   */
  @Deprecated()
  public Observable zaddManyObservable(String key, java.util.Map members) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param members New member keys and their scores
   * @return 
   */
  public Single rxZaddMany(String key, java.util.Map members) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zaddMany(key, members, fut);
    }));
  }

  /**
   * 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> handler) { 
    delegate.zcard(key, handler);
    return this;
  }

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

  /**
   * Get the number of members in a sorted set
   * @param key Key string
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.zcount(key, min, max, handler);
    return this;
  }

    /**
   * 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 zcountObservable(String key, double min, double max) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param min Minimum score
   * @param max Maximum score
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.zincrby(key, increment, member, handler);
    return this;
  }

    /**
   * 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 zincrbyObservable(String key, double increment, String member) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param increment Increment amount
   * @param member Member key
   * @return 
   */
  public Single 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
   * @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 sets, io.vertx.redis.op.AggregateOptions options, Handler> handler) { 
    delegate.zinterstore(destkey, sets, options, handler);
    return this;
  }

    /**
   * 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 zinterstoreObservable(String destkey, List sets, io.vertx.redis.op.AggregateOptions options) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets to intersect
   * @param options Aggregation options
   * @return 
   */
  public Single rxZinterstore(String destkey, List sets, io.vertx.redis.op.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
   * @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, java.util.Map sets, io.vertx.redis.op.AggregateOptions options, Handler> 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
   * @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 zinterstoreWeighedObservable(String destkey, java.util.Map sets, io.vertx.redis.op.AggregateOptions options) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets to intersect
   * @param options Aggregation options
   * @return 
   */
  public Single rxZinterstoreWeighed(String destkey, java.util.Map sets, io.vertx.redis.op.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
   * @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> handler) { 
    delegate.zlexcount(key, min, max, handler);
    return this;
  }

    /**
   * 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 zlexcountObservable(String key, String min, String max) { 
    io.vertx.rx.java.ObservableFuture 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
   * @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 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
   * @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> handler) { 
    delegate.zrange(key, start, stop, handler);
    return this;
  }

    /**
   * 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 zrangeObservable(String key, long start, long stop) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param start Start index for the range
   * @param stop Stop index for the range - inclusive
   * @return 
   */
  public Single 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
   * @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, io.vertx.redis.op.RangeOptions options, Handler> handler) { 
    delegate.zrangeWithOptions(key, start, stop, options, handler);
    return this;
  }

    /**
   * 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 zrangeWithOptionsObservable(String key, long start, long stop, io.vertx.redis.op.RangeOptions options) { 
    io.vertx.rx.java.ObservableFuture 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
   * @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 rxZrangeWithOptions(String key, long start, long stop, io.vertx.redis.op.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
   * @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, io.vertx.redis.op.LimitOptions options, Handler> handler) { 
    delegate.zrangebylex(key, min, max, options, handler);
    return this;
  }

    /**
   * 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 zrangebylexObservable(String key, String min, String max, io.vertx.redis.op.LimitOptions options) { 
    io.vertx.rx.java.ObservableFuture 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
   * @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 rxZrangebylex(String key, String min, String max, io.vertx.redis.op.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
   * @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, io.vertx.redis.op.RangeLimitOptions options, Handler> handler) { 
    delegate.zrangebyscore(key, min, max, options, handler);
    return this;
  }

    /**
   * 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 zrangebyscoreObservable(String key, String min, String max, io.vertx.redis.op.RangeLimitOptions options) { 
    io.vertx.rx.java.ObservableFuture 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
   * @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 rxZrangebyscore(String key, String min, String max, io.vertx.redis.op.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
   * @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> handler) { 
    delegate.zrank(key, member, handler);
    return this;
  }

    /**
   * 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 zrankObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrank(key, member, handler.toHandler());
    return handler;
  }

  /**
   * 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 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
   * @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> handler) { 
    delegate.zrem(key, member, handler);
    return this;
  }

    /**
   * 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 zremObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrem(key, member, handler.toHandler());
    return handler;
  }

  /**
   * Remove one member from a sorted set
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   */
  public Single 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
   * @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 members, Handler> handler) { 
    delegate.zremMany(key, members, handler);
    return this;
  }

    /**
   * 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 zremManyObservable(String key, List members) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zremMany(key, members, handler.toHandler());
    return handler;
  }

  /**
   * 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 rxZremMany(String key, List 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
   * @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> handler) { 
    delegate.zremrangebylex(key, min, max, handler);
    return this;
  }

    /**
   * 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 zremrangebylexObservable(String key, String min, String max) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param min Pattern defining a minimum value
   * @param max Pattern defining a maximum value
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.zremrangebyrank(key, start, stop, handler);
    return this;
  }

    /**
   * 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 zremrangebyrankObservable(String key, long start, long stop) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param start Start index
   * @param stop Stop index
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.zremrangebyscore(key, min, max, handler);
    return this;
  }

    /**
   * 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 zremrangebyscoreObservable(String key, String min, String max) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param min Pattern defining a minimum value
   * @param max Pattern defining a maximum value
   * @return 
   */
  public Single 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
   * @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, io.vertx.redis.op.RangeOptions options, Handler> 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
   * @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 zrevrangeObservable(String key, long start, long stop, io.vertx.redis.op.RangeOptions options) { 
    io.vertx.rx.java.ObservableFuture 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
   * @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 rxZrevrange(String key, long start, long stop, io.vertx.redis.op.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
   * @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, io.vertx.redis.op.LimitOptions options, Handler> 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
   * @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 zrevrangebylexObservable(String key, String max, String min, io.vertx.redis.op.LimitOptions options) { 
    io.vertx.rx.java.ObservableFuture 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
   * @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 rxZrevrangebylex(String key, String max, String min, io.vertx.redis.op.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
   * @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, io.vertx.redis.op.RangeLimitOptions options, Handler> 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
   * @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 zrevrangebyscoreObservable(String key, String max, String min, io.vertx.redis.op.RangeLimitOptions options) { 
    io.vertx.rx.java.ObservableFuture 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
   * @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 rxZrevrangebyscore(String key, String max, String min, io.vertx.redis.op.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
   * @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> 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
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   * @deprecated use {@link #rxZrevrank} instead
   */
  @Deprecated()
  public Observable zrevrankObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   */
  public Single 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
   * @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> handler) { 
    delegate.zscore(key, member, handler);
    return this;
  }

    /**
   * 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 zscoreObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Key string
   * @param member Member in the sorted set identified by key
   * @return 
   */
  public Single 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
   * @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 sets, io.vertx.redis.op.AggregateOptions options, Handler> handler) { 
    delegate.zunionstore(destkey, sets, options, handler);
    return this;
  }

    /**
   * 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 zunionstoreObservable(String destkey, List sets, io.vertx.redis.op.AggregateOptions options) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param destkey Destination key
   * @param sets List of keys identifying sorted sets
   * @param options Aggregation options
   * @return 
   */
  public Single rxZunionstore(String destkey, List sets, io.vertx.redis.op.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
   * @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, java.util.Map sets, io.vertx.redis.op.AggregateOptions options, Handler> 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
   * @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 zunionstoreWeighedObservable(String key, java.util.Map sets, io.vertx.redis.op.AggregateOptions options) { 
    io.vertx.rx.java.ObservableFuture 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
   * @param key Destination key
   * @param sets Map containing set-key:weight pairs
   * @param options Aggregation options
   * @return 
   */
  public Single rxZunionstoreWeighed(String key, java.util.Map sets, io.vertx.redis.op.AggregateOptions options) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zunionstoreWeighed(key, sets, options, fut);
    }));
  }

  /**
   * 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, io.vertx.redis.op.ScanOptions options, Handler> handler) { 
    delegate.scan(cursor, options, handler);
    return this;
  }

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

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

  /**
   * 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, io.vertx.redis.op.ScanOptions options, Handler> handler) { 
    delegate.sscan(key, cursor, options, handler);
    return this;
  }

    /**
   * 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 sscanObservable(String key, String cursor, io.vertx.redis.op.ScanOptions options) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sscan(key, cursor, options, handler.toHandler());
    return handler;
  }

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

  /**
   * 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, io.vertx.redis.op.ScanOptions options, Handler> handler) { 
    delegate.hscan(key, cursor, options, handler);
    return this;
  }

    /**
   * 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 hscanObservable(String key, String cursor, io.vertx.redis.op.ScanOptions options) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hscan(key, cursor, options, handler.toHandler());
    return handler;
  }

  /**
   * Incrementally iterate hash fields and associated values
   * @param key Key string
   * @param cursor Cursor id
   * @param options Scan options
   * @return 
   */
  public Single rxHscan(String key, String cursor, io.vertx.redis.op.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
   * @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, io.vertx.redis.op.ScanOptions options, Handler> handler) { 
    delegate.zscan(key, cursor, options, handler);
    return this;
  }

    /**
   * 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 zscanObservable(String key, String cursor, io.vertx.redis.op.ScanOptions options) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zscan(key, cursor, options, handler.toHandler());
    return handler;
  }

  /**
   * Incrementally iterate sorted sets elements and associated scores
   * @param key Key string
   * @param cursor Cursor id
   * @param options Scan options
   * @return 
   */
  public Single rxZscan(String key, String cursor, io.vertx.redis.op.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.
   * @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> 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.
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param member member
   * @return 
   * @deprecated use {@link #rxGeoadd} instead
   */
  @Deprecated()
  public Observable geoaddObservable(String key, double longitude, double latitude, String member) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param member member
   * @return 
   */
  public Single 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.
   * @param key Key string
   * @param members list of <lon, lat, member>
   * @param handler Handler for the result of this call.
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient geoaddMany(String key, List members, Handler> handler) { 
    delegate.geoaddMany(key, members, handler);
    return this;
  }

    /**
   * Add one or more geospatial items in the geospatial index represented using a sorted set.
   * @param key Key string
   * @param members list of <lon, lat, member>
   * @return 
   * @deprecated use {@link #rxGeoaddMany} instead
   */
  @Deprecated()
  public Observable geoaddManyObservable(String key, List members) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key string
   * @param members list of <lon, lat, member>
   * @return 
   */
  public Single rxGeoaddMany(String key, List 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).
   * @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> 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).
   * @param key Key string
   * @param member member
   * @return 
   * @deprecated use {@link #rxGeohash} instead
   */
  @Deprecated()
  public Observable geohashObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture 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).
   * @param key Key string
   * @param member member
   * @return 
   */
  public Single 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).
   * @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 members, Handler> 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).
   * @param key Key string
   * @param members list of members
   * @return 
   * @deprecated use {@link #rxGeohashMany} instead
   */
  @Deprecated()
  public Observable geohashManyObservable(String key, List members) { 
    io.vertx.rx.java.ObservableFuture 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).
   * @param key Key string
   * @param members list of members
   * @return 
   */
  public Single rxGeohashMany(String key, List 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.
   * @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> 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.
   * @param key Key string
   * @param member member
   * @return 
   * @deprecated use {@link #rxGeopos} instead
   */
  @Deprecated()
  public Observable geoposObservable(String key, String member) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key string
   * @param member member
   * @return 
   */
  public Single 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.
   * @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 members, Handler> 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.
   * @param key Key string
   * @param members list of members
   * @return 
   * @deprecated use {@link #rxGeoposMany} instead
   */
  @Deprecated()
  public Observable geoposManyObservable(String key, List members) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key string
   * @param members list of members
   * @return 
   */
  public Single rxGeoposMany(String key, List 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.
   * @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> handler) { 
    delegate.geodist(key, member1, member2, handler);
    return this;
  }

    /**
   * 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 geodistObservable(String key, String member1, String member2) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key string
   * @param member1 member 1
   * @param member2 member 2
   * @return 
   */
  public Single 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.
   * @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, io.vertx.redis.op.GeoUnit unit, Handler> 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.
   * @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 geodistWithUnitObservable(String key, String member1, String member2, io.vertx.redis.op.GeoUnit unit) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key string
   * @param member1 member 1
   * @param member2 member 2
   * @param unit geo unit
   * @return 
   */
  public Single rxGeodistWithUnit(String key, String member1, String member2, io.vertx.redis.op.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).
   * @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, io.vertx.redis.op.GeoUnit unit, Handler> 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).
   * @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 georadiusObservable(String key, double longitude, double latitude, double radius, io.vertx.redis.op.GeoUnit unit) { 
    io.vertx.rx.java.ObservableFuture 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).
   * @param key Key string
   * @param longitude longitude
   * @param latitude latitude
   * @param radius radius
   * @param unit geo unit
   * @return 
   */
  public Single rxGeoradius(String key, double longitude, double latitude, double radius, io.vertx.redis.op.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).
   * @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, io.vertx.redis.op.GeoUnit unit, io.vertx.redis.op.GeoRadiusOptions options, Handler> 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).
   * @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 georadiusWithOptionsObservable(String key, double longitude, double latitude, double radius, io.vertx.redis.op.GeoUnit unit, io.vertx.redis.op.GeoRadiusOptions options) { 
    io.vertx.rx.java.ObservableFuture 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).
   * @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 rxGeoradiusWithOptions(String key, double longitude, double latitude, double radius, io.vertx.redis.op.GeoUnit unit, io.vertx.redis.op.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.
   * @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, io.vertx.redis.op.GeoUnit unit, Handler> 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.
   * @param key Key string
   * @param member member
   * @param radius radius
   * @param unit geo unit
   * @return 
   * @deprecated use {@link #rxGeoradiusbymember} instead
   */
  @Deprecated()
  public Observable georadiusbymemberObservable(String key, String member, double radius, io.vertx.redis.op.GeoUnit unit) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key string
   * @param member member
   * @param radius radius
   * @param unit geo unit
   * @return 
   */
  public Single rxGeoradiusbymember(String key, String member, double radius, io.vertx.redis.op.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.
   * @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, io.vertx.redis.op.GeoUnit unit, io.vertx.redis.op.GeoRadiusOptions options, Handler> 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.
   * @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 georadiusbymemberWithOptionsObservable(String key, String member, double radius, io.vertx.redis.op.GeoUnit unit, io.vertx.redis.op.GeoRadiusOptions options) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key string
   * @param member member
   * @param radius radius
   * @param unit geo unit
   * @param options geo radius options
   * @return 
   */
  public Single rxGeoradiusbymemberWithOptions(String key, String member, double radius, io.vertx.redis.op.GeoUnit unit, io.vertx.redis.op.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.
   * @param options 
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient clientReply(io.vertx.redis.op.ClientReplyOptions options, Handler> handler) { 
    delegate.clientReply(options, handler);
    return this;
  }

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

  /**
   * Instruct the server whether to reply to commands.
   * @param options 
   * @return 
   */
  public Single rxClientReply(io.vertx.redis.op.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.
   * @param key Key String
   * @param field field
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient hstrlen(String key, String field, Handler> handler) { 
    delegate.hstrlen(key, field, handler);
    return this;
  }

    /**
   * 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 hstrlenObservable(String key, String field) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hstrlen(key, field, handler.toHandler());
    return handler;
  }

  /**
   * Get the length of the value of a hash field.
   * @param key Key String
   * @param field field
   * @return 
   */
  public Single 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.
   * @param key Key String
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient touch(String key, Handler> handler) { 
    delegate.touch(key, handler);
    return this;
  }

    /**
   * 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 touchObservable(String key) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key String
   * @return 
   */
  public Single 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.
   * @param keys list of keys
   * @param handler 
   * @return 
   */
  public io.vertx.rxjava.redis.RedisClient touchMany(List keys, Handler> handler) { 
    delegate.touchMany(keys, handler);
    return this;
  }

    /**
   * 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 touchManyObservable(List keys) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param keys list of keys
   * @return 
   */
  public Single rxTouchMany(List keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      touchMany(keys, fut);
    }));
  }

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

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

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

  /**
   * 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, io.vertx.redis.op.BitFieldOptions bitFieldOptions, Handler> handler) { 
    delegate.bitfield(key, bitFieldOptions, handler);
    return this;
  }

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

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

  /**
   * 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, io.vertx.redis.op.BitFieldOptions commands, io.vertx.redis.op.BitFieldOverflowOptions overflow, Handler> handler) { 
    delegate.bitfieldWithOverflow(key, commands, overflow, handler);
    return this;
  }

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

  /**
   * Perform arbitrary bitfield integer operations on strings.
   * @param key Key string
   * @param commands 
   * @param overflow 
   * @return 
   */
  public Single rxBitfieldWithOverflow(String key, io.vertx.redis.op.BitFieldOptions commands, io.vertx.redis.op.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.
   * @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> handler) { 
    delegate.unlink(key, handler);
    return this;
  }

    /**
   * 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 unlinkObservable(String key) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param key Key to delete
   * @return 
   */
  public Single 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.
   * @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 keys, Handler> handler) { 
    delegate.unlinkMany(keys, handler);
    return this;
  }

    /**
   * 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 unlinkManyObservable(List keys) { 
    io.vertx.rx.java.ObservableFuture 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.
   * @param keys List of keys to delete
   * @return 
   */
  public Single rxUnlinkMany(List keys) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      unlinkMany(keys, fut);
    }));
  }

  /**
   * 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> handler) { 
    delegate.swapdb(index1, index2, handler);
    return this;
  }

    /**
   * 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 swapdbObservable(int index1, int index2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    swapdb(index1, index2, handler.toHandler());
    return handler;
  }

  /**
   * Swaps two Redis databases
   * @param index1 index of first database to swap
   * @param index2 index of second database to swap
   * @return 
   */
  public Single 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;
  }

}