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 ftAdd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAdd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftAdd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftAdd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAdd(java.util.List args) {
    return 
ftAdd(args, ar -> { });
  }

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

  /**
   * Redis command ftAggregate.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAggregate(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftAggregate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftAggregate.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAggregate(java.util.List args) {
    return 
ftAggregate(args, ar -> { });
  }

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

  /**
   * Redis command ftAliasadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAliasadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftAliasadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftAliasadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAliasadd(java.util.List args) {
    return 
ftAliasadd(args, ar -> { });
  }

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

  /**
   * Redis command ftAliasdel.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAliasdel(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftAliasdel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftAliasdel.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAliasdel(java.util.List args) {
    return 
ftAliasdel(args, ar -> { });
  }

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

  /**
   * Redis command ftAliasupdate.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAliasupdate(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftAliasupdate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftAliasupdate.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAliasupdate(java.util.List args) {
    return 
ftAliasupdate(args, ar -> { });
  }

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

  /**
   * Redis command ftAlter.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAlter(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftAlter(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftAlter.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAlter(java.util.List args) {
    return 
ftAlter(args, ar -> { });
  }

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

  /**
   * Redis command ftConfig.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftConfig(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftConfig(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftConfig.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftConfig(java.util.List args) {
    return 
ftConfig(args, ar -> { });
  }

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

  /**
   * Redis command ftCreate.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftCreate(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftCreate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftCreate.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftCreate(java.util.List args) {
    return 
ftCreate(args, ar -> { });
  }

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

  /**
   * Redis command ftCursor.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftCursor(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftCursor(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftCursor.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftCursor(java.util.List args) {
    return 
ftCursor(args, ar -> { });
  }

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

  /**
   * Redis command ftDebug.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDebug(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftDebug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftDebug.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDebug(java.util.List args) {
    return 
ftDebug(args, ar -> { });
  }

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

  /**
   * Redis command ftDel.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDel(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftDel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftDel.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDel(java.util.List args) {
    return 
ftDel(args, ar -> { });
  }

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

  /**
   * Redis command ftDictadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDictadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftDictadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftDictadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDictadd(java.util.List args) {
    return 
ftDictadd(args, ar -> { });
  }

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

  /**
   * Redis command ftDictdel.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDictdel(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftDictdel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftDictdel.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDictdel(java.util.List args) {
    return 
ftDictdel(args, ar -> { });
  }

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

  /**
   * Redis command ftDictdump.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDictdump(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftDictdump(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftDictdump.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDictdump(java.util.List args) {
    return 
ftDictdump(args, ar -> { });
  }

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

  /**
   * Redis command ftDrop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDrop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftDrop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftDrop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDrop(java.util.List args) {
    return 
ftDrop(args, ar -> { });
  }

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

  /**
   * Redis command ftDropindex.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDropindex(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftDropindex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftDropindex.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDropindex(java.util.List args) {
    return 
ftDropindex(args, ar -> { });
  }

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

  /**
   * Redis command ftExplain.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftExplain(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftExplain(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftExplain.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftExplain(java.util.List args) {
    return 
ftExplain(args, ar -> { });
  }

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

  /**
   * Redis command ftExplaincli.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftExplaincli(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftExplaincli(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftExplaincli.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftExplaincli(java.util.List args) {
    return 
ftExplaincli(args, ar -> { });
  }

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

  /**
   * Redis command ftGet.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftGet(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftGet(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftGet.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftGet(java.util.List args) {
    return 
ftGet(args, ar -> { });
  }

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

  /**
   * Redis command ftInfo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftInfo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftInfo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftInfo(java.util.List args) {
    return 
ftInfo(args, ar -> { });
  }

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

  /**
   * Redis command ftMget.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftMget(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftMget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftMget.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftMget(java.util.List args) {
    return 
ftMget(args, ar -> { });
  }

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

  /**
   * Redis command ftProfile.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftProfile(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftProfile(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftProfile.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftProfile(java.util.List args) {
    return 
ftProfile(args, ar -> { });
  }

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

  /**
   * Redis command ftSafeadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSafeadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftSafeadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftSafeadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSafeadd(java.util.List args) {
    return 
ftSafeadd(args, ar -> { });
  }

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

  /**
   * Redis command ftSearch.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSearch(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftSearch(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftSearch.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSearch(java.util.List args) {
    return 
ftSearch(args, ar -> { });
  }

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

  /**
   * Redis command ftSpellcheck.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSpellcheck(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftSpellcheck(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftSpellcheck.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSpellcheck(java.util.List args) {
    return 
ftSpellcheck(args, ar -> { });
  }

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

  /**
   * Redis command ftSugadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSugadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftSugadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftSugadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSugadd(java.util.List args) {
    return 
ftSugadd(args, ar -> { });
  }

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

  /**
   * Redis command ftSugdel.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSugdel(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftSugdel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftSugdel.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSugdel(java.util.List args) {
    return 
ftSugdel(args, ar -> { });
  }

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

  /**
   * Redis command ftSugget.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSugget(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftSugget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftSugget.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSugget(java.util.List args) {
    return 
ftSugget(args, ar -> { });
  }

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

  /**
   * Redis command ftSuglen.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSuglen(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftSuglen(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftSuglen.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSuglen(java.util.List args) {
    return 
ftSuglen(args, ar -> { });
  }

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

  /**
   * Redis command ftSynadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSynadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftSynadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftSynadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSynadd(java.util.List args) {
    return 
ftSynadd(args, ar -> { });
  }

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

  /**
   * Redis command ftSyndump.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSyndump(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftSyndump(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftSyndump.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSyndump(java.util.List args) {
    return 
ftSyndump(args, ar -> { });
  }

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

  /**
   * Redis command ftSynupdate.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSynupdate(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftSynupdate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftSynupdate.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftSynupdate(java.util.List args) {
    return 
ftSynupdate(args, ar -> { });
  }

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

  /**
   * Redis command ftTagvals.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftTagvals(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftTagvals(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftTagvals.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftTagvals(java.util.List args) {
    return 
ftTagvals(args, ar -> { });
  }

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

  /**
   * Redis command ftAliasaddifnx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAliasaddifnx(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftAliasaddifnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftAliasaddifnx.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAliasaddifnx(java.util.List args) {
    return 
ftAliasaddifnx(args, ar -> { });
  }

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

  /**
   * Redis command ftAliasdelifx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAliasdelifx(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftAliasdelifx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftAliasdelifx.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAliasdelifx(java.util.List args) {
    return 
ftAliasdelifx(args, ar -> { });
  }

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

  /**
   * Redis command ftAlterifnx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAlterifnx(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftAlterifnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftAlterifnx.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftAlterifnx(java.util.List args) {
    return 
ftAlterifnx(args, ar -> { });
  }

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

  /**
   * Redis command ftCreateifnx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftCreateifnx(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftCreateifnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftCreateifnx.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftCreateifnx(java.util.List args) {
    return 
ftCreateifnx(args, ar -> { });
  }

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

  /**
   * Redis command ftDropifx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDropifx(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftDropifx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftDropifx.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDropifx(java.util.List args) {
    return 
ftDropifx(args, ar -> { });
  }

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

  /**
   * Redis command ftDropindexifx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDropindexifx(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftDropindexifx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftDropindexifx.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftDropindexifx(java.util.List args) {
    return 
ftDropindexifx(args, ar -> { });
  }

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

  /**
   * Redis command ftList.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftList(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ftList(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ftList.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ftList(java.util.List args) {
    return 
ftList(args, ar -> { });
  }

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

  /**
   * Redis command acl.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI acl(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.acl(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command acl.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI acl(java.util.List args) {
    return 
acl(args, ar -> { });
  }

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

  /**
   * Redis command append.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI append(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.append(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command append.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI append(java.lang.String arg0, java.lang.String arg1) {
    return 
append(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command asking.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI asking(io.vertx.core.Handler> handler) { 
    delegate.asking(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command asking.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI asking() {
    return 
asking(ar -> { });
  }

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

  /**
   * Redis command auth.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI auth(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.auth(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command auth.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI auth(java.util.List args) {
    return 
auth(args, ar -> { });
  }

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

  /**
   * Redis command bfAdd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfAdd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bfAdd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bfAdd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfAdd(java.util.List args) {
    return 
bfAdd(args, ar -> { });
  }

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

  /**
   * Redis command bfDebug.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfDebug(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bfDebug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bfDebug.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfDebug(java.util.List args) {
    return 
bfDebug(args, ar -> { });
  }

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

  /**
   * Redis command bfExists.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfExists(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bfExists(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bfExists.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfExists(java.util.List args) {
    return 
bfExists(args, ar -> { });
  }

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

  /**
   * Redis command bfInfo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfInfo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bfInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bfInfo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfInfo(java.util.List args) {
    return 
bfInfo(args, ar -> { });
  }

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

  /**
   * Redis command bfInsert.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfInsert(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bfInsert(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bfInsert.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfInsert(java.util.List args) {
    return 
bfInsert(args, ar -> { });
  }

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

  /**
   * Redis command bfLoadchunk.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfLoadchunk(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bfLoadchunk(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bfLoadchunk.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfLoadchunk(java.util.List args) {
    return 
bfLoadchunk(args, ar -> { });
  }

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

  /**
   * Redis command bfMadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfMadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bfMadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bfMadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfMadd(java.util.List args) {
    return 
bfMadd(args, ar -> { });
  }

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

  /**
   * Redis command bfMexists.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfMexists(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bfMexists(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bfMexists.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfMexists(java.util.List args) {
    return 
bfMexists(args, ar -> { });
  }

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

  /**
   * Redis command bfReserve.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfReserve(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bfReserve(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bfReserve.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfReserve(java.util.List args) {
    return 
bfReserve(args, ar -> { });
  }

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

  /**
   * Redis command bfScandump.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfScandump(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bfScandump(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bfScandump.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bfScandump(java.util.List args) {
    return 
bfScandump(args, ar -> { });
  }

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

  /**
   * Redis command bgrewriteaof.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bgrewriteaof(io.vertx.core.Handler> handler) { 
    delegate.bgrewriteaof(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bgrewriteaof.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bgrewriteaof() {
    return 
bgrewriteaof(ar -> { });
  }

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

  /**
   * Redis command bgsave.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bgsave(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bgsave(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bgsave.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bgsave(java.util.List args) {
    return 
bgsave(args, ar -> { });
  }

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

  /**
   * Redis command bitcount.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitcount(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bitcount(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bitcount.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitcount(java.util.List args) {
    return 
bitcount(args, ar -> { });
  }

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

  /**
   * Redis command bitfield.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitfield(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bitfield(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bitfield.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitfield(java.util.List args) {
    return 
bitfield(args, ar -> { });
  }

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

  /**
   * Redis command bitfieldRo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitfieldRo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bitfieldRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bitfieldRo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitfieldRo(java.util.List args) {
    return 
bitfieldRo(args, ar -> { });
  }

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

  /**
   * Redis command bitop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bitop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bitop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitop(java.util.List args) {
    return 
bitop(args, ar -> { });
  }

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

  /**
   * Redis command bitpos.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitpos(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bitpos(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bitpos.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bitpos(java.util.List args) {
    return 
bitpos(args, ar -> { });
  }

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

  /**
   * Redis command blmove.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @param arg4 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI blmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3, java.lang.String arg4, io.vertx.core.Handler> handler) { 
    delegate.blmove(arg0, arg1, arg2, arg3, arg4, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command blmove.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @param arg4 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI blmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3, java.lang.String arg4) {
    return 
blmove(arg0, arg1, arg2, arg3, arg4, ar -> { });
  }

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

  /**
   * Redis command blmpop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI blmpop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.blmpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command blmpop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI blmpop(java.util.List args) {
    return 
blmpop(args, ar -> { });
  }

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

  /**
   * Redis command blpop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI blpop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.blpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command blpop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI blpop(java.util.List args) {
    return 
blpop(args, ar -> { });
  }

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

  /**
   * Redis command brpop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI brpop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.brpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command brpop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI brpop(java.util.List args) {
    return 
brpop(args, ar -> { });
  }

    /**
   * Redis command brpop.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxBrpop(java.util.List args) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.brpoplpush(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command brpoplpush.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI brpoplpush(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
brpoplpush(arg0, arg1, arg2, ar -> { });
  }

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

  /**
   * Redis command bzmpop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzmpop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bzmpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bzmpop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzmpop(java.util.List args) {
    return 
bzmpop(args, ar -> { });
  }

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

  /**
   * Redis command bzpopmax.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzpopmax(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bzpopmax(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bzpopmax.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzpopmax(java.util.List args) {
    return 
bzpopmax(args, ar -> { });
  }

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

  /**
   * Redis command bzpopmin.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzpopmin(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.bzpopmin(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command bzpopmin.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI bzpopmin(java.util.List args) {
    return 
bzpopmin(args, ar -> { });
  }

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

  /**
   * Redis command cfAdd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfAdd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfAdd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfAdd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfAdd(java.util.List args) {
    return 
cfAdd(args, ar -> { });
  }

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

  /**
   * Redis command cfAddnx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfAddnx(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfAddnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfAddnx.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfAddnx(java.util.List args) {
    return 
cfAddnx(args, ar -> { });
  }

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

  /**
   * Redis command cfCompact.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfCompact(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfCompact(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfCompact.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfCompact(java.util.List args) {
    return 
cfCompact(args, ar -> { });
  }

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

  /**
   * Redis command cfCount.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfCount(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfCount(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfCount.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfCount(java.util.List args) {
    return 
cfCount(args, ar -> { });
  }

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

  /**
   * Redis command cfDebug.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfDebug(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfDebug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfDebug.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfDebug(java.util.List args) {
    return 
cfDebug(args, ar -> { });
  }

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

  /**
   * Redis command cfDel.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfDel(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfDel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfDel.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfDel(java.util.List args) {
    return 
cfDel(args, ar -> { });
  }

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

  /**
   * Redis command cfExists.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfExists(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfExists(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfExists.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfExists(java.util.List args) {
    return 
cfExists(args, ar -> { });
  }

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

  /**
   * Redis command cfInfo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfInfo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfInfo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfInfo(java.util.List args) {
    return 
cfInfo(args, ar -> { });
  }

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

  /**
   * Redis command cfInsert.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfInsert(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfInsert(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfInsert.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfInsert(java.util.List args) {
    return 
cfInsert(args, ar -> { });
  }

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

  /**
   * Redis command cfInsertnx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfInsertnx(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfInsertnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfInsertnx.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfInsertnx(java.util.List args) {
    return 
cfInsertnx(args, ar -> { });
  }

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

  /**
   * Redis command cfLoadchunk.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfLoadchunk(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfLoadchunk(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfLoadchunk.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfLoadchunk(java.util.List args) {
    return 
cfLoadchunk(args, ar -> { });
  }

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

  /**
   * Redis command cfMexists.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfMexists(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfMexists(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfMexists.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfMexists(java.util.List args) {
    return 
cfMexists(args, ar -> { });
  }

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

  /**
   * Redis command cfReserve.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfReserve(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfReserve(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfReserve.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfReserve(java.util.List args) {
    return 
cfReserve(args, ar -> { });
  }

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

  /**
   * Redis command cfScandump.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfScandump(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cfScandump(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cfScandump.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cfScandump(java.util.List args) {
    return 
cfScandump(args, ar -> { });
  }

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

  /**
   * Redis command client.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI client(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.client(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command client.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI client(java.util.List args) {
    return 
client(args, ar -> { });
  }

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

  /**
   * Redis command cluster.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cluster(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cluster(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cluster.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cluster(java.util.List args) {
    return 
cluster(args, ar -> { });
  }

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

  /**
   * Redis command cmsIncrby.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsIncrby(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cmsIncrby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cmsIncrby.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsIncrby(java.util.List args) {
    return 
cmsIncrby(args, ar -> { });
  }

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

  /**
   * Redis command cmsInfo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsInfo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cmsInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cmsInfo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsInfo(java.util.List args) {
    return 
cmsInfo(args, ar -> { });
  }

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

  /**
   * Redis command cmsInitbydim.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsInitbydim(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cmsInitbydim(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cmsInitbydim.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsInitbydim(java.util.List args) {
    return 
cmsInitbydim(args, ar -> { });
  }

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

  /**
   * Redis command cmsInitbyprob.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsInitbyprob(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cmsInitbyprob(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cmsInitbyprob.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsInitbyprob(java.util.List args) {
    return 
cmsInitbyprob(args, ar -> { });
  }

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

  /**
   * Redis command cmsMerge.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsMerge(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cmsMerge(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cmsMerge.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsMerge(java.util.List args) {
    return 
cmsMerge(args, ar -> { });
  }

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

  /**
   * Redis command cmsQuery.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsQuery(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.cmsQuery(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command cmsQuery.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI cmsQuery(java.util.List args) {
    return 
cmsQuery(args, ar -> { });
  }

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

  /**
   * Redis command command.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI command(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.command(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command command.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI command(java.util.List args) {
    return 
command(args, ar -> { });
  }

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

  /**
   * Redis command config.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI config(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.config(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command config.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI config(java.util.List args) {
    return 
config(args, ar -> { });
  }

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

  /**
   * Redis command copy.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI copy(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.copy(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command copy.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI copy(java.util.List args) {
    return 
copy(args, ar -> { });
  }

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

  /**
   * Redis command dbsize.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI dbsize(io.vertx.core.Handler> handler) { 
    delegate.dbsize(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command dbsize.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI dbsize() {
    return 
dbsize(ar -> { });
  }

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

  /**
   * Redis command debug.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI debug(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.debug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command debug.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI debug(java.util.List args) {
    return 
debug(args, ar -> { });
  }

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

  /**
   * Redis command decr.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI decr(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.decr(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command decr.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI decr(java.lang.String arg0) {
    return 
decr(arg0, ar -> { });
  }

    /**
   * Redis command decr.
   * @param arg0 
   * @return fluent self
   */
  public rx.Single rxDecr(java.lang.String arg0) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.decrby(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command decrby.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI decrby(java.lang.String arg0, java.lang.String arg1) {
    return 
decrby(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command del.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI del(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.del(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command del.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI del(java.util.List args) {
    return 
del(args, ar -> { });
  }

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

  /**
   * Redis command discard.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI discard(io.vertx.core.Handler> handler) { 
    delegate.discard(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command discard.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI discard() {
    return 
discard(ar -> { });
  }

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

  /**
   * Redis command dump.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI dump(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.dump(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command dump.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI dump(java.lang.String arg0) {
    return 
dump(arg0, ar -> { });
  }

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

  /**
   * Redis command echo.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI echo(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.echo(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command echo.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI echo(java.lang.String arg0) {
    return 
echo(arg0, ar -> { });
  }

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

  /**
   * Redis command eval.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI eval(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.eval(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command eval.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI eval(java.util.List args) {
    return 
eval(args, ar -> { });
  }

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

  /**
   * Redis command evalRo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI evalRo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.evalRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command evalRo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI evalRo(java.util.List args) {
    return 
evalRo(args, ar -> { });
  }

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

  /**
   * Redis command evalsha.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI evalsha(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.evalsha(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command evalsha.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI evalsha(java.util.List args) {
    return 
evalsha(args, ar -> { });
  }

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

  /**
   * Redis command evalshaRo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI evalshaRo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.evalshaRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command evalshaRo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI evalshaRo(java.util.List args) {
    return 
evalshaRo(args, ar -> { });
  }

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

  /**
   * Redis command exec.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI exec(io.vertx.core.Handler> handler) { 
    delegate.exec(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command exec.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI exec() {
    return 
exec(ar -> { });
  }

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

  /**
   * Redis command exists.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI exists(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.exists(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command exists.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI exists(java.util.List args) {
    return 
exists(args, ar -> { });
  }

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

  /**
   * Redis command expire.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expire(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.expire(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command expire.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expire(java.util.List args) {
    return 
expire(args, ar -> { });
  }

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

  /**
   * Redis command expireat.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expireat(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.expireat(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command expireat.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expireat(java.util.List args) {
    return 
expireat(args, ar -> { });
  }

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

  /**
   * Redis command expiretime.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expiretime(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.expiretime(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command expiretime.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI expiretime(java.lang.String arg0) {
    return 
expiretime(arg0, ar -> { });
  }

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

  /**
   * Redis command failover.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI failover(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.failover(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command failover.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI failover(java.util.List args) {
    return 
failover(args, ar -> { });
  }

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

  /**
   * Redis command fcall.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI fcall(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.fcall(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command fcall.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI fcall(java.util.List args) {
    return 
fcall(args, ar -> { });
  }

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

  /**
   * Redis command fcallRo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI fcallRo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.fcallRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command fcallRo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI fcallRo(java.util.List args) {
    return 
fcallRo(args, ar -> { });
  }

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

  /**
   * Redis command flushall.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI flushall(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.flushall(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command flushall.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI flushall(java.util.List args) {
    return 
flushall(args, ar -> { });
  }

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

  /**
   * Redis command flushdb.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI flushdb(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.flushdb(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command flushdb.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI flushdb(java.util.List args) {
    return 
flushdb(args, ar -> { });
  }

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

  /**
   * Redis command function.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI function(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.function(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command function.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI function(java.util.List args) {
    return 
function(args, ar -> { });
  }

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

  /**
   * Redis command geoadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geoadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.geoadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command geoadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geoadd(java.util.List args) {
    return 
geoadd(args, ar -> { });
  }

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

  /**
   * Redis command geodist.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geodist(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.geodist(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command geodist.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geodist(java.util.List args) {
    return 
geodist(args, ar -> { });
  }

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

  /**
   * Redis command geohash.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geohash(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.geohash(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command geohash.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geohash(java.util.List args) {
    return 
geohash(args, ar -> { });
  }

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

  /**
   * Redis command geopos.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geopos(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.geopos(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command geopos.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geopos(java.util.List args) {
    return 
geopos(args, ar -> { });
  }

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

  /**
   * Redis command georadius.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadius(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.georadius(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command georadius.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadius(java.util.List args) {
    return 
georadius(args, ar -> { });
  }

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

  /**
   * Redis command georadiusRo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusRo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.georadiusRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command georadiusRo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusRo(java.util.List args) {
    return 
georadiusRo(args, ar -> { });
  }

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

  /**
   * Redis command georadiusbymember.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusbymember(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.georadiusbymember(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command georadiusbymember.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusbymember(java.util.List args) {
    return 
georadiusbymember(args, ar -> { });
  }

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

  /**
   * Redis command georadiusbymemberRo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusbymemberRo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.georadiusbymemberRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command georadiusbymemberRo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI georadiusbymemberRo(java.util.List args) {
    return 
georadiusbymemberRo(args, ar -> { });
  }

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

  /**
   * Redis command geosearch.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geosearch(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.geosearch(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command geosearch.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geosearch(java.util.List args) {
    return 
geosearch(args, ar -> { });
  }

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

  /**
   * Redis command geosearchstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geosearchstore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.geosearchstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command geosearchstore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI geosearchstore(java.util.List args) {
    return 
geosearchstore(args, ar -> { });
  }

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

  /**
   * Redis command get.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI get(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.get(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command get.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI get(java.lang.String arg0) {
    return 
get(arg0, ar -> { });
  }

    /**
   * Redis command get.
   * @param arg0 
   * @return fluent self
   */
  public rx.Single rxGet(java.lang.String arg0) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.getbit(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command getbit.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getbit(java.lang.String arg0, java.lang.String arg1) {
    return 
getbit(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command getdel.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getdel(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.getdel(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command getdel.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getdel(java.lang.String arg0) {
    return 
getdel(arg0, ar -> { });
  }

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

  /**
   * Redis command getex.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getex(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.getex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command getex.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getex(java.util.List args) {
    return 
getex(args, ar -> { });
  }

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

  /**
   * Redis command getrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.getrange(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command getrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
getrange(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command getrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxGetrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.getset(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command getset.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI getset(java.lang.String arg0, java.lang.String arg1) {
    return 
getset(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command graphBulk.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphBulk(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.graphBulk(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command graphBulk.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphBulk(java.util.List args) {
    return 
graphBulk(args, ar -> { });
  }

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

  /**
   * Redis command graphConfig.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphConfig(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.graphConfig(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command graphConfig.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphConfig(java.util.List args) {
    return 
graphConfig(args, ar -> { });
  }

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

  /**
   * Redis command graphDebug.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphDebug(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.graphDebug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command graphDebug.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphDebug(java.util.List args) {
    return 
graphDebug(args, ar -> { });
  }

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

  /**
   * Redis command graphDelete.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphDelete(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.graphDelete(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command graphDelete.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphDelete(java.util.List args) {
    return 
graphDelete(args, ar -> { });
  }

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

  /**
   * Redis command graphExplain.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphExplain(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.graphExplain(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command graphExplain.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphExplain(java.util.List args) {
    return 
graphExplain(args, ar -> { });
  }

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

  /**
   * Redis command graphList.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphList(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.graphList(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command graphList.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphList(java.util.List args) {
    return 
graphList(args, ar -> { });
  }

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

  /**
   * Redis command graphProfile.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphProfile(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.graphProfile(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command graphProfile.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphProfile(java.util.List args) {
    return 
graphProfile(args, ar -> { });
  }

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

  /**
   * Redis command graphQuery.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphQuery(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.graphQuery(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command graphQuery.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphQuery(java.util.List args) {
    return 
graphQuery(args, ar -> { });
  }

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

  /**
   * Redis command graphRoQuery.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphRoQuery(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.graphRoQuery(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command graphRoQuery.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphRoQuery(java.util.List args) {
    return 
graphRoQuery(args, ar -> { });
  }

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

  /**
   * Redis command graphSlowlog.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphSlowlog(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.graphSlowlog(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command graphSlowlog.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI graphSlowlog(java.util.List args) {
    return 
graphSlowlog(args, ar -> { });
  }

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

  /**
   * Redis command hdel.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hdel(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.hdel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hdel.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hdel(java.util.List args) {
    return 
hdel(args, ar -> { });
  }

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

  /**
   * Redis command hello.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hello(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.hello(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hello.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hello(java.util.List args) {
    return 
hello(args, ar -> { });
  }

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

  /**
   * Redis command hexists.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hexists(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.hexists(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hexists.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hexists(java.lang.String arg0, java.lang.String arg1) {
    return 
hexists(arg0, arg1, ar -> { });
  }

    /**
   * Redis command hexists.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public rx.Single rxHexists(java.lang.String arg0, java.lang.String arg1) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.hget(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hget.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hget(java.lang.String arg0, java.lang.String arg1) {
    return 
hget(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command hgetall.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hgetall(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.hgetall(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hgetall.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hgetall(java.lang.String arg0) {
    return 
hgetall(arg0, ar -> { });
  }

    /**
   * Redis command hgetall.
   * @param arg0 
   * @return fluent self
   */
  public rx.Single rxHgetall(java.lang.String arg0) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.hincrby(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hincrby.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
hincrby(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command hincrby.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxHincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.hincrbyfloat(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hincrbyfloat.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hincrbyfloat(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
hincrbyfloat(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command hincrbyfloat.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxHincrbyfloat(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.hkeys(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hkeys.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hkeys(java.lang.String arg0) {
    return 
hkeys(arg0, ar -> { });
  }

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

  /**
   * Redis command hlen.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hlen(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.hlen(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hlen.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hlen(java.lang.String arg0) {
    return 
hlen(arg0, ar -> { });
  }

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

  /**
   * Redis command hmget.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hmget(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.hmget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hmget.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hmget(java.util.List args) {
    return 
hmget(args, ar -> { });
  }

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

  /**
   * Redis command hmset.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hmset(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.hmset(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hmset.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hmset(java.util.List args) {
    return 
hmset(args, ar -> { });
  }

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

  /**
   * Redis command hrandfield.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hrandfield(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.hrandfield(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hrandfield.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hrandfield(java.util.List args) {
    return 
hrandfield(args, ar -> { });
  }

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

  /**
   * Redis command hscan.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hscan(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.hscan(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hscan.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hscan(java.util.List args) {
    return 
hscan(args, ar -> { });
  }

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

  /**
   * Redis command hset.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hset(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.hset(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hset.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hset(java.util.List args) {
    return 
hset(args, ar -> { });
  }

    /**
   * Redis command hset.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxHset(java.util.List args) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.hsetnx(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hsetnx.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hsetnx(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
hsetnx(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command hsetnx.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxHsetnx(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.hstrlen(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hstrlen.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hstrlen(java.lang.String arg0, java.lang.String arg1) {
    return 
hstrlen(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command hvals.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hvals(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.hvals(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command hvals.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI hvals(java.lang.String arg0) {
    return 
hvals(arg0, ar -> { });
  }

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

  /**
   * Redis command incr.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incr(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.incr(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command incr.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incr(java.lang.String arg0) {
    return 
incr(arg0, ar -> { });
  }

    /**
   * Redis command incr.
   * @param arg0 
   * @return fluent self
   */
  public rx.Single rxIncr(java.lang.String arg0) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.incrby(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command incrby.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incrby(java.lang.String arg0, java.lang.String arg1) {
    return 
incrby(arg0, arg1, ar -> { });
  }

    /**
   * Redis command incrby.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public rx.Single rxIncrby(java.lang.String arg0, java.lang.String arg1) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.incrbyfloat(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command incrbyfloat.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI incrbyfloat(java.lang.String arg0, java.lang.String arg1) {
    return 
incrbyfloat(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command info.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI info(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.info(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command info.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI info(java.util.List args) {
    return 
info(args, ar -> { });
  }

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

  /**
   * Redis command jsonArrappend.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrappend(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonArrappend(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonArrappend.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrappend(java.util.List args) {
    return 
jsonArrappend(args, ar -> { });
  }

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

  /**
   * Redis command jsonArrindex.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrindex(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonArrindex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonArrindex.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrindex(java.util.List args) {
    return 
jsonArrindex(args, ar -> { });
  }

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

  /**
   * Redis command jsonArrinsert.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrinsert(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonArrinsert(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonArrinsert.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrinsert(java.util.List args) {
    return 
jsonArrinsert(args, ar -> { });
  }

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

  /**
   * Redis command jsonArrlen.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrlen(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonArrlen(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonArrlen.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrlen(java.util.List args) {
    return 
jsonArrlen(args, ar -> { });
  }

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

  /**
   * Redis command jsonArrpop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrpop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonArrpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonArrpop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrpop(java.util.List args) {
    return 
jsonArrpop(args, ar -> { });
  }

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

  /**
   * Redis command jsonArrtrim.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrtrim(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonArrtrim(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonArrtrim.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonArrtrim(java.util.List args) {
    return 
jsonArrtrim(args, ar -> { });
  }

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

  /**
   * Redis command jsonClear.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonClear(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonClear(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonClear.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonClear(java.util.List args) {
    return 
jsonClear(args, ar -> { });
  }

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

  /**
   * Redis command jsonDebug.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonDebug(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonDebug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonDebug.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonDebug(java.util.List args) {
    return 
jsonDebug(args, ar -> { });
  }

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

  /**
   * Redis command jsonDel.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonDel(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonDel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonDel.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonDel(java.util.List args) {
    return 
jsonDel(args, ar -> { });
  }

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

  /**
   * Redis command jsonForget.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonForget(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonForget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonForget.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonForget(java.util.List args) {
    return 
jsonForget(args, ar -> { });
  }

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

  /**
   * Redis command jsonGet.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonGet(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonGet(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonGet.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonGet(java.util.List args) {
    return 
jsonGet(args, ar -> { });
  }

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

  /**
   * Redis command jsonMget.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonMget(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonMget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonMget.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonMget(java.util.List args) {
    return 
jsonMget(args, ar -> { });
  }

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

  /**
   * Redis command jsonNumincrby.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonNumincrby(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonNumincrby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonNumincrby.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonNumincrby(java.util.List args) {
    return 
jsonNumincrby(args, ar -> { });
  }

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

  /**
   * Redis command jsonNummultby.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonNummultby(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonNummultby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonNummultby.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonNummultby(java.util.List args) {
    return 
jsonNummultby(args, ar -> { });
  }

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

  /**
   * Redis command jsonNumpowby.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonNumpowby(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonNumpowby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonNumpowby.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonNumpowby(java.util.List args) {
    return 
jsonNumpowby(args, ar -> { });
  }

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

  /**
   * Redis command jsonObjkeys.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonObjkeys(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonObjkeys(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonObjkeys.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonObjkeys(java.util.List args) {
    return 
jsonObjkeys(args, ar -> { });
  }

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

  /**
   * Redis command jsonObjlen.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonObjlen(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonObjlen(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonObjlen.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonObjlen(java.util.List args) {
    return 
jsonObjlen(args, ar -> { });
  }

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

  /**
   * Redis command jsonResp.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonResp(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonResp(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonResp.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonResp(java.util.List args) {
    return 
jsonResp(args, ar -> { });
  }

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

  /**
   * Redis command jsonSet.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonSet(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonSet(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonSet.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonSet(java.util.List args) {
    return 
jsonSet(args, ar -> { });
  }

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

  /**
   * Redis command jsonStrappend.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonStrappend(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonStrappend(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonStrappend.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonStrappend(java.util.List args) {
    return 
jsonStrappend(args, ar -> { });
  }

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

  /**
   * Redis command jsonStrlen.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonStrlen(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonStrlen(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonStrlen.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonStrlen(java.util.List args) {
    return 
jsonStrlen(args, ar -> { });
  }

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

  /**
   * Redis command jsonToggle.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonToggle(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonToggle(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonToggle.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonToggle(java.util.List args) {
    return 
jsonToggle(args, ar -> { });
  }

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

  /**
   * Redis command jsonType.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonType(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.jsonType(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command jsonType.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI jsonType(java.util.List args) {
    return 
jsonType(args, ar -> { });
  }

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

  /**
   * Redis command keys.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI keys(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.keys(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command keys.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI keys(java.lang.String arg0) {
    return 
keys(arg0, ar -> { });
  }

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

  /**
   * Redis command lastsave.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lastsave(io.vertx.core.Handler> handler) { 
    delegate.lastsave(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lastsave.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lastsave() {
    return 
lastsave(ar -> { });
  }

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

  /**
   * Redis command latency.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI latency(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.latency(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command latency.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI latency(java.util.List args) {
    return 
latency(args, ar -> { });
  }

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

  /**
   * Redis command lcs.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lcs(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.lcs(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lcs.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lcs(java.util.List args) {
    return 
lcs(args, ar -> { });
  }

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

  /**
   * Redis command lindex.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lindex(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.lindex(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lindex.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lindex(java.lang.String arg0, java.lang.String arg1) {
    return 
lindex(arg0, arg1, ar -> { });
  }

    /**
   * Redis command lindex.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public rx.Single rxLindex(java.lang.String arg0, java.lang.String arg1) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3, io.vertx.core.Handler> handler) { 
    delegate.linsert(arg0, arg1, arg2, arg3, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command linsert.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI linsert(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3) {
    return 
linsert(arg0, arg1, arg2, arg3, ar -> { });
  }

    /**
   * Redis command linsert.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return fluent self
   */
  public rx.Single rxLinsert(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3) { 
    return Single.create(new 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(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.llen(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command llen.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI llen(java.lang.String arg0) {
    return 
llen(arg0, ar -> { });
  }

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

  /**
   * Redis command lmove.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3, io.vertx.core.Handler> handler) { 
    delegate.lmove(arg0, arg1, arg2, arg3, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lmove.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3) {
    return 
lmove(arg0, arg1, arg2, arg3, ar -> { });
  }

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

  /**
   * Redis command lmpop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lmpop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.lmpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lmpop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lmpop(java.util.List args) {
    return 
lmpop(args, ar -> { });
  }

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

  /**
   * Redis command lolwut.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lolwut(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.lolwut(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lolwut.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lolwut(java.util.List args) {
    return 
lolwut(args, ar -> { });
  }

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

  /**
   * Redis command lpop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.lpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lpop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpop(java.util.List args) {
    return 
lpop(args, ar -> { });
  }

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

  /**
   * Redis command lpos.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpos(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.lpos(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lpos.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpos(java.util.List args) {
    return 
lpos(args, ar -> { });
  }

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

  /**
   * Redis command lpush.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpush(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.lpush(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lpush.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpush(java.util.List args) {
    return 
lpush(args, ar -> { });
  }

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

  /**
   * Redis command lpushx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpushx(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.lpushx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lpushx.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lpushx(java.util.List args) {
    return 
lpushx(args, ar -> { });
  }

    /**
   * Redis command lpushx.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxLpushx(java.util.List args) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.lrange(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
lrange(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command lrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxLrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.lrem(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lrem.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lrem(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
lrem(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command lrem.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxLrem(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.lset(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command lset.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI lset(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
lset(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command lset.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxLset(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.ltrim(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ltrim.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ltrim(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
ltrim(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command ltrim.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxLtrim(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.memory(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command memory.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI memory(java.util.List args) {
    return 
memory(args, ar -> { });
  }

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

  /**
   * Redis command mget.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI mget(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.mget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command mget.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI mget(java.util.List args) {
    return 
mget(args, ar -> { });
  }

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

  /**
   * Redis command migrate.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI migrate(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.migrate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command migrate.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI migrate(java.util.List args) {
    return 
migrate(args, ar -> { });
  }

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

  /**
   * Redis command module.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI module(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.module(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command module.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI module(java.util.List args) {
    return 
module(args, ar -> { });
  }

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

  /**
   * Redis command monitor.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI monitor(io.vertx.core.Handler> handler) { 
    delegate.monitor(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command monitor.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI monitor() {
    return 
monitor(ar -> { });
  }

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

  /**
   * Redis command move.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI move(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.move(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command move.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI move(java.lang.String arg0, java.lang.String arg1) {
    return 
move(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command mset.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI mset(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.mset(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command mset.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI mset(java.util.List args) {
    return 
mset(args, ar -> { });
  }

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

  /**
   * Redis command msetnx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI msetnx(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.msetnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command msetnx.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI msetnx(java.util.List args) {
    return 
msetnx(args, ar -> { });
  }

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

  /**
   * Redis command multi.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI multi(io.vertx.core.Handler> handler) { 
    delegate.multi(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command multi.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI multi() {
    return 
multi(ar -> { });
  }

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

  /**
   * Redis command object.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI object(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.object(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command object.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI object(java.util.List args) {
    return 
object(args, ar -> { });
  }

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

  /**
   * Redis command persist.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI persist(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.persist(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command persist.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI persist(java.lang.String arg0) {
    return 
persist(arg0, ar -> { });
  }

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

  /**
   * Redis command pexpire.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpire(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.pexpire(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command pexpire.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpire(java.util.List args) {
    return 
pexpire(args, ar -> { });
  }

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

  /**
   * Redis command pexpireat.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpireat(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.pexpireat(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command pexpireat.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpireat(java.util.List args) {
    return 
pexpireat(args, ar -> { });
  }

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

  /**
   * Redis command pexpiretime.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpiretime(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.pexpiretime(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command pexpiretime.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pexpiretime(java.lang.String arg0) {
    return 
pexpiretime(arg0, ar -> { });
  }

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

  /**
   * Redis command pfadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.pfadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command pfadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfadd(java.util.List args) {
    return 
pfadd(args, ar -> { });
  }

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

  /**
   * Redis command pfcount.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfcount(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.pfcount(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command pfcount.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfcount(java.util.List args) {
    return 
pfcount(args, ar -> { });
  }

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

  /**
   * Redis command pfdebug.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfdebug(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.pfdebug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command pfdebug.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfdebug(java.util.List args) {
    return 
pfdebug(args, ar -> { });
  }

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

  /**
   * Redis command pfmerge.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfmerge(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.pfmerge(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command pfmerge.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfmerge(java.util.List args) {
    return 
pfmerge(args, ar -> { });
  }

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

  /**
   * Redis command pfselftest.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfselftest(io.vertx.core.Handler> handler) { 
    delegate.pfselftest(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command pfselftest.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pfselftest() {
    return 
pfselftest(ar -> { });
  }

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

  /**
   * Redis command ping.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ping(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ping(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ping.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ping(java.util.List args) {
    return 
ping(args, ar -> { });
  }

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

  /**
   * Redis command psetex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psetex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.psetex(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command psetex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psetex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
psetex(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command psetex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxPsetex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.psubscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command psubscribe.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psubscribe(java.util.List args) {
    return 
psubscribe(args, ar -> { });
  }

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

  /**
   * Redis command psync.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psync(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.psync(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command psync.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI psync(java.util.List args) {
    return 
psync(args, ar -> { });
  }

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

  /**
   * Redis command pttl.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pttl(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.pttl(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command pttl.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pttl(java.lang.String arg0) {
    return 
pttl(arg0, ar -> { });
  }

    /**
   * Redis command pttl.
   * @param arg0 
   * @return fluent self
   */
  public rx.Single rxPttl(java.lang.String arg0) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.publish(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command publish.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI publish(java.lang.String arg0, java.lang.String arg1) {
    return 
publish(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command pubsub.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pubsub(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.pubsub(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command pubsub.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI pubsub(java.util.List args) {
    return 
pubsub(args, ar -> { });
  }

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

  /**
   * Redis command punsubscribe.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI punsubscribe(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.punsubscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command punsubscribe.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI punsubscribe(java.util.List args) {
    return 
punsubscribe(args, ar -> { });
  }

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

  /**
   * Redis command quit.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI quit(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.quit(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command quit.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI quit(java.util.List args) {
    return 
quit(args, ar -> { });
  }

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

  /**
   * Redis command randomkey.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI randomkey(io.vertx.core.Handler> handler) { 
    delegate.randomkey(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command randomkey.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI randomkey() {
    return 
randomkey(ar -> { });
  }

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

  /**
   * Redis command readonly.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI readonly(io.vertx.core.Handler> handler) { 
    delegate.readonly(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command readonly.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI readonly() {
    return 
readonly(ar -> { });
  }

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

  /**
   * Redis command readwrite.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI readwrite(io.vertx.core.Handler> handler) { 
    delegate.readwrite(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command readwrite.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI readwrite() {
    return 
readwrite(ar -> { });
  }

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

  /**
   * Redis command rename.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rename(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.rename(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command rename.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rename(java.lang.String arg0, java.lang.String arg1) {
    return 
rename(arg0, arg1, ar -> { });
  }

    /**
   * Redis command rename.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public rx.Single rxRename(java.lang.String arg0, java.lang.String arg1) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.renamenx(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command renamenx.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI renamenx(java.lang.String arg0, java.lang.String arg1) {
    return 
renamenx(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command replconf.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI replconf(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.replconf(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command replconf.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI replconf(java.util.List args) {
    return 
replconf(args, ar -> { });
  }

    /**
   * Redis command replconf.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxReplconf(java.util.List args) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.replicaof(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command replicaof.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI replicaof(java.lang.String arg0, java.lang.String arg1) {
    return 
replicaof(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command reset.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI reset(io.vertx.core.Handler> handler) { 
    delegate.reset(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command reset.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI reset() {
    return 
reset(ar -> { });
  }

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

  /**
   * Redis command restore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI restore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.restore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command restore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI restore(java.util.List args) {
    return 
restore(args, ar -> { });
  }

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

  /**
   * Redis command restoreAsking.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI restoreAsking(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.restoreAsking(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command restoreAsking.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI restoreAsking(java.util.List args) {
    return 
restoreAsking(args, ar -> { });
  }

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

  /**
   * Redis command role.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI role(io.vertx.core.Handler> handler) { 
    delegate.role(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command role.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI role() {
    return 
role(ar -> { });
  }

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

  /**
   * Redis command rpop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.rpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command rpop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpop(java.util.List args) {
    return 
rpop(args, ar -> { });
  }

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

  /**
   * Redis command rpoplpush.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpoplpush(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.rpoplpush(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command rpoplpush.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpoplpush(java.lang.String arg0, java.lang.String arg1) {
    return 
rpoplpush(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command rpush.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpush(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.rpush(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command rpush.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpush(java.util.List args) {
    return 
rpush(args, ar -> { });
  }

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

  /**
   * Redis command rpushx.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpushx(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.rpushx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command rpushx.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI rpushx(java.util.List args) {
    return 
rpushx(args, ar -> { });
  }

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

  /**
   * Redis command sadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sadd(java.util.List args) {
    return 
sadd(args, ar -> { });
  }

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

  /**
   * Redis command save.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI save(io.vertx.core.Handler> handler) { 
    delegate.save(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command save.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI save() {
    return 
save(ar -> { });
  }

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

  /**
   * Redis command scan.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI scan(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.scan(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command scan.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI scan(java.util.List args) {
    return 
scan(args, ar -> { });
  }

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

  /**
   * Redis command scard.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI scard(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.scard(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command scard.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI scard(java.lang.String arg0) {
    return 
scard(arg0, ar -> { });
  }

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

  /**
   * Redis command script.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI script(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.script(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command script.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI script(java.util.List args) {
    return 
script(args, ar -> { });
  }

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

  /**
   * Redis command sdiff.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sdiff(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sdiff(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sdiff.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sdiff(java.util.List args) {
    return 
sdiff(args, ar -> { });
  }

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

  /**
   * Redis command sdiffstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sdiffstore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sdiffstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sdiffstore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sdiffstore(java.util.List args) {
    return 
sdiffstore(args, ar -> { });
  }

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

  /**
   * Redis command select.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI select(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.select(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command select.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI select(java.lang.String arg0) {
    return 
select(arg0, ar -> { });
  }

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

  /**
   * Redis command set.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI set(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.set(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command set.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI set(java.util.List args) {
    return 
set(args, ar -> { });
  }

    /**
   * Redis command set.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxSet(java.util.List args) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.setbit(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command setbit.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setbit(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
setbit(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command setbit.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxSetbit(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.setex(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command setex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
setex(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command setex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxSetex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.setnx(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command setnx.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setnx(java.lang.String arg0, java.lang.String arg1) {
    return 
setnx(arg0, arg1, ar -> { });
  }

    /**
   * Redis command setnx.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public rx.Single rxSetnx(java.lang.String arg0, java.lang.String arg1) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.setrange(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command setrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI setrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
setrange(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command setrange.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxSetrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.shutdown(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command shutdown.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI shutdown(java.util.List args) {
    return 
shutdown(args, ar -> { });
  }

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

  /**
   * Redis command sinter.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sinter(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sinter(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sinter.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sinter(java.util.List args) {
    return 
sinter(args, ar -> { });
  }

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

  /**
   * Redis command sintercard.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sintercard(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sintercard(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sintercard.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sintercard(java.util.List args) {
    return 
sintercard(args, ar -> { });
  }

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

  /**
   * Redis command sinterstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sinterstore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sinterstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sinterstore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sinterstore(java.util.List args) {
    return 
sinterstore(args, ar -> { });
  }

    /**
   * Redis command sinterstore.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxSinterstore(java.util.List args) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.sismember(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sismember.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sismember(java.lang.String arg0, java.lang.String arg1) {
    return 
sismember(arg0, arg1, ar -> { });
  }

    /**
   * Redis command sismember.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public rx.Single rxSismember(java.lang.String arg0, java.lang.String arg1) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.slaveof(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command slaveof.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI slaveof(java.lang.String arg0, java.lang.String arg1) {
    return 
slaveof(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command slowlog.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI slowlog(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.slowlog(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command slowlog.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI slowlog(java.util.List args) {
    return 
slowlog(args, ar -> { });
  }

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

  /**
   * Redis command smembers.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smembers(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.smembers(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command smembers.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smembers(java.lang.String arg0) {
    return 
smembers(arg0, ar -> { });
  }

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

  /**
   * Redis command smismember.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smismember(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.smismember(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command smismember.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smismember(java.util.List args) {
    return 
smismember(args, ar -> { });
  }

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

  /**
   * Redis command smove.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.smove(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command smove.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI smove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
smove(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command smove.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxSmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sort(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sort.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sort(java.util.List args) {
    return 
sort(args, ar -> { });
  }

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

  /**
   * Redis command sortRo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sortRo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sortRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sortRo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sortRo(java.util.List args) {
    return 
sortRo(args, ar -> { });
  }

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

  /**
   * Redis command spop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI spop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.spop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command spop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI spop(java.util.List args) {
    return 
spop(args, ar -> { });
  }

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

  /**
   * Redis command spublish.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI spublish(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.spublish(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command spublish.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI spublish(java.lang.String arg0, java.lang.String arg1) {
    return 
spublish(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command srandmember.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI srandmember(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.srandmember(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command srandmember.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI srandmember(java.util.List args) {
    return 
srandmember(args, ar -> { });
  }

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

  /**
   * Redis command srem.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI srem(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.srem(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command srem.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI srem(java.util.List args) {
    return 
srem(args, ar -> { });
  }

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

  /**
   * Redis command sscan.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sscan(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sscan(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sscan.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sscan(java.util.List args) {
    return 
sscan(args, ar -> { });
  }

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

  /**
   * Redis command ssubscribe.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ssubscribe(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.ssubscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ssubscribe.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ssubscribe(java.util.List args) {
    return 
ssubscribe(args, ar -> { });
  }

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

  /**
   * Redis command strlen.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI strlen(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.strlen(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command strlen.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI strlen(java.lang.String arg0) {
    return 
strlen(arg0, ar -> { });
  }

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

  /**
   * Redis command subscribe.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI subscribe(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.subscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command subscribe.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI subscribe(java.util.List args) {
    return 
subscribe(args, ar -> { });
  }

    /**
   * Redis command subscribe.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxSubscribe(java.util.List args) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.substr(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command substr.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI substr(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
substr(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command substr.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxSubstr(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sunion(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sunion.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sunion(java.util.List args) {
    return 
sunion(args, ar -> { });
  }

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

  /**
   * Redis command sunionstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sunionstore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sunionstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sunionstore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sunionstore(java.util.List args) {
    return 
sunionstore(args, ar -> { });
  }

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

  /**
   * Redis command sunsubscribe.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sunsubscribe(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.sunsubscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sunsubscribe.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sunsubscribe(java.util.List args) {
    return 
sunsubscribe(args, ar -> { });
  }

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

  /**
   * Redis command swapdb.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI swapdb(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.swapdb(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command swapdb.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI swapdb(java.lang.String arg0, java.lang.String arg1) {
    return 
swapdb(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command sync.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sync(io.vertx.core.Handler> handler) { 
    delegate.sync(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command sync.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI sync() {
    return 
sync(ar -> { });
  }

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

  /**
   * Redis command time.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI time(io.vertx.core.Handler> handler) { 
    delegate.time(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command time.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI time() {
    return 
time(ar -> { });
  }

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

  /**
   * Redis command timeseriesClusterset.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesClusterset(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.timeseriesClusterset(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command timeseriesClusterset.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesClusterset(java.util.List args) {
    return 
timeseriesClusterset(args, ar -> { });
  }

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

  /**
   * Redis command timeseriesClustersetfromshard.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesClustersetfromshard(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.timeseriesClustersetfromshard(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command timeseriesClustersetfromshard.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesClustersetfromshard(java.util.List args) {
    return 
timeseriesClustersetfromshard(args, ar -> { });
  }

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

  /**
   * Redis command timeseriesHello.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesHello(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.timeseriesHello(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command timeseriesHello.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesHello(java.util.List args) {
    return 
timeseriesHello(args, ar -> { });
  }

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

  /**
   * Redis command timeseriesInfocluster.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesInfocluster(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.timeseriesInfocluster(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command timeseriesInfocluster.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesInfocluster(java.util.List args) {
    return 
timeseriesInfocluster(args, ar -> { });
  }

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

  /**
   * Redis command timeseriesInnercommunication.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesInnercommunication(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.timeseriesInnercommunication(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command timeseriesInnercommunication.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesInnercommunication(java.util.List args) {
    return 
timeseriesInnercommunication(args, ar -> { });
  }

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

  /**
   * Redis command timeseriesNetworktest.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesNetworktest(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.timeseriesNetworktest(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command timeseriesNetworktest.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesNetworktest(java.util.List args) {
    return 
timeseriesNetworktest(args, ar -> { });
  }

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

  /**
   * Redis command timeseriesRefreshcluster.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesRefreshcluster(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.timeseriesRefreshcluster(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command timeseriesRefreshcluster.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI timeseriesRefreshcluster(java.util.List args) {
    return 
timeseriesRefreshcluster(args, ar -> { });
  }

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

  /**
   * Redis command topkAdd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkAdd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.topkAdd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command topkAdd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkAdd(java.util.List args) {
    return 
topkAdd(args, ar -> { });
  }

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

  /**
   * Redis command topkCount.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkCount(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.topkCount(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command topkCount.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkCount(java.util.List args) {
    return 
topkCount(args, ar -> { });
  }

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

  /**
   * Redis command topkIncrby.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkIncrby(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.topkIncrby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command topkIncrby.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkIncrby(java.util.List args) {
    return 
topkIncrby(args, ar -> { });
  }

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

  /**
   * Redis command topkInfo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkInfo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.topkInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command topkInfo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkInfo(java.util.List args) {
    return 
topkInfo(args, ar -> { });
  }

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

  /**
   * Redis command topkList.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkList(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.topkList(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command topkList.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkList(java.util.List args) {
    return 
topkList(args, ar -> { });
  }

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

  /**
   * Redis command topkQuery.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkQuery(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.topkQuery(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command topkQuery.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkQuery(java.util.List args) {
    return 
topkQuery(args, ar -> { });
  }

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

  /**
   * Redis command topkReserve.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkReserve(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.topkReserve(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command topkReserve.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI topkReserve(java.util.List args) {
    return 
topkReserve(args, ar -> { });
  }

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

  /**
   * Redis command touch.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI touch(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.touch(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command touch.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI touch(java.util.List args) {
    return 
touch(args, ar -> { });
  }

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

  /**
   * Redis command tsAdd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsAdd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsAdd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsAdd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsAdd(java.util.List args) {
    return 
tsAdd(args, ar -> { });
  }

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

  /**
   * Redis command tsAlter.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsAlter(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsAlter(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsAlter.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsAlter(java.util.List args) {
    return 
tsAlter(args, ar -> { });
  }

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

  /**
   * Redis command tsCreate.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsCreate(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsCreate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsCreate.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsCreate(java.util.List args) {
    return 
tsCreate(args, ar -> { });
  }

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

  /**
   * Redis command tsCreaterule.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsCreaterule(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsCreaterule(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsCreaterule.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsCreaterule(java.util.List args) {
    return 
tsCreaterule(args, ar -> { });
  }

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

  /**
   * Redis command tsDecrby.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsDecrby(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsDecrby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsDecrby.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsDecrby(java.util.List args) {
    return 
tsDecrby(args, ar -> { });
  }

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

  /**
   * Redis command tsDel.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsDel(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsDel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsDel.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsDel(java.util.List args) {
    return 
tsDel(args, ar -> { });
  }

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

  /**
   * Redis command tsDeleterule.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsDeleterule(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsDeleterule(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsDeleterule.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsDeleterule(java.util.List args) {
    return 
tsDeleterule(args, ar -> { });
  }

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

  /**
   * Redis command tsGet.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsGet(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsGet(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsGet.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsGet(java.util.List args) {
    return 
tsGet(args, ar -> { });
  }

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

  /**
   * Redis command tsIncrby.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsIncrby(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsIncrby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsIncrby.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsIncrby(java.util.List args) {
    return 
tsIncrby(args, ar -> { });
  }

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

  /**
   * Redis command tsInfo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsInfo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsInfo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsInfo(java.util.List args) {
    return 
tsInfo(args, ar -> { });
  }

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

  /**
   * Redis command tsMadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsMadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsMadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsMadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsMadd(java.util.List args) {
    return 
tsMadd(args, ar -> { });
  }

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

  /**
   * Redis command tsMget.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsMget(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsMget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsMget.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsMget(java.util.List args) {
    return 
tsMget(args, ar -> { });
  }

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

  /**
   * Redis command tsMrange.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsMrange(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsMrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsMrange.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsMrange(java.util.List args) {
    return 
tsMrange(args, ar -> { });
  }

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

  /**
   * Redis command tsMrevrange.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsMrevrange(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsMrevrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsMrevrange.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsMrevrange(java.util.List args) {
    return 
tsMrevrange(args, ar -> { });
  }

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

  /**
   * Redis command tsQueryindex.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsQueryindex(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsQueryindex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsQueryindex.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsQueryindex(java.util.List args) {
    return 
tsQueryindex(args, ar -> { });
  }

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

  /**
   * Redis command tsRange.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsRange(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsRange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsRange.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsRange(java.util.List args) {
    return 
tsRange(args, ar -> { });
  }

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

  /**
   * Redis command tsRevrange.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsRevrange(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.tsRevrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command tsRevrange.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI tsRevrange(java.util.List args) {
    return 
tsRevrange(args, ar -> { });
  }

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

  /**
   * Redis command ttl.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ttl(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.ttl(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command ttl.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI ttl(java.lang.String arg0) {
    return 
ttl(arg0, ar -> { });
  }

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

  /**
   * Redis command type.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI type(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.type(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command type.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI type(java.lang.String arg0) {
    return 
type(arg0, ar -> { });
  }

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

  /**
   * Redis command unlink.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unlink(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.unlink(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command unlink.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unlink(java.util.List args) {
    return 
unlink(args, ar -> { });
  }

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

  /**
   * Redis command unsubscribe.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unsubscribe(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.unsubscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command unsubscribe.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unsubscribe(java.util.List args) {
    return 
unsubscribe(args, ar -> { });
  }

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

  /**
   * Redis command unwatch.
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unwatch(io.vertx.core.Handler> handler) { 
    delegate.unwatch(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command unwatch.
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI unwatch() {
    return 
unwatch(ar -> { });
  }

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

  /**
   * Redis command wait.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI wait(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.wait(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command wait.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI wait(java.lang.String arg0, java.lang.String arg1) {
    return 
wait(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command watch.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI watch(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.watch(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command watch.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI watch(java.util.List args) {
    return 
watch(args, ar -> { });
  }

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

  /**
   * Redis command xack.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xack(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xack(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xack.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xack(java.util.List args) {
    return 
xack(args, ar -> { });
  }

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

  /**
   * Redis command xadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xadd(java.util.List args) {
    return 
xadd(args, ar -> { });
  }

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

  /**
   * Redis command xautoclaim.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xautoclaim(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xautoclaim(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xautoclaim.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xautoclaim(java.util.List args) {
    return 
xautoclaim(args, ar -> { });
  }

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

  /**
   * Redis command xclaim.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xclaim(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xclaim(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xclaim.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xclaim(java.util.List args) {
    return 
xclaim(args, ar -> { });
  }

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

  /**
   * Redis command xdel.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xdel(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xdel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xdel.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xdel(java.util.List args) {
    return 
xdel(args, ar -> { });
  }

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

  /**
   * Redis command xgroup.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xgroup(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xgroup(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xgroup.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xgroup(java.util.List args) {
    return 
xgroup(args, ar -> { });
  }

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

  /**
   * Redis command xinfo.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xinfo(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xinfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xinfo.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xinfo(java.util.List args) {
    return 
xinfo(args, ar -> { });
  }

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

  /**
   * Redis command xlen.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xlen(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.xlen(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xlen.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xlen(java.lang.String arg0) {
    return 
xlen(arg0, ar -> { });
  }

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

  /**
   * Redis command xpending.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xpending(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xpending(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xpending.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xpending(java.util.List args) {
    return 
xpending(args, ar -> { });
  }

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

  /**
   * Redis command xrange.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xrange(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xrange.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xrange(java.util.List args) {
    return 
xrange(args, ar -> { });
  }

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

  /**
   * Redis command xread.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xread(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xread(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xread.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xread(java.util.List args) {
    return 
xread(args, ar -> { });
  }

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

  /**
   * Redis command xreadgroup.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xreadgroup(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xreadgroup(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xreadgroup.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xreadgroup(java.util.List args) {
    return 
xreadgroup(args, ar -> { });
  }

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

  /**
   * Redis command xrevrange.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xrevrange(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xrevrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xrevrange.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xrevrange(java.util.List args) {
    return 
xrevrange(args, ar -> { });
  }

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

  /**
   * Redis command xsetid.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xsetid(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xsetid(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xsetid.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xsetid(java.util.List args) {
    return 
xsetid(args, ar -> { });
  }

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

  /**
   * Redis command xtrim.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xtrim(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.xtrim(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command xtrim.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI xtrim(java.util.List args) {
    return 
xtrim(args, ar -> { });
  }

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

  /**
   * Redis command zadd.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zadd(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zadd.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zadd(java.util.List args) {
    return 
zadd(args, ar -> { });
  }

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

  /**
   * Redis command zcard.
   * @param arg0 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zcard(java.lang.String arg0, io.vertx.core.Handler> handler) { 
    delegate.zcard(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zcard.
   * @param arg0 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zcard(java.lang.String arg0) {
    return 
zcard(arg0, ar -> { });
  }

    /**
   * Redis command zcard.
   * @param arg0 
   * @return fluent self
   */
  public rx.Single rxZcard(java.lang.String arg0) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.zcount(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zcount.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zcount(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
zcount(arg0, arg1, arg2, ar -> { });
  }

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

  /**
   * Redis command zdiff.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zdiff(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zdiff(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zdiff.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zdiff(java.util.List args) {
    return 
zdiff(args, ar -> { });
  }

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

  /**
   * Redis command zdiffstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zdiffstore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zdiffstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zdiffstore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zdiffstore(java.util.List args) {
    return 
zdiffstore(args, ar -> { });
  }

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

  /**
   * Redis command zincrby.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.zincrby(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zincrby.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
zincrby(arg0, arg1, arg2, ar -> { });
  }

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

  /**
   * Redis command zinter.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zinter(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zinter(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zinter.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zinter(java.util.List args) {
    return 
zinter(args, ar -> { });
  }

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

  /**
   * Redis command zintercard.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zintercard(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zintercard(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zintercard.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zintercard(java.util.List args) {
    return 
zintercard(args, ar -> { });
  }

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

  /**
   * Redis command zinterstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zinterstore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zinterstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zinterstore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zinterstore(java.util.List args) {
    return 
zinterstore(args, ar -> { });
  }

    /**
   * Redis command zinterstore.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxZinterstore(java.util.List args) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.zlexcount(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zlexcount.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zlexcount(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
zlexcount(arg0, arg1, arg2, ar -> { });
  }

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

  /**
   * Redis command zmpop.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zmpop(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zmpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zmpop.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zmpop(java.util.List args) {
    return 
zmpop(args, ar -> { });
  }

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

  /**
   * Redis command zmscore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zmscore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zmscore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zmscore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zmscore(java.util.List args) {
    return 
zmscore(args, ar -> { });
  }

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

  /**
   * Redis command zpopmax.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zpopmax(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zpopmax(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zpopmax.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zpopmax(java.util.List args) {
    return 
zpopmax(args, ar -> { });
  }

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

  /**
   * Redis command zpopmin.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zpopmin(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zpopmin(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zpopmin.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zpopmin(java.util.List args) {
    return 
zpopmin(args, ar -> { });
  }

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

  /**
   * Redis command zrandmember.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrandmember(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zrandmember(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zrandmember.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrandmember(java.util.List args) {
    return 
zrandmember(args, ar -> { });
  }

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

  /**
   * Redis command zrange.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrange(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zrange.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrange(java.util.List args) {
    return 
zrange(args, ar -> { });
  }

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

  /**
   * Redis command zrangebylex.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangebylex(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zrangebylex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zrangebylex.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangebylex(java.util.List args) {
    return 
zrangebylex(args, ar -> { });
  }

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

  /**
   * Redis command zrangebyscore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangebyscore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zrangebyscore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zrangebyscore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangebyscore(java.util.List args) {
    return 
zrangebyscore(args, ar -> { });
  }

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

  /**
   * Redis command zrangestore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangestore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zrangestore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zrangestore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrangestore(java.util.List args) {
    return 
zrangestore(args, ar -> { });
  }

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

  /**
   * Redis command zrank.
   * @param arg0 
   * @param arg1 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrank(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.zrank(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zrank.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrank(java.lang.String arg0, java.lang.String arg1) {
    return 
zrank(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command zrem.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrem(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zrem(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zrem.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrem(java.util.List args) {
    return 
zrem(args, ar -> { });
  }

    /**
   * Redis command zrem.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxZrem(java.util.List args) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.zremrangebylex(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zremrangebylex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebylex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
zremrangebylex(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command zremrangebylex.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxZremrangebylex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.zremrangebyrank(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zremrangebyrank.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebyrank(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
zremrangebyrank(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command zremrangebyrank.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxZremrangebyrank(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, io.vertx.core.Handler> handler) { 
    delegate.zremrangebyscore(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zremrangebyscore.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zremrangebyscore(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) {
    return 
zremrangebyscore(arg0, arg1, arg2, ar -> { });
  }

    /**
   * Redis command zremrangebyscore.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public rx.Single rxZremrangebyscore(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return Single.create(new 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(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zrevrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zrevrange.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrange(java.util.List args) {
    return 
zrevrange(args, ar -> { });
  }

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

  /**
   * Redis command zrevrangebylex.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrangebylex(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zrevrangebylex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zrevrangebylex.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrangebylex(java.util.List args) {
    return 
zrevrangebylex(args, ar -> { });
  }

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

  /**
   * Redis command zrevrangebyscore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrangebyscore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zrevrangebyscore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zrevrangebyscore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrangebyscore(java.util.List args) {
    return 
zrevrangebyscore(args, ar -> { });
  }

    /**
   * Redis command zrevrangebyscore.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxZrevrangebyscore(java.util.List args) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.zrevrank(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zrevrank.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zrevrank(java.lang.String arg0, java.lang.String arg1) {
    return 
zrevrank(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command zscan.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zscan(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zscan(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zscan.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zscan(java.util.List args) {
    return 
zscan(args, ar -> { });
  }

    /**
   * Redis command zscan.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxZscan(java.util.List args) { 
    return Single.create(new 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(java.lang.String arg0, java.lang.String arg1, io.vertx.core.Handler> handler) { 
    delegate.zscore(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zscore.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zscore(java.lang.String arg0, java.lang.String arg1) {
    return 
zscore(arg0, arg1, ar -> { });
  }

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

  /**
   * Redis command zunion.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zunion(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zunion(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zunion.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zunion(java.util.List args) {
    return 
zunion(args, ar -> { });
  }

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

  /**
   * Redis command zunionstore.
   * @param args 
   * @param handler 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zunionstore(java.util.List args, io.vertx.core.Handler> handler) { 
    delegate.zunionstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    return this;
  }

  /**
   * Redis command zunionstore.
   * @param args 
   * @return fluent self
   */
  public io.vertx.rxjava.redis.client.RedisAPI zunionstore(java.util.List args) {
    return 
zunionstore(args, ar -> { });
  }

    /**
   * Redis command zunionstore.
   * @param args 
   * @return fluent self
   */
  public rx.Single rxZunionstore(java.util.List args) { 
    return Single.create(new 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