All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • io.vertx.rxjava.redis.client.RedisAPI Maven / Gradle / Ivy

    /*
 * 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.client;

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;

/**
 * Auto generated Redis API client wrapper.
 *
 * 
    
 * NOTE: This class has been automatically generated from the {@link io.vertx.redis.client.RedisAPI original} non RX-ified interface using Vert.x codegen.
 */

@RxGen(io.vertx.redis.client.RedisAPI.class)
public class RedisAPI {

  @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;
    RedisAPI that = (RedisAPI) o;
    return delegate.equals(that.delegate);
  }
  
  @Override
  public int hashCode() {
    return delegate.hashCode();
  }

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

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

  public RedisAPI(Object delegate) {
    this.delegate = (io.vertx.redis.client.RedisAPI)delegate;
  }

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

  public void close() { 
    delegate.close();
  }

  /**
   * Redis command append.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI append(String arg0, String arg1, Handler> handler) { 
    delegate.append(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command append.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxAppend} instead
   */
  @Deprecated()
  public Observable appendObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    append(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command append.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxAppend(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      append(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command asking.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI asking(Handler> handler) { 
    delegate.asking(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command asking.
   * @return fluent self
   * @deprecated use {@link #rxAsking} instead
   */
  @Deprecated()
  public Observable askingObservable() { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    asking(handler.toHandler());
    return handler;
  }

  /**
   * Redis command asking.
   * @return fluent self
   */
  public Single rxAsking() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      asking(fut);
    }));
  }

  /**
   * Redis command auth.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI auth(String arg0, Handler> handler) { 
    delegate.auth(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command auth.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxAuth} instead
   */
  @Deprecated()
  public Observable authObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    auth(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command auth.
   * @param arg0 
   * @return fluent self
   */
  public Single rxAuth(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      auth(arg0, fut);
    }));
  }

  /**
   * Redis command bgrewriteaof.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bgrewriteaof(Handler> handler) { 
    delegate.bgrewriteaof(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command bgrewriteaof.
   * @return fluent self
   * @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;
  }

  /**
   * Redis command bgrewriteaof.
   * @return fluent self
   */
  public Single rxBgrewriteaof() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bgrewriteaof(fut);
    }));
  }

  /**
   * Redis command bgsave.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bgsave(List args, Handler> handler) { 
    delegate.bgsave(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command bgsave.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxBgsave} instead
   */
  @Deprecated()
  public Observable bgsaveObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    bgsave(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command bgsave.
   * @param args 
   * @return fluent self
   */
  public Single rxBgsave(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bgsave(args, fut);
    }));
  }

  /**
   * Redis command bitcount.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitcount(List args, Handler> handler) { 
    delegate.bitcount(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command bitcount.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxBitcount} instead
   */
  @Deprecated()
  public Observable bitcountObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitcount(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command bitcount.
   * @param args 
   * @return fluent self
   */
  public Single rxBitcount(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitcount(args, fut);
    }));
  }

  /**
   * Redis command bitfield.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitfield(List args, Handler> handler) { 
    delegate.bitfield(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command bitfield.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxBitfield} instead
   */
  @Deprecated()
  public Observable bitfieldObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitfield(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command bitfield.
   * @param args 
   * @return fluent self
   */
  public Single rxBitfield(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitfield(args, fut);
    }));
  }

  /**
   * Redis command bitop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitop(List args, Handler> handler) { 
    delegate.bitop(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command bitop.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxBitop} instead
   */
  @Deprecated()
  public Observable bitopObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitop(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command bitop.
   * @param args 
   * @return fluent self
   */
  public Single rxBitop(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitop(args, fut);
    }));
  }

  /**
   * Redis command bitpos.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitpos(List args, Handler> handler) { 
    delegate.bitpos(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command bitpos.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxBitpos} instead
   */
  @Deprecated()
  public Observable bitposObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    bitpos(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command bitpos.
   * @param args 
   * @return fluent self
   */
  public Single rxBitpos(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bitpos(args, fut);
    }));
  }

  /**
   * Redis command blpop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI blpop(List args, Handler> handler) { 
    delegate.blpop(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command blpop.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxBlpop} instead
   */
  @Deprecated()
  public Observable blpopObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    blpop(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command blpop.
   * @param args 
   * @return fluent self
   */
  public Single rxBlpop(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      blpop(args, fut);
    }));
  }

  /**
   * Redis command brpop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI brpop(List args, Handler> handler) { 
    delegate.brpop(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command brpop.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxBrpop} instead
   */
  @Deprecated()
  public Observable brpopObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    brpop(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command brpop.
   * @param args 
   * @return fluent self
   */
  public Single rxBrpop(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      brpop(args, fut);
    }));
  }

  /**
   * Redis command brpoplpush.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI brpoplpush(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.brpoplpush(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command brpoplpush.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxBrpoplpush} instead
   */
  @Deprecated()
  public Observable brpoplpushObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    brpoplpush(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command brpoplpush.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxBrpoplpush(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      brpoplpush(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command bzpopmax.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzpopmax(List args, Handler> handler) { 
    delegate.bzpopmax(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command bzpopmax.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxBzpopmax} instead
   */
  @Deprecated()
  public Observable bzpopmaxObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    bzpopmax(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command bzpopmax.
   * @param args 
   * @return fluent self
   */
  public Single rxBzpopmax(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bzpopmax(args, fut);
    }));
  }

  /**
   * Redis command bzpopmin.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzpopmin(List args, Handler> handler) { 
    delegate.bzpopmin(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command bzpopmin.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxBzpopmin} instead
   */
  @Deprecated()
  public Observable bzpopminObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    bzpopmin(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command bzpopmin.
   * @param args 
   * @return fluent self
   */
  public Single rxBzpopmin(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      bzpopmin(args, fut);
    }));
  }

  /**
   * Redis command client.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI client(List args, Handler> handler) { 
    delegate.client(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command client.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxClient} instead
   */
  @Deprecated()
  public Observable clientObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    client(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command client.
   * @param args 
   * @return fluent self
   */
  public Single rxClient(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      client(args, fut);
    }));
  }

  /**
   * Redis command cluster.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cluster(List args, Handler> handler) { 
    delegate.cluster(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command cluster.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxCluster} instead
   */
  @Deprecated()
  public Observable clusterObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    cluster(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command cluster.
   * @param args 
   * @return fluent self
   */
  public Single rxCluster(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      cluster(args, fut);
    }));
  }

  /**
   * Redis command command.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI command(Handler> handler) { 
    delegate.command(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command command.
   * @return fluent self
   * @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;
  }

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

  /**
   * Redis command config.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI config(List args, Handler> handler) { 
    delegate.config(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command config.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxConfig} instead
   */
  @Deprecated()
  public Observable configObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    config(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command config.
   * @param args 
   * @return fluent self
   */
  public Single rxConfig(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      config(args, fut);
    }));
  }

  /**
   * Redis command dbsize.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI dbsize(Handler> handler) { 
    delegate.dbsize(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command dbsize.
   * @return fluent self
   * @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;
  }

  /**
   * Redis command dbsize.
   * @return fluent self
   */
  public Single rxDbsize() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      dbsize(fut);
    }));
  }

  /**
   * Redis command debug.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI debug(List args, Handler> handler) { 
    delegate.debug(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command debug.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxDebug} instead
   */
  @Deprecated()
  public Observable debugObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    debug(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command debug.
   * @param args 
   * @return fluent self
   */
  public Single rxDebug(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      debug(args, fut);
    }));
  }

  /**
   * Redis command decr.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI decr(String arg0, Handler> handler) { 
    delegate.decr(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command decr.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxDecr} instead
   */
  @Deprecated()
  public Observable decrObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    decr(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command decr.
   * @param arg0 
   * @return fluent self
   */
  public Single rxDecr(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      decr(arg0, fut);
    }));
  }

  /**
   * Redis command decrby.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI decrby(String arg0, String arg1, Handler> handler) { 
    delegate.decrby(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command decrby.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxDecrby} instead
   */
  @Deprecated()
  public Observable decrbyObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    decrby(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command decrby.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxDecrby(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      decrby(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command del.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI del(List args, Handler> handler) { 
    delegate.del(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command del.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxDel} instead
   */
  @Deprecated()
  public Observable delObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    del(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command del.
   * @param args 
   * @return fluent self
   */
  public Single rxDel(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      del(args, fut);
    }));
  }

  /**
   * Redis command discard.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI discard(Handler> handler) { 
    delegate.discard(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command discard.
   * @return fluent self
   * @deprecated use {@link #rxDiscard} instead
   */
  @Deprecated()
  public Observable discardObservable() { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    discard(handler.toHandler());
    return handler;
  }

  /**
   * Redis command discard.
   * @return fluent self
   */
  public Single rxDiscard() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      discard(fut);
    }));
  }

  /**
   * Redis command dump.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI dump(String arg0, Handler> handler) { 
    delegate.dump(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command dump.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxDump} instead
   */
  @Deprecated()
  public Observable dumpObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    dump(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command dump.
   * @param arg0 
   * @return fluent self
   */
  public Single rxDump(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      dump(arg0, fut);
    }));
  }

  /**
   * Redis command echo.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI echo(String arg0, Handler> handler) { 
    delegate.echo(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command echo.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxEcho} instead
   */
  @Deprecated()
  public Observable echoObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    echo(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command echo.
   * @param arg0 
   * @return fluent self
   */
  public Single rxEcho(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      echo(arg0, fut);
    }));
  }

  /**
   * Redis command eval.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI eval(List args, Handler> handler) { 
    delegate.eval(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command eval.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxEval} instead
   */
  @Deprecated()
  public Observable evalObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    eval(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command eval.
   * @param args 
   * @return fluent self
   */
  public Single rxEval(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      eval(args, fut);
    }));
  }

  /**
   * Redis command evalsha.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI evalsha(List args, Handler> handler) { 
    delegate.evalsha(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command evalsha.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxEvalsha} instead
   */
  @Deprecated()
  public Observable evalshaObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    evalsha(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command evalsha.
   * @param args 
   * @return fluent self
   */
  public Single rxEvalsha(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      evalsha(args, fut);
    }));
  }

  /**
   * Redis command exec.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI exec(Handler> handler) { 
    delegate.exec(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command exec.
   * @return fluent self
   * @deprecated use {@link #rxExec} instead
   */
  @Deprecated()
  public Observable execObservable() { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    exec(handler.toHandler());
    return handler;
  }

  /**
   * Redis command exec.
   * @return fluent self
   */
  public Single rxExec() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      exec(fut);
    }));
  }

  /**
   * Redis command exists.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI exists(List args, Handler> handler) { 
    delegate.exists(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command exists.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxExists} instead
   */
  @Deprecated()
  public Observable existsObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    exists(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command exists.
   * @param args 
   * @return fluent self
   */
  public Single rxExists(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      exists(args, fut);
    }));
  }

  /**
   * Redis command expire.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expire(String arg0, String arg1, Handler> handler) { 
    delegate.expire(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command expire.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxExpire} instead
   */
  @Deprecated()
  public Observable expireObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    expire(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command expire.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxExpire(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      expire(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command expireat.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expireat(String arg0, String arg1, Handler> handler) { 
    delegate.expireat(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command expireat.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxExpireat} instead
   */
  @Deprecated()
  public Observable expireatObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    expireat(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command expireat.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxExpireat(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      expireat(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command flushall.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI flushall(List args, Handler> handler) { 
    delegate.flushall(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command flushall.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxFlushall} instead
   */
  @Deprecated()
  public Observable flushallObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    flushall(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command flushall.
   * @param args 
   * @return fluent self
   */
  public Single rxFlushall(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      flushall(args, fut);
    }));
  }

  /**
   * Redis command flushdb.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI flushdb(List args, Handler> handler) { 
    delegate.flushdb(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command flushdb.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxFlushdb} instead
   */
  @Deprecated()
  public Observable flushdbObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    flushdb(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command flushdb.
   * @param args 
   * @return fluent self
   */
  public Single rxFlushdb(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      flushdb(args, fut);
    }));
  }

  /**
   * Redis command geoadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geoadd(List args, Handler> handler) { 
    delegate.geoadd(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command geoadd.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxGeoadd} instead
   */
  @Deprecated()
  public Observable geoaddObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    geoadd(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command geoadd.
   * @param args 
   * @return fluent self
   */
  public Single rxGeoadd(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geoadd(args, fut);
    }));
  }

  /**
   * Redis command geodist.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geodist(List args, Handler> handler) { 
    delegate.geodist(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command geodist.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxGeodist} instead
   */
  @Deprecated()
  public Observable geodistObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    geodist(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command geodist.
   * @param args 
   * @return fluent self
   */
  public Single rxGeodist(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geodist(args, fut);
    }));
  }

  /**
   * Redis command geohash.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geohash(List args, Handler> handler) { 
    delegate.geohash(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command geohash.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxGeohash} instead
   */
  @Deprecated()
  public Observable geohashObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    geohash(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command geohash.
   * @param args 
   * @return fluent self
   */
  public Single rxGeohash(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geohash(args, fut);
    }));
  }

  /**
   * Redis command geopos.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geopos(List args, Handler> handler) { 
    delegate.geopos(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command geopos.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxGeopos} instead
   */
  @Deprecated()
  public Observable geoposObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    geopos(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command geopos.
   * @param args 
   * @return fluent self
   */
  public Single rxGeopos(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      geopos(args, fut);
    }));
  }

  /**
   * Redis command georadius.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadius(List args, Handler> handler) { 
    delegate.georadius(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command georadius.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxGeoradius} instead
   */
  @Deprecated()
  public Observable georadiusObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    georadius(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command georadius.
   * @param args 
   * @return fluent self
   */
  public Single rxGeoradius(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      georadius(args, fut);
    }));
  }

  /**
   * Redis command georadiusRo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusRo(List args, Handler> handler) { 
    delegate.georadiusRo(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command georadiusRo.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxGeoradiusRo} instead
   */
  @Deprecated()
  public Observable georadiusRoObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    georadiusRo(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command georadiusRo.
   * @param args 
   * @return fluent self
   */
  public Single rxGeoradiusRo(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      georadiusRo(args, fut);
    }));
  }

  /**
   * Redis command georadiusbymember.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusbymember(List args, Handler> handler) { 
    delegate.georadiusbymember(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command georadiusbymember.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxGeoradiusbymember} instead
   */
  @Deprecated()
  public Observable georadiusbymemberObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    georadiusbymember(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command georadiusbymember.
   * @param args 
   * @return fluent self
   */
  public Single rxGeoradiusbymember(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      georadiusbymember(args, fut);
    }));
  }

  /**
   * Redis command georadiusbymemberRo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusbymemberRo(List args, Handler> handler) { 
    delegate.georadiusbymemberRo(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command georadiusbymemberRo.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxGeoradiusbymemberRo} instead
   */
  @Deprecated()
  public Observable georadiusbymemberRoObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    georadiusbymemberRo(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command georadiusbymemberRo.
   * @param args 
   * @return fluent self
   */
  public Single rxGeoradiusbymemberRo(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      georadiusbymemberRo(args, fut);
    }));
  }

  /**
   * Redis command get.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI get(String arg0, Handler> handler) { 
    delegate.get(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command get.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxGet} instead
   */
  @Deprecated()
  public Observable getObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    get(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command get.
   * @param arg0 
   * @return fluent self
   */
  public Single rxGet(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      get(arg0, fut);
    }));
  }

  /**
   * Redis command getbit.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getbit(String arg0, String arg1, Handler> handler) { 
    delegate.getbit(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command getbit.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxGetbit} instead
   */
  @Deprecated()
  public Observable getbitObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    getbit(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command getbit.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxGetbit(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      getbit(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command getrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getrange(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.getrange(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command getrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxGetrange} instead
   */
  @Deprecated()
  public Observable getrangeObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    getrange(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command getrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxGetrange(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      getrange(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command getset.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getset(String arg0, String arg1, Handler> handler) { 
    delegate.getset(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command getset.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxGetset} instead
   */
  @Deprecated()
  public Observable getsetObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    getset(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command getset.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxGetset(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      getset(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command hdel.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hdel(List args, Handler> handler) { 
    delegate.hdel(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hdel.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxHdel} instead
   */
  @Deprecated()
  public Observable hdelObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hdel(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hdel.
   * @param args 
   * @return fluent self
   */
  public Single rxHdel(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hdel(args, fut);
    }));
  }

  /**
   * Redis command hexists.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hexists(String arg0, String arg1, Handler> handler) { 
    delegate.hexists(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hexists.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxHexists} instead
   */
  @Deprecated()
  public Observable hexistsObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hexists(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hexists.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxHexists(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hexists(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command hget.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hget(String arg0, String arg1, Handler> handler) { 
    delegate.hget(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hget.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxHget} instead
   */
  @Deprecated()
  public Observable hgetObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hget(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hget.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxHget(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hget(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command hgetall.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hgetall(String arg0, Handler> handler) { 
    delegate.hgetall(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hgetall.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxHgetall} instead
   */
  @Deprecated()
  public Observable hgetallObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hgetall(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hgetall.
   * @param arg0 
   * @return fluent self
   */
  public Single rxHgetall(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hgetall(arg0, fut);
    }));
  }

  /**
   * Redis command hincrby.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hincrby(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.hincrby(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hincrby.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxHincrby} instead
   */
  @Deprecated()
  public Observable hincrbyObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hincrby(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hincrby.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxHincrby(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hincrby(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command hincrbyfloat.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hincrbyfloat(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.hincrbyfloat(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hincrbyfloat.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxHincrbyfloat} instead
   */
  @Deprecated()
  public Observable hincrbyfloatObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hincrbyfloat(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hincrbyfloat.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxHincrbyfloat(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hincrbyfloat(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command hkeys.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hkeys(String arg0, Handler> handler) { 
    delegate.hkeys(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hkeys.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxHkeys} instead
   */
  @Deprecated()
  public Observable hkeysObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hkeys(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hkeys.
   * @param arg0 
   * @return fluent self
   */
  public Single rxHkeys(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hkeys(arg0, fut);
    }));
  }

  /**
   * Redis command hlen.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hlen(String arg0, Handler> handler) { 
    delegate.hlen(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hlen.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxHlen} instead
   */
  @Deprecated()
  public Observable hlenObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hlen(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hlen.
   * @param arg0 
   * @return fluent self
   */
  public Single rxHlen(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hlen(arg0, fut);
    }));
  }

  /**
   * Redis command hmget.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hmget(List args, Handler> handler) { 
    delegate.hmget(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hmget.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxHmget} instead
   */
  @Deprecated()
  public Observable hmgetObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hmget(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hmget.
   * @param args 
   * @return fluent self
   */
  public Single rxHmget(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hmget(args, fut);
    }));
  }

  /**
   * Redis command hmset.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hmset(List args, Handler> handler) { 
    delegate.hmset(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hmset.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxHmset} instead
   */
  @Deprecated()
  public Observable hmsetObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hmset(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hmset.
   * @param args 
   * @return fluent self
   */
  public Single rxHmset(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hmset(args, fut);
    }));
  }

  /**
   * Redis command host.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI host(List args, Handler> handler) { 
    delegate.host(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command host.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxHost} instead
   */
  @Deprecated()
  public Observable hostObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    host(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command host.
   * @param args 
   * @return fluent self
   */
  public Single rxHost(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      host(args, fut);
    }));
  }

  /**
   * Redis command hscan.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hscan(List args, Handler> handler) { 
    delegate.hscan(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hscan.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxHscan} instead
   */
  @Deprecated()
  public Observable hscanObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hscan(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hscan.
   * @param args 
   * @return fluent self
   */
  public Single rxHscan(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hscan(args, fut);
    }));
  }

  /**
   * Redis command hset.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hset(List args, Handler> handler) { 
    delegate.hset(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hset.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxHset} instead
   */
  @Deprecated()
  public Observable hsetObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hset(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hset.
   * @param args 
   * @return fluent self
   */
  public Single rxHset(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hset(args, fut);
    }));
  }

  /**
   * Redis command hsetnx.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hsetnx(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.hsetnx(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hsetnx.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxHsetnx} instead
   */
  @Deprecated()
  public Observable hsetnxObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hsetnx(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hsetnx.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxHsetnx(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hsetnx(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command hstrlen.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hstrlen(String arg0, String arg1, Handler> handler) { 
    delegate.hstrlen(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hstrlen.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxHstrlen} instead
   */
  @Deprecated()
  public Observable hstrlenObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hstrlen(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hstrlen.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxHstrlen(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hstrlen(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command hvals.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hvals(String arg0, Handler> handler) { 
    delegate.hvals(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command hvals.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxHvals} instead
   */
  @Deprecated()
  public Observable hvalsObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    hvals(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command hvals.
   * @param arg0 
   * @return fluent self
   */
  public Single rxHvals(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      hvals(arg0, fut);
    }));
  }

  /**
   * Redis command incr.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incr(String arg0, Handler> handler) { 
    delegate.incr(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command incr.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxIncr} instead
   */
  @Deprecated()
  public Observable incrObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    incr(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command incr.
   * @param arg0 
   * @return fluent self
   */
  public Single rxIncr(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      incr(arg0, fut);
    }));
  }

  /**
   * Redis command incrby.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incrby(String arg0, String arg1, Handler> handler) { 
    delegate.incrby(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command incrby.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxIncrby} instead
   */
  @Deprecated()
  public Observable incrbyObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    incrby(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command incrby.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxIncrby(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      incrby(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command incrbyfloat.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incrbyfloat(String arg0, String arg1, Handler> handler) { 
    delegate.incrbyfloat(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command incrbyfloat.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxIncrbyfloat} instead
   */
  @Deprecated()
  public Observable incrbyfloatObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    incrbyfloat(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command incrbyfloat.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxIncrbyfloat(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      incrbyfloat(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command info.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI info(List args, Handler> handler) { 
    delegate.info(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command info.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxInfo} instead
   */
  @Deprecated()
  public Observable infoObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    info(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command info.
   * @param args 
   * @return fluent self
   */
  public Single rxInfo(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      info(args, fut);
    }));
  }

  /**
   * Redis command keys.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI keys(String arg0, Handler> handler) { 
    delegate.keys(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command keys.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxKeys} instead
   */
  @Deprecated()
  public Observable keysObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    keys(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command keys.
   * @param arg0 
   * @return fluent self
   */
  public Single rxKeys(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      keys(arg0, fut);
    }));
  }

  /**
   * Redis command lastsave.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lastsave(Handler> handler) { 
    delegate.lastsave(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command lastsave.
   * @return fluent self
   * @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;
  }

  /**
   * Redis command lastsave.
   * @return fluent self
   */
  public Single rxLastsave() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lastsave(fut);
    }));
  }

  /**
   * Redis command latency.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI latency(List args, Handler> handler) { 
    delegate.latency(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command latency.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxLatency} instead
   */
  @Deprecated()
  public Observable latencyObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    latency(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command latency.
   * @param args 
   * @return fluent self
   */
  public Single rxLatency(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      latency(args, fut);
    }));
  }

  /**
   * Redis command lindex.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lindex(String arg0, String arg1, Handler> handler) { 
    delegate.lindex(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command lindex.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxLindex} instead
   */
  @Deprecated()
  public Observable lindexObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lindex(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command lindex.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxLindex(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lindex(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command linsert.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI linsert(String arg0, String arg1, String arg2, String arg3, Handler> handler) { 
    delegate.linsert(arg0, arg1, arg2, arg3, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command linsert.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return fluent self
   * @deprecated use {@link #rxLinsert} instead
   */
  @Deprecated()
  public Observable linsertObservable(String arg0, String arg1, String arg2, String arg3) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    linsert(arg0, arg1, arg2, arg3, handler.toHandler());
    return handler;
  }

  /**
   * Redis command linsert.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return fluent self
   */
  public Single rxLinsert(String arg0, String arg1, String arg2, String arg3) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      linsert(arg0, arg1, arg2, arg3, fut);
    }));
  }

  /**
   * Redis command llen.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI llen(String arg0, Handler> handler) { 
    delegate.llen(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command llen.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxLlen} instead
   */
  @Deprecated()
  public Observable llenObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    llen(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command llen.
   * @param arg0 
   * @return fluent self
   */
  public Single rxLlen(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      llen(arg0, fut);
    }));
  }

  /**
   * Redis command lolwut.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lolwut(List args, Handler> handler) { 
    delegate.lolwut(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command lolwut.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxLolwut} instead
   */
  @Deprecated()
  public Observable lolwutObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lolwut(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command lolwut.
   * @param args 
   * @return fluent self
   */
  public Single rxLolwut(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lolwut(args, fut);
    }));
  }

  /**
   * Redis command lpop.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpop(String arg0, Handler> handler) { 
    delegate.lpop(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command lpop.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxLpop} instead
   */
  @Deprecated()
  public Observable lpopObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lpop(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command lpop.
   * @param arg0 
   * @return fluent self
   */
  public Single rxLpop(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lpop(arg0, fut);
    }));
  }

  /**
   * Redis command lpush.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpush(List args, Handler> handler) { 
    delegate.lpush(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command lpush.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxLpush} instead
   */
  @Deprecated()
  public Observable lpushObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lpush(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command lpush.
   * @param args 
   * @return fluent self
   */
  public Single rxLpush(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lpush(args, fut);
    }));
  }

  /**
   * Redis command lpushx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpushx(List args, Handler> handler) { 
    delegate.lpushx(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command lpushx.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxLpushx} instead
   */
  @Deprecated()
  public Observable lpushxObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lpushx(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command lpushx.
   * @param args 
   * @return fluent self
   */
  public Single rxLpushx(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lpushx(args, fut);
    }));
  }

  /**
   * Redis command lrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lrange(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.lrange(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command lrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxLrange} instead
   */
  @Deprecated()
  public Observable lrangeObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lrange(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command lrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxLrange(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lrange(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command lrem.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lrem(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.lrem(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command lrem.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxLrem} instead
   */
  @Deprecated()
  public Observable lremObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lrem(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command lrem.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxLrem(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lrem(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command lset.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lset(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.lset(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command lset.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxLset} instead
   */
  @Deprecated()
  public Observable lsetObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    lset(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command lset.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxLset(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      lset(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command ltrim.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ltrim(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.ltrim(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command ltrim.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxLtrim} instead
   */
  @Deprecated()
  public Observable ltrimObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    ltrim(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command ltrim.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxLtrim(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      ltrim(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command memory.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI memory(List args, Handler> handler) { 
    delegate.memory(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command memory.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxMemory} instead
   */
  @Deprecated()
  public Observable memoryObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    memory(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command memory.
   * @param args 
   * @return fluent self
   */
  public Single rxMemory(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      memory(args, fut);
    }));
  }

  /**
   * Redis command mget.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI mget(List args, Handler> handler) { 
    delegate.mget(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command mget.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxMget} instead
   */
  @Deprecated()
  public Observable mgetObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    mget(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command mget.
   * @param args 
   * @return fluent self
   */
  public Single rxMget(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      mget(args, fut);
    }));
  }

  /**
   * Redis command migrate.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI migrate(List args, Handler> handler) { 
    delegate.migrate(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command migrate.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxMigrate} instead
   */
  @Deprecated()
  public Observable migrateObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    migrate(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command migrate.
   * @param args 
   * @return fluent self
   */
  public Single rxMigrate(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      migrate(args, fut);
    }));
  }

  /**
   * Redis command module.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI module(List args, Handler> handler) { 
    delegate.module(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command module.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxModule} instead
   */
  @Deprecated()
  public Observable moduleObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    module(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command module.
   * @param args 
   * @return fluent self
   */
  public Single rxModule(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      module(args, fut);
    }));
  }

  /**
   * Redis command monitor.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI monitor(Handler> handler) { 
    delegate.monitor(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command monitor.
   * @return fluent self
   * @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;
  }

  /**
   * Redis command monitor.
   * @return fluent self
   */
  public Single rxMonitor() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      monitor(fut);
    }));
  }

  /**
   * Redis command move.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI move(String arg0, String arg1, Handler> handler) { 
    delegate.move(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command move.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxMove} instead
   */
  @Deprecated()
  public Observable moveObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    move(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command move.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxMove(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      move(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command mset.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI mset(List args, Handler> handler) { 
    delegate.mset(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command mset.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxMset} instead
   */
  @Deprecated()
  public Observable msetObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    mset(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command mset.
   * @param args 
   * @return fluent self
   */
  public Single rxMset(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      mset(args, fut);
    }));
  }

  /**
   * Redis command msetnx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI msetnx(List args, Handler> handler) { 
    delegate.msetnx(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command msetnx.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxMsetnx} instead
   */
  @Deprecated()
  public Observable msetnxObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    msetnx(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command msetnx.
   * @param args 
   * @return fluent self
   */
  public Single rxMsetnx(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      msetnx(args, fut);
    }));
  }

  /**
   * Redis command multi.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI multi(Handler> handler) { 
    delegate.multi(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command multi.
   * @return fluent self
   * @deprecated use {@link #rxMulti} instead
   */
  @Deprecated()
  public Observable multiObservable() { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    multi(handler.toHandler());
    return handler;
  }

  /**
   * Redis command multi.
   * @return fluent self
   */
  public Single rxMulti() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      multi(fut);
    }));
  }

  /**
   * Redis command object.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI object(List args, Handler> handler) { 
    delegate.object(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command object.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxObject} instead
   */
  @Deprecated()
  public Observable objectObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    object(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command object.
   * @param args 
   * @return fluent self
   */
  public Single rxObject(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      object(args, fut);
    }));
  }

  /**
   * Redis command persist.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI persist(String arg0, Handler> handler) { 
    delegate.persist(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command persist.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxPersist} instead
   */
  @Deprecated()
  public Observable persistObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    persist(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command persist.
   * @param arg0 
   * @return fluent self
   */
  public Single rxPersist(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      persist(arg0, fut);
    }));
  }

  /**
   * Redis command pexpire.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpire(String arg0, String arg1, Handler> handler) { 
    delegate.pexpire(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command pexpire.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxPexpire} instead
   */
  @Deprecated()
  public Observable pexpireObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pexpire(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command pexpire.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxPexpire(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pexpire(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command pexpireat.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpireat(String arg0, String arg1, Handler> handler) { 
    delegate.pexpireat(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command pexpireat.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxPexpireat} instead
   */
  @Deprecated()
  public Observable pexpireatObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pexpireat(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command pexpireat.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxPexpireat(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pexpireat(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command pfadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfadd(List args, Handler> handler) { 
    delegate.pfadd(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command pfadd.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxPfadd} instead
   */
  @Deprecated()
  public Observable pfaddObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfadd(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command pfadd.
   * @param args 
   * @return fluent self
   */
  public Single rxPfadd(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pfadd(args, fut);
    }));
  }

  /**
   * Redis command pfcount.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfcount(List args, Handler> handler) { 
    delegate.pfcount(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command pfcount.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxPfcount} instead
   */
  @Deprecated()
  public Observable pfcountObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfcount(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command pfcount.
   * @param args 
   * @return fluent self
   */
  public Single rxPfcount(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pfcount(args, fut);
    }));
  }

  /**
   * Redis command pfdebug.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfdebug(List args, Handler> handler) { 
    delegate.pfdebug(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command pfdebug.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxPfdebug} instead
   */
  @Deprecated()
  public Observable pfdebugObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfdebug(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command pfdebug.
   * @param args 
   * @return fluent self
   */
  public Single rxPfdebug(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pfdebug(args, fut);
    }));
  }

  /**
   * Redis command pfmerge.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfmerge(List args, Handler> handler) { 
    delegate.pfmerge(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command pfmerge.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxPfmerge} instead
   */
  @Deprecated()
  public Observable pfmergeObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfmerge(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command pfmerge.
   * @param args 
   * @return fluent self
   */
  public Single rxPfmerge(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pfmerge(args, fut);
    }));
  }

  /**
   * Redis command pfselftest.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfselftest(Handler> handler) { 
    delegate.pfselftest(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command pfselftest.
   * @return fluent self
   * @deprecated use {@link #rxPfselftest} instead
   */
  @Deprecated()
  public Observable pfselftestObservable() { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pfselftest(handler.toHandler());
    return handler;
  }

  /**
   * Redis command pfselftest.
   * @return fluent self
   */
  public Single rxPfselftest() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pfselftest(fut);
    }));
  }

  /**
   * Redis command ping.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ping(List args, Handler> handler) { 
    delegate.ping(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command ping.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxPing} instead
   */
  @Deprecated()
  public Observable pingObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    ping(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command ping.
   * @param args 
   * @return fluent self
   */
  public Single rxPing(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      ping(args, fut);
    }));
  }

  /**
   * Redis command post.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI post(List args, Handler> handler) { 
    delegate.post(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command post.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxPost} instead
   */
  @Deprecated()
  public Observable postObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    post(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command post.
   * @param args 
   * @return fluent self
   */
  public Single rxPost(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      post(args, fut);
    }));
  }

  /**
   * Redis command psetex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psetex(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.psetex(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command psetex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxPsetex} instead
   */
  @Deprecated()
  public Observable psetexObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    psetex(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command psetex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxPsetex(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      psetex(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command psubscribe.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psubscribe(List args, Handler> handler) { 
    delegate.psubscribe(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command psubscribe.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxPsubscribe} instead
   */
  @Deprecated()
  public Observable psubscribeObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    psubscribe(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command psubscribe.
   * @param args 
   * @return fluent self
   */
  public Single rxPsubscribe(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      psubscribe(args, fut);
    }));
  }

  /**
   * Redis command psync.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psync(String arg0, String arg1, Handler> handler) { 
    delegate.psync(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command psync.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxPsync} instead
   */
  @Deprecated()
  public Observable psyncObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    psync(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command psync.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxPsync(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      psync(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command pttl.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pttl(String arg0, Handler> handler) { 
    delegate.pttl(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command pttl.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxPttl} instead
   */
  @Deprecated()
  public Observable pttlObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pttl(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command pttl.
   * @param arg0 
   * @return fluent self
   */
  public Single rxPttl(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pttl(arg0, fut);
    }));
  }

  /**
   * Redis command publish.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI publish(String arg0, String arg1, Handler> handler) { 
    delegate.publish(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command publish.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxPublish} instead
   */
  @Deprecated()
  public Observable publishObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    publish(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command publish.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxPublish(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      publish(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command pubsub.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pubsub(List args, Handler> handler) { 
    delegate.pubsub(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command pubsub.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxPubsub} instead
   */
  @Deprecated()
  public Observable pubsubObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    pubsub(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command pubsub.
   * @param args 
   * @return fluent self
   */
  public Single rxPubsub(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      pubsub(args, fut);
    }));
  }

  /**
   * Redis command punsubscribe.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI punsubscribe(List args, Handler> handler) { 
    delegate.punsubscribe(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command punsubscribe.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxPunsubscribe} instead
   */
  @Deprecated()
  public Observable punsubscribeObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    punsubscribe(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command punsubscribe.
   * @param args 
   * @return fluent self
   */
  public Single rxPunsubscribe(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      punsubscribe(args, fut);
    }));
  }

  /**
   * Redis command randomkey.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI randomkey(Handler> handler) { 
    delegate.randomkey(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command randomkey.
   * @return fluent self
   * @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;
  }

  /**
   * Redis command randomkey.
   * @return fluent self
   */
  public Single rxRandomkey() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      randomkey(fut);
    }));
  }

  /**
   * Redis command readonly.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI readonly(Handler> handler) { 
    delegate.readonly(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command readonly.
   * @return fluent self
   * @deprecated use {@link #rxReadonly} instead
   */
  @Deprecated()
  public Observable readonlyObservable() { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    readonly(handler.toHandler());
    return handler;
  }

  /**
   * Redis command readonly.
   * @return fluent self
   */
  public Single rxReadonly() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      readonly(fut);
    }));
  }

  /**
   * Redis command readwrite.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI readwrite(Handler> handler) { 
    delegate.readwrite(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command readwrite.
   * @return fluent self
   * @deprecated use {@link #rxReadwrite} instead
   */
  @Deprecated()
  public Observable readwriteObservable() { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    readwrite(handler.toHandler());
    return handler;
  }

  /**
   * Redis command readwrite.
   * @return fluent self
   */
  public Single rxReadwrite() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      readwrite(fut);
    }));
  }

  /**
   * Redis command rename.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rename(String arg0, String arg1, Handler> handler) { 
    delegate.rename(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command rename.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxRename} instead
   */
  @Deprecated()
  public Observable renameObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    rename(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command rename.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxRename(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rename(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command renamenx.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI renamenx(String arg0, String arg1, Handler> handler) { 
    delegate.renamenx(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command renamenx.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxRenamenx} instead
   */
  @Deprecated()
  public Observable renamenxObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    renamenx(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command renamenx.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxRenamenx(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      renamenx(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command replconf.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI replconf(List args, Handler> handler) { 
    delegate.replconf(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command replconf.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxReplconf} instead
   */
  @Deprecated()
  public Observable replconfObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    replconf(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command replconf.
   * @param args 
   * @return fluent self
   */
  public Single rxReplconf(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      replconf(args, fut);
    }));
  }

  /**
   * Redis command replicaof.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI replicaof(String arg0, String arg1, Handler> handler) { 
    delegate.replicaof(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command replicaof.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxReplicaof} instead
   */
  @Deprecated()
  public Observable replicaofObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    replicaof(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command replicaof.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxReplicaof(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      replicaof(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command restore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI restore(List args, Handler> handler) { 
    delegate.restore(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command restore.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxRestore} instead
   */
  @Deprecated()
  public Observable restoreObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    restore(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command restore.
   * @param args 
   * @return fluent self
   */
  public Single rxRestore(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      restore(args, fut);
    }));
  }

  /**
   * Redis command restoreAsking.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI restoreAsking(List args, Handler> handler) { 
    delegate.restoreAsking(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command restoreAsking.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxRestoreAsking} instead
   */
  @Deprecated()
  public Observable restoreAskingObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    restoreAsking(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command restoreAsking.
   * @param args 
   * @return fluent self
   */
  public Single rxRestoreAsking(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      restoreAsking(args, fut);
    }));
  }

  /**
   * Redis command role.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI role(Handler> handler) { 
    delegate.role(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command role.
   * @return fluent self
   * @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;
  }

  /**
   * Redis command role.
   * @return fluent self
   */
  public Single rxRole() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      role(fut);
    }));
  }

  /**
   * Redis command rpop.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpop(String arg0, Handler> handler) { 
    delegate.rpop(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command rpop.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxRpop} instead
   */
  @Deprecated()
  public Observable rpopObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    rpop(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command rpop.
   * @param arg0 
   * @return fluent self
   */
  public Single rxRpop(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rpop(arg0, fut);
    }));
  }

  /**
   * Redis command rpoplpush.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpoplpush(String arg0, String arg1, Handler> handler) { 
    delegate.rpoplpush(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command rpoplpush.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxRpoplpush} instead
   */
  @Deprecated()
  public Observable rpoplpushObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    rpoplpush(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command rpoplpush.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxRpoplpush(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rpoplpush(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command rpush.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpush(List args, Handler> handler) { 
    delegate.rpush(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command rpush.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxRpush} instead
   */
  @Deprecated()
  public Observable rpushObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    rpush(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command rpush.
   * @param args 
   * @return fluent self
   */
  public Single rxRpush(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rpush(args, fut);
    }));
  }

  /**
   * Redis command rpushx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpushx(List args, Handler> handler) { 
    delegate.rpushx(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command rpushx.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxRpushx} instead
   */
  @Deprecated()
  public Observable rpushxObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    rpushx(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command rpushx.
   * @param args 
   * @return fluent self
   */
  public Single rxRpushx(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      rpushx(args, fut);
    }));
  }

  /**
   * Redis command sadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sadd(List args, Handler> handler) { 
    delegate.sadd(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command sadd.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSadd} instead
   */
  @Deprecated()
  public Observable saddObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sadd(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command sadd.
   * @param args 
   * @return fluent self
   */
  public Single rxSadd(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sadd(args, fut);
    }));
  }

  /**
   * Redis command save.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI save(Handler> handler) { 
    delegate.save(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command save.
   * @return fluent self
   * @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;
  }

  /**
   * Redis command save.
   * @return fluent self
   */
  public Single rxSave() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      save(fut);
    }));
  }

  /**
   * Redis command scan.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI scan(List args, Handler> handler) { 
    delegate.scan(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command scan.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxScan} instead
   */
  @Deprecated()
  public Observable scanObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    scan(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command scan.
   * @param args 
   * @return fluent self
   */
  public Single rxScan(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      scan(args, fut);
    }));
  }

  /**
   * Redis command scard.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI scard(String arg0, Handler> handler) { 
    delegate.scard(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command scard.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxScard} instead
   */
  @Deprecated()
  public Observable scardObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    scard(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command scard.
   * @param arg0 
   * @return fluent self
   */
  public Single rxScard(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      scard(arg0, fut);
    }));
  }

  /**
   * Redis command script.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI script(List args, Handler> handler) { 
    delegate.script(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command script.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxScript} instead
   */
  @Deprecated()
  public Observable scriptObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    script(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command script.
   * @param args 
   * @return fluent self
   */
  public Single rxScript(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      script(args, fut);
    }));
  }

  /**
   * Redis command sdiff.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sdiff(List args, Handler> handler) { 
    delegate.sdiff(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command sdiff.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSdiff} instead
   */
  @Deprecated()
  public Observable sdiffObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sdiff(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command sdiff.
   * @param args 
   * @return fluent self
   */
  public Single rxSdiff(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sdiff(args, fut);
    }));
  }

  /**
   * Redis command sdiffstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sdiffstore(List args, Handler> handler) { 
    delegate.sdiffstore(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command sdiffstore.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSdiffstore} instead
   */
  @Deprecated()
  public Observable sdiffstoreObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sdiffstore(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command sdiffstore.
   * @param args 
   * @return fluent self
   */
  public Single rxSdiffstore(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sdiffstore(args, fut);
    }));
  }

  /**
   * Redis command select.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI select(String arg0, Handler> handler) { 
    delegate.select(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command select.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxSelect} instead
   */
  @Deprecated()
  public Observable selectObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    select(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command select.
   * @param arg0 
   * @return fluent self
   */
  public Single rxSelect(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      select(arg0, fut);
    }));
  }

  /**
   * Redis command set.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI set(List args, Handler> handler) { 
    delegate.set(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command set.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSet} instead
   */
  @Deprecated()
  public Observable setObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    set(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command set.
   * @param args 
   * @return fluent self
   */
  public Single rxSet(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      set(args, fut);
    }));
  }

  /**
   * Redis command setbit.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setbit(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.setbit(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command setbit.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxSetbit} instead
   */
  @Deprecated()
  public Observable setbitObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    setbit(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command setbit.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxSetbit(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      setbit(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command setex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setex(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.setex(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command setex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxSetex} instead
   */
  @Deprecated()
  public Observable setexObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    setex(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command setex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxSetex(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      setex(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command setnx.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setnx(String arg0, String arg1, Handler> handler) { 
    delegate.setnx(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command setnx.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxSetnx} instead
   */
  @Deprecated()
  public Observable setnxObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    setnx(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command setnx.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxSetnx(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      setnx(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command setrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setrange(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.setrange(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command setrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxSetrange} instead
   */
  @Deprecated()
  public Observable setrangeObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    setrange(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command setrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxSetrange(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      setrange(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command shutdown.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI shutdown(List args, Handler> handler) { 
    delegate.shutdown(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command shutdown.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxShutdown} instead
   */
  @Deprecated()
  public Observable shutdownObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    shutdown(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command shutdown.
   * @param args 
   * @return fluent self
   */
  public Single rxShutdown(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      shutdown(args, fut);
    }));
  }

  /**
   * Redis command sinter.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sinter(List args, Handler> handler) { 
    delegate.sinter(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command sinter.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSinter} instead
   */
  @Deprecated()
  public Observable sinterObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sinter(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command sinter.
   * @param args 
   * @return fluent self
   */
  public Single rxSinter(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sinter(args, fut);
    }));
  }

  /**
   * Redis command sinterstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sinterstore(List args, Handler> handler) { 
    delegate.sinterstore(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command sinterstore.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSinterstore} instead
   */
  @Deprecated()
  public Observable sinterstoreObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sinterstore(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command sinterstore.
   * @param args 
   * @return fluent self
   */
  public Single rxSinterstore(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sinterstore(args, fut);
    }));
  }

  /**
   * Redis command sismember.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sismember(String arg0, String arg1, Handler> handler) { 
    delegate.sismember(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command sismember.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxSismember} instead
   */
  @Deprecated()
  public Observable sismemberObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sismember(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command sismember.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxSismember(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sismember(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command slaveof.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI slaveof(String arg0, String arg1, Handler> handler) { 
    delegate.slaveof(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command slaveof.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxSlaveof} instead
   */
  @Deprecated()
  public Observable slaveofObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    slaveof(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command slaveof.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxSlaveof(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      slaveof(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command slowlog.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI slowlog(List args, Handler> handler) { 
    delegate.slowlog(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command slowlog.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSlowlog} instead
   */
  @Deprecated()
  public Observable slowlogObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    slowlog(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command slowlog.
   * @param args 
   * @return fluent self
   */
  public Single rxSlowlog(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      slowlog(args, fut);
    }));
  }

  /**
   * Redis command smembers.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smembers(String arg0, Handler> handler) { 
    delegate.smembers(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command smembers.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxSmembers} instead
   */
  @Deprecated()
  public Observable smembersObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    smembers(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command smembers.
   * @param arg0 
   * @return fluent self
   */
  public Single rxSmembers(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      smembers(arg0, fut);
    }));
  }

  /**
   * Redis command smove.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smove(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.smove(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command smove.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxSmove} instead
   */
  @Deprecated()
  public Observable smoveObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    smove(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command smove.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxSmove(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      smove(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command sort.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sort(List args, Handler> handler) { 
    delegate.sort(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command sort.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSort} instead
   */
  @Deprecated()
  public Observable sortObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sort(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command sort.
   * @param args 
   * @return fluent self
   */
  public Single rxSort(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sort(args, fut);
    }));
  }

  /**
   * Redis command spop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI spop(List args, Handler> handler) { 
    delegate.spop(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command spop.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSpop} instead
   */
  @Deprecated()
  public Observable spopObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    spop(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command spop.
   * @param args 
   * @return fluent self
   */
  public Single rxSpop(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      spop(args, fut);
    }));
  }

  /**
   * Redis command srandmember.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI srandmember(List args, Handler> handler) { 
    delegate.srandmember(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command srandmember.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSrandmember} instead
   */
  @Deprecated()
  public Observable srandmemberObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    srandmember(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command srandmember.
   * @param args 
   * @return fluent self
   */
  public Single rxSrandmember(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      srandmember(args, fut);
    }));
  }

  /**
   * Redis command srem.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI srem(List args, Handler> handler) { 
    delegate.srem(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command srem.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSrem} instead
   */
  @Deprecated()
  public Observable sremObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    srem(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command srem.
   * @param args 
   * @return fluent self
   */
  public Single rxSrem(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      srem(args, fut);
    }));
  }

  /**
   * Redis command sscan.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sscan(List args, Handler> handler) { 
    delegate.sscan(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command sscan.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSscan} instead
   */
  @Deprecated()
  public Observable sscanObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sscan(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command sscan.
   * @param args 
   * @return fluent self
   */
  public Single rxSscan(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sscan(args, fut);
    }));
  }

  /**
   * Redis command strlen.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI strlen(String arg0, Handler> handler) { 
    delegate.strlen(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command strlen.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxStrlen} instead
   */
  @Deprecated()
  public Observable strlenObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    strlen(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command strlen.
   * @param arg0 
   * @return fluent self
   */
  public Single rxStrlen(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      strlen(arg0, fut);
    }));
  }

  /**
   * Redis command subscribe.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI subscribe(List args, Handler> handler) { 
    delegate.subscribe(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command subscribe.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSubscribe} instead
   */
  @Deprecated()
  public Observable subscribeObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    subscribe(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command subscribe.
   * @param args 
   * @return fluent self
   */
  public Single rxSubscribe(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      subscribe(args, fut);
    }));
  }

  /**
   * Redis command substr.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI substr(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.substr(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command substr.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxSubstr} instead
   */
  @Deprecated()
  public Observable substrObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    substr(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command substr.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxSubstr(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      substr(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command sunion.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sunion(List args, Handler> handler) { 
    delegate.sunion(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command sunion.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSunion} instead
   */
  @Deprecated()
  public Observable sunionObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sunion(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command sunion.
   * @param args 
   * @return fluent self
   */
  public Single rxSunion(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sunion(args, fut);
    }));
  }

  /**
   * Redis command sunionstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sunionstore(List args, Handler> handler) { 
    delegate.sunionstore(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command sunionstore.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxSunionstore} instead
   */
  @Deprecated()
  public Observable sunionstoreObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    sunionstore(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command sunionstore.
   * @param args 
   * @return fluent self
   */
  public Single rxSunionstore(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sunionstore(args, fut);
    }));
  }

  /**
   * Redis command swapdb.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI swapdb(String arg0, String arg1, Handler> handler) { 
    delegate.swapdb(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command swapdb.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxSwapdb} instead
   */
  @Deprecated()
  public Observable swapdbObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    swapdb(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command swapdb.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxSwapdb(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      swapdb(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command sync.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sync(Handler> handler) { 
    delegate.sync(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command sync.
   * @return fluent self
   * @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;
  }

  /**
   * Redis command sync.
   * @return fluent self
   */
  public Single rxSync() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      sync(fut);
    }));
  }

  /**
   * Redis command time.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI time(Handler> handler) { 
    delegate.time(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command time.
   * @return fluent self
   * @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;
  }

  /**
   * Redis command time.
   * @return fluent self
   */
  public Single rxTime() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      time(fut);
    }));
  }

  /**
   * Redis command touch.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI touch(List args, Handler> handler) { 
    delegate.touch(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command touch.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxTouch} instead
   */
  @Deprecated()
  public Observable touchObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    touch(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command touch.
   * @param args 
   * @return fluent self
   */
  public Single rxTouch(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      touch(args, fut);
    }));
  }

  /**
   * Redis command ttl.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ttl(String arg0, Handler> handler) { 
    delegate.ttl(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command ttl.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxTtl} instead
   */
  @Deprecated()
  public Observable ttlObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    ttl(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command ttl.
   * @param arg0 
   * @return fluent self
   */
  public Single rxTtl(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      ttl(arg0, fut);
    }));
  }

  /**
   * Redis command type.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI type(String arg0, Handler> handler) { 
    delegate.type(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command type.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxType} instead
   */
  @Deprecated()
  public Observable typeObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    type(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command type.
   * @param arg0 
   * @return fluent self
   */
  public Single rxType(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      type(arg0, fut);
    }));
  }

  /**
   * Redis command unlink.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unlink(List args, Handler> handler) { 
    delegate.unlink(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command unlink.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxUnlink} instead
   */
  @Deprecated()
  public Observable unlinkObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    unlink(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command unlink.
   * @param args 
   * @return fluent self
   */
  public Single rxUnlink(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      unlink(args, fut);
    }));
  }

  /**
   * Redis command unsubscribe.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unsubscribe(List args, Handler> handler) { 
    delegate.unsubscribe(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command unsubscribe.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxUnsubscribe} instead
   */
  @Deprecated()
  public Observable unsubscribeObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    unsubscribe(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command unsubscribe.
   * @param args 
   * @return fluent self
   */
  public Single rxUnsubscribe(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      unsubscribe(args, fut);
    }));
  }

  /**
   * Redis command unwatch.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unwatch(Handler> handler) { 
    delegate.unwatch(new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command unwatch.
   * @return fluent self
   * @deprecated use {@link #rxUnwatch} instead
   */
  @Deprecated()
  public Observable unwatchObservable() { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    unwatch(handler.toHandler());
    return handler;
  }

  /**
   * Redis command unwatch.
   * @return fluent self
   */
  public Single rxUnwatch() { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      unwatch(fut);
    }));
  }

  /**
   * Redis command wait.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI wait(String arg0, String arg1, Handler> handler) { 
    delegate.wait(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command wait.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxWait} instead
   */
  @Deprecated()
  public Observable waitObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    wait(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command wait.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxWait(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      wait(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command watch.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI watch(List args, Handler> handler) { 
    delegate.watch(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command watch.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxWatch} instead
   */
  @Deprecated()
  public Observable watchObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    watch(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command watch.
   * @param args 
   * @return fluent self
   */
  public Single rxWatch(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      watch(args, fut);
    }));
  }

  /**
   * Redis command xack.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xack(List args, Handler> handler) { 
    delegate.xack(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xack.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXack} instead
   */
  @Deprecated()
  public Observable xackObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xack(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xack.
   * @param args 
   * @return fluent self
   */
  public Single rxXack(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xack(args, fut);
    }));
  }

  /**
   * Redis command xadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xadd(List args, Handler> handler) { 
    delegate.xadd(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xadd.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXadd} instead
   */
  @Deprecated()
  public Observable xaddObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xadd(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xadd.
   * @param args 
   * @return fluent self
   */
  public Single rxXadd(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xadd(args, fut);
    }));
  }

  /**
   * Redis command xclaim.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xclaim(List args, Handler> handler) { 
    delegate.xclaim(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xclaim.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXclaim} instead
   */
  @Deprecated()
  public Observable xclaimObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xclaim(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xclaim.
   * @param args 
   * @return fluent self
   */
  public Single rxXclaim(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xclaim(args, fut);
    }));
  }

  /**
   * Redis command xdel.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xdel(List args, Handler> handler) { 
    delegate.xdel(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xdel.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXdel} instead
   */
  @Deprecated()
  public Observable xdelObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xdel(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xdel.
   * @param args 
   * @return fluent self
   */
  public Single rxXdel(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xdel(args, fut);
    }));
  }

  /**
   * Redis command xgroup.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xgroup(List args, Handler> handler) { 
    delegate.xgroup(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xgroup.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXgroup} instead
   */
  @Deprecated()
  public Observable xgroupObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xgroup(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xgroup.
   * @param args 
   * @return fluent self
   */
  public Single rxXgroup(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xgroup(args, fut);
    }));
  }

  /**
   * Redis command xinfo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xinfo(List args, Handler> handler) { 
    delegate.xinfo(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xinfo.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXinfo} instead
   */
  @Deprecated()
  public Observable xinfoObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xinfo(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xinfo.
   * @param args 
   * @return fluent self
   */
  public Single rxXinfo(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xinfo(args, fut);
    }));
  }

  /**
   * Redis command xlen.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xlen(String arg0, Handler> handler) { 
    delegate.xlen(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xlen.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxXlen} instead
   */
  @Deprecated()
  public Observable xlenObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xlen(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xlen.
   * @param arg0 
   * @return fluent self
   */
  public Single rxXlen(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xlen(arg0, fut);
    }));
  }

  /**
   * Redis command xpending.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xpending(List args, Handler> handler) { 
    delegate.xpending(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xpending.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXpending} instead
   */
  @Deprecated()
  public Observable xpendingObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xpending(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xpending.
   * @param args 
   * @return fluent self
   */
  public Single rxXpending(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xpending(args, fut);
    }));
  }

  /**
   * Redis command xrange.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xrange(List args, Handler> handler) { 
    delegate.xrange(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xrange.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXrange} instead
   */
  @Deprecated()
  public Observable xrangeObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xrange(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xrange.
   * @param args 
   * @return fluent self
   */
  public Single rxXrange(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xrange(args, fut);
    }));
  }

  /**
   * Redis command xread.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xread(List args, Handler> handler) { 
    delegate.xread(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xread.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXread} instead
   */
  @Deprecated()
  public Observable xreadObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xread(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xread.
   * @param args 
   * @return fluent self
   */
  public Single rxXread(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xread(args, fut);
    }));
  }

  /**
   * Redis command xreadgroup.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xreadgroup(List args, Handler> handler) { 
    delegate.xreadgroup(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xreadgroup.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXreadgroup} instead
   */
  @Deprecated()
  public Observable xreadgroupObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xreadgroup(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xreadgroup.
   * @param args 
   * @return fluent self
   */
  public Single rxXreadgroup(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xreadgroup(args, fut);
    }));
  }

  /**
   * Redis command xrevrange.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xrevrange(List args, Handler> handler) { 
    delegate.xrevrange(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xrevrange.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXrevrange} instead
   */
  @Deprecated()
  public Observable xrevrangeObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xrevrange(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xrevrange.
   * @param args 
   * @return fluent self
   */
  public Single rxXrevrange(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xrevrange(args, fut);
    }));
  }

  /**
   * Redis command xsetid.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xsetid(String arg0, String arg1, Handler> handler) { 
    delegate.xsetid(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xsetid.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxXsetid} instead
   */
  @Deprecated()
  public Observable xsetidObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xsetid(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xsetid.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxXsetid(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xsetid(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command xtrim.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xtrim(List args, Handler> handler) { 
    delegate.xtrim(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command xtrim.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxXtrim} instead
   */
  @Deprecated()
  public Observable xtrimObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    xtrim(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command xtrim.
   * @param args 
   * @return fluent self
   */
  public Single rxXtrim(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      xtrim(args, fut);
    }));
  }

  /**
   * Redis command zadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zadd(List args, Handler> handler) { 
    delegate.zadd(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zadd.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZadd} instead
   */
  @Deprecated()
  public Observable zaddObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zadd(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zadd.
   * @param args 
   * @return fluent self
   */
  public Single rxZadd(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zadd(args, fut);
    }));
  }

  /**
   * Redis command zcard.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zcard(String arg0, Handler> handler) { 
    delegate.zcard(arg0, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zcard.
   * @param arg0 
   * @return fluent self
   * @deprecated use {@link #rxZcard} instead
   */
  @Deprecated()
  public Observable zcardObservable(String arg0) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zcard(arg0, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zcard.
   * @param arg0 
   * @return fluent self
   */
  public Single rxZcard(String arg0) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zcard(arg0, fut);
    }));
  }

  /**
   * Redis command zcount.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zcount(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.zcount(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zcount.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxZcount} instead
   */
  @Deprecated()
  public Observable zcountObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zcount(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zcount.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxZcount(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zcount(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command zincrby.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zincrby(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.zincrby(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zincrby.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxZincrby} instead
   */
  @Deprecated()
  public Observable zincrbyObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zincrby(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zincrby.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxZincrby(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zincrby(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command zinterstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zinterstore(List args, Handler> handler) { 
    delegate.zinterstore(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zinterstore.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZinterstore} instead
   */
  @Deprecated()
  public Observable zinterstoreObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zinterstore(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zinterstore.
   * @param args 
   * @return fluent self
   */
  public Single rxZinterstore(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zinterstore(args, fut);
    }));
  }

  /**
   * Redis command zlexcount.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zlexcount(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.zlexcount(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zlexcount.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxZlexcount} instead
   */
  @Deprecated()
  public Observable zlexcountObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zlexcount(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zlexcount.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxZlexcount(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zlexcount(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command zpopmax.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zpopmax(List args, Handler> handler) { 
    delegate.zpopmax(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zpopmax.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZpopmax} instead
   */
  @Deprecated()
  public Observable zpopmaxObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zpopmax(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zpopmax.
   * @param args 
   * @return fluent self
   */
  public Single rxZpopmax(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zpopmax(args, fut);
    }));
  }

  /**
   * Redis command zpopmin.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zpopmin(List args, Handler> handler) { 
    delegate.zpopmin(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zpopmin.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZpopmin} instead
   */
  @Deprecated()
  public Observable zpopminObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zpopmin(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zpopmin.
   * @param args 
   * @return fluent self
   */
  public Single rxZpopmin(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zpopmin(args, fut);
    }));
  }

  /**
   * Redis command zrange.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrange(List args, Handler> handler) { 
    delegate.zrange(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zrange.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZrange} instead
   */
  @Deprecated()
  public Observable zrangeObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrange(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zrange.
   * @param args 
   * @return fluent self
   */
  public Single rxZrange(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrange(args, fut);
    }));
  }

  /**
   * Redis command zrangebylex.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangebylex(List args, Handler> handler) { 
    delegate.zrangebylex(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zrangebylex.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZrangebylex} instead
   */
  @Deprecated()
  public Observable zrangebylexObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrangebylex(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zrangebylex.
   * @param args 
   * @return fluent self
   */
  public Single rxZrangebylex(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrangebylex(args, fut);
    }));
  }

  /**
   * Redis command zrangebyscore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangebyscore(List args, Handler> handler) { 
    delegate.zrangebyscore(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zrangebyscore.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZrangebyscore} instead
   */
  @Deprecated()
  public Observable zrangebyscoreObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrangebyscore(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zrangebyscore.
   * @param args 
   * @return fluent self
   */
  public Single rxZrangebyscore(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrangebyscore(args, fut);
    }));
  }

  /**
   * Redis command zrank.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrank(String arg0, String arg1, Handler> handler) { 
    delegate.zrank(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zrank.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxZrank} instead
   */
  @Deprecated()
  public Observable zrankObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrank(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zrank.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxZrank(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrank(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command zrem.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrem(List args, Handler> handler) { 
    delegate.zrem(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zrem.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZrem} instead
   */
  @Deprecated()
  public Observable zremObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrem(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zrem.
   * @param args 
   * @return fluent self
   */
  public Single rxZrem(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrem(args, fut);
    }));
  }

  /**
   * Redis command zremrangebylex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebylex(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.zremrangebylex(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zremrangebylex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxZremrangebylex} instead
   */
  @Deprecated()
  public Observable zremrangebylexObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zremrangebylex(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zremrangebylex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxZremrangebylex(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zremrangebylex(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command zremrangebyrank.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebyrank(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.zremrangebyrank(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zremrangebyrank.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxZremrangebyrank} instead
   */
  @Deprecated()
  public Observable zremrangebyrankObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zremrangebyrank(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zremrangebyrank.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxZremrangebyrank(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zremrangebyrank(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command zremrangebyscore.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebyscore(String arg0, String arg1, String arg2, Handler> handler) { 
    delegate.zremrangebyscore(arg0, arg1, arg2, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zremrangebyscore.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   * @deprecated use {@link #rxZremrangebyscore} instead
   */
  @Deprecated()
  public Observable zremrangebyscoreObservable(String arg0, String arg1, String arg2) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zremrangebyscore(arg0, arg1, arg2, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zremrangebyscore.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public Single rxZremrangebyscore(String arg0, String arg1, String arg2) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zremrangebyscore(arg0, arg1, arg2, fut);
    }));
  }

  /**
   * Redis command zrevrange.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrange(List args, Handler> handler) { 
    delegate.zrevrange(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zrevrange.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZrevrange} instead
   */
  @Deprecated()
  public Observable zrevrangeObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrevrange(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zrevrange.
   * @param args 
   * @return fluent self
   */
  public Single rxZrevrange(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrevrange(args, fut);
    }));
  }

  /**
   * Redis command zrevrangebylex.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrangebylex(List args, Handler> handler) { 
    delegate.zrevrangebylex(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zrevrangebylex.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZrevrangebylex} instead
   */
  @Deprecated()
  public Observable zrevrangebylexObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrevrangebylex(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zrevrangebylex.
   * @param args 
   * @return fluent self
   */
  public Single rxZrevrangebylex(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrevrangebylex(args, fut);
    }));
  }

  /**
   * Redis command zrevrangebyscore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrangebyscore(List args, Handler> handler) { 
    delegate.zrevrangebyscore(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zrevrangebyscore.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZrevrangebyscore} instead
   */
  @Deprecated()
  public Observable zrevrangebyscoreObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrevrangebyscore(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zrevrangebyscore.
   * @param args 
   * @return fluent self
   */
  public Single rxZrevrangebyscore(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrevrangebyscore(args, fut);
    }));
  }

  /**
   * Redis command zrevrank.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrank(String arg0, String arg1, Handler> handler) { 
    delegate.zrevrank(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zrevrank.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxZrevrank} instead
   */
  @Deprecated()
  public Observable zrevrankObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zrevrank(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zrevrank.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxZrevrank(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zrevrank(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command zscan.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zscan(List args, Handler> handler) { 
    delegate.zscan(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zscan.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZscan} instead
   */
  @Deprecated()
  public Observable zscanObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zscan(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zscan.
   * @param args 
   * @return fluent self
   */
  public Single rxZscan(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zscan(args, fut);
    }));
  }

  /**
   * Redis command zscore.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zscore(String arg0, String arg1, Handler> handler) { 
    delegate.zscore(arg0, arg1, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zscore.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   * @deprecated use {@link #rxZscore} instead
   */
  @Deprecated()
  public Observable zscoreObservable(String arg0, String arg1) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zscore(arg0, arg1, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zscore.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public Single rxZscore(String arg0, String arg1) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zscore(arg0, arg1, fut);
    }));
  }

  /**
   * Redis command zunionstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zunionstore(List args, Handler> handler) { 
    delegate.zunionstore(args, new Handler>() {
      public void handle(AsyncResult ar) {
        if (ar.succeeded()) {
          handler.handle(io.vertx.core.Future.succeededFuture(io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)ar.result())));
        } else {
          handler.handle(io.vertx.core.Future.failedFuture(ar.cause()));
        }
      }
    });
    return this;
  }

    /**
   * Redis command zunionstore.
   * @param args 
   * @return fluent self
   * @deprecated use {@link #rxZunionstore} instead
   */
  @Deprecated()
  public Observable zunionstoreObservable(List args) { 
    io.vertx.rx.java.ObservableFuture handler = io.vertx.rx.java.RxHelper.observableFuture();
    zunionstore(args, handler.toHandler());
    return handler;
  }

  /**
   * Redis command zunionstore.
   * @param args 
   * @return fluent self
   */
  public Single rxZunionstore(List args) { 
    return Single.create(new io.vertx.rx.java.SingleOnSubscribeAdapter<>(fut -> {
      zunionstore(args, fut);
    }));
  }

  public static io.vertx.rxjava.redis.client.RedisAPI api(io.vertx.rxjava.redis.client.Redis client) { 
    io.vertx.rxjava.redis.client.RedisAPI ret = io.vertx.rxjava.redis.client.RedisAPI.newInstance((io.vertx.redis.client.RedisAPI)io.vertx.redis.client.RedisAPI.api(client.getDelegate()));
    return ret;
  }

  public static io.vertx.rxjava.redis.client.RedisAPI api(io.vertx.rxjava.redis.client.RedisConnection connection) { 
    io.vertx.rxjava.redis.client.RedisAPI ret = io.vertx.rxjava.redis.client.RedisAPI.newInstance((io.vertx.redis.client.RedisAPI)io.vertx.redis.client.RedisAPI.api(connection.getDelegate()));
    return ret;
  }

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

}




    © 2015 - 2025 Weber Informatics LLC | Privacy Policy