io.vertx.reactivex.redis.client.RedisAPI Maven / Gradle / Ivy

Go to download
/*
 * 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.reactivex.redis.client;

import io.vertx.reactivex.RxHelper;
import io.vertx.reactivex.ObservableHelper;
import io.vertx.reactivex.FlowableHelper;
import io.vertx.reactivex.impl.AsyncResultMaybe;
import io.vertx.reactivex.impl.AsyncResultSingle;
import io.vertx.reactivex.impl.AsyncResultCompletable;
import io.vertx.reactivex.WriteStreamObserver;
import io.vertx.reactivex.WriteStreamSubscriber;
import java.util.Map;
import java.util.Set;
import java.util.List;
import java.util.Iterator;
import java.util.function.Function;
import java.util.function.Supplier;
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 FT.ADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftAdd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftAdd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.ADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftAdd(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.AGGREGATE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftAggregate(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftAggregate(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.AGGREGATE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtAggregate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftAggregate(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.ALIASADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftAliasadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftAliasadd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.ALIASADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtAliasadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftAliasadd(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.ALIASDEL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftAliasdel(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftAliasdel(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.ALIASDEL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtAliasdel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftAliasdel(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.ALIASUPDATE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftAliasupdate(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftAliasupdate(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.ALIASUPDATE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtAliasupdate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftAliasupdate(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.ALTER.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftAlter(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftAlter(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.ALTER.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtAlter(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftAlter(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.CONFIG.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftConfig(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftConfig(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.CONFIG.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtConfig(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftConfig(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.CREATE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftCreate(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftCreate(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.CREATE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtCreate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftCreate(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.CURSOR.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftCursor(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftCursor(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.CURSOR.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtCursor(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftCursor(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftDebug(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftDebug(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftDebug(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.DEL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftDel(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftDel(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.DEL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtDel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftDel(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.DICTADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftDictadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftDictadd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.DICTADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtDictadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftDictadd(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.DICTDEL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftDictdel(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftDictdel(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.DICTDEL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtDictdel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftDictdel(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.DICTDUMP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftDictdump(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftDictdump(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.DICTDUMP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtDictdump(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftDictdump(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.DROP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftDrop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftDrop(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.DROP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtDrop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftDrop(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.DROPINDEX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftDropindex(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftDropindex(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.DROPINDEX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtDropindex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftDropindex(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.EXPLAIN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftExplain(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftExplain(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.EXPLAIN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtExplain(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftExplain(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.EXPLAINCLI.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftExplaincli(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftExplaincli(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.EXPLAINCLI.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtExplaincli(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftExplaincli(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.GET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftGet(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftGet(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.GET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtGet(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftGet(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.INFO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftInfo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftInfo(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.INFO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftInfo(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.MGET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftMget(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftMget(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.MGET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtMget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftMget(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.PROFILE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftProfile(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftProfile(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.PROFILE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtProfile(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftProfile(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.SAFEADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftSafeadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftSafeadd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.SAFEADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtSafeadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftSafeadd(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.SEARCH.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftSearch(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftSearch(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.SEARCH.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtSearch(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftSearch(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.SPELLCHECK.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftSpellcheck(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftSpellcheck(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.SPELLCHECK.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtSpellcheck(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftSpellcheck(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.SUGADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftSugadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftSugadd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.SUGADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtSugadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftSugadd(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.SUGDEL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftSugdel(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftSugdel(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.SUGDEL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtSugdel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftSugdel(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.SUGGET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftSugget(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftSugget(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.SUGGET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtSugget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftSugget(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.SUGLEN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftSuglen(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftSuglen(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.SUGLEN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtSuglen(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftSuglen(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.SYNADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftSynadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftSynadd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.SYNADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtSynadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftSynadd(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.SYNDUMP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftSyndump(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftSyndump(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.SYNDUMP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtSyndump(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftSyndump(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.SYNUPDATE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftSynupdate(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftSynupdate(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.SYNUPDATE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtSynupdate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftSynupdate(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT.TAGVALS.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftTagvals(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftTagvals(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT.TAGVALS.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtTagvals(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftTagvals(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT._ALIASADDIFNX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftAliasaddifnx(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftAliasaddifnx(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT._ALIASADDIFNX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtAliasaddifnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftAliasaddifnx(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT._ALIASDELIFX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftAliasdelifx(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftAliasdelifx(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT._ALIASDELIFX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtAliasdelifx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftAliasdelifx(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT._ALTERIFNX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftAlterifnx(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftAlterifnx(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT._ALTERIFNX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtAlterifnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftAlterifnx(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT._CREATEIFNX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftCreateifnx(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftCreateifnx(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT._CREATEIFNX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtCreateifnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftCreateifnx(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT._DROPIFX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftDropifx(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftDropifx(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT._DROPIFX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtDropifx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftDropifx(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT._DROPINDEXIFX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftDropindexifx(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftDropindexifx(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT._DROPINDEXIFX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtDropindexifx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftDropindexifx(args).onComplete($handler);
    });
  }

  /**
   * Redis command FT._LIST.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ftList(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ftList(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command FT._LIST.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFtList(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ftList(args).onComplete($handler);
    });
  }

  /**
   * A container for Access List Control commands.
   * 

   * Redis command ACL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future acl(java.util.List args) { 
    io.vertx.core.Future ret = delegate.acl(args).map(val -> val);
    return ret;
  }

  /**
   * A container for Access List Control commands.
   * 

   * Redis command ACL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxAcl(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.acl(args).onComplete($handler);
    });
  }

  /**
   * Append a value to a key.
   * 

   * Redis command APPEND.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future append(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.append(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Append a value to a key.
   * 

   * Redis command APPEND.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxAppend(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.append(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Sent by cluster clients after an -ASK redirect.
   * 

   * Redis command ASKING.
   * @return Future response.
   */
  public io.vertx.core.Future asking() { 
    io.vertx.core.Future ret = delegate.asking().map(val -> val);
    return ret;
  }

  /**
   * Sent by cluster clients after an -ASK redirect.
   * 

   * Redis command ASKING.
   * @return Future response.
   */
  public io.reactivex.Maybe rxAsking() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.asking().onComplete($handler);
    });
  }

  /**
   * Authenticate to the server.
   * 

   * Redis command AUTH.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future auth(java.util.List args) { 
    io.vertx.core.Future ret = delegate.auth(args).map(val -> val);
    return ret;
  }

  /**
   * Authenticate to the server.
   * 

   * Redis command AUTH.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxAuth(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.auth(args).onComplete($handler);
    });
  }

  /**
   * Redis command BF.ADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bfAdd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bfAdd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command BF.ADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBfAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bfAdd(args).onComplete($handler);
    });
  }

  /**
   * Redis command BF.CARD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bfCard(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bfCard(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command BF.CARD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBfCard(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bfCard(args).onComplete($handler);
    });
  }

  /**
   * Redis command BF.DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bfDebug(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bfDebug(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command BF.DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBfDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bfDebug(args).onComplete($handler);
    });
  }

  /**
   * Redis command BF.EXISTS.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bfExists(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bfExists(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command BF.EXISTS.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBfExists(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bfExists(args).onComplete($handler);
    });
  }

  /**
   * Redis command BF.INFO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bfInfo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bfInfo(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command BF.INFO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBfInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bfInfo(args).onComplete($handler);
    });
  }

  /**
   * Redis command BF.INSERT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bfInsert(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bfInsert(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command BF.INSERT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBfInsert(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bfInsert(args).onComplete($handler);
    });
  }

  /**
   * Redis command BF.LOADCHUNK.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bfLoadchunk(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bfLoadchunk(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command BF.LOADCHUNK.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBfLoadchunk(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bfLoadchunk(args).onComplete($handler);
    });
  }

  /**
   * Redis command BF.MADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bfMadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bfMadd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command BF.MADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBfMadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bfMadd(args).onComplete($handler);
    });
  }

  /**
   * Redis command BF.MEXISTS.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bfMexists(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bfMexists(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command BF.MEXISTS.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBfMexists(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bfMexists(args).onComplete($handler);
    });
  }

  /**
   * Redis command BF.RESERVE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bfReserve(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bfReserve(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command BF.RESERVE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBfReserve(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bfReserve(args).onComplete($handler);
    });
  }

  /**
   * Redis command BF.SCANDUMP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bfScandump(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bfScandump(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command BF.SCANDUMP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBfScandump(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bfScandump(args).onComplete($handler);
    });
  }

  /**
   * Asynchronously rewrite the append-only file.
   * 

   * Redis command BGREWRITEAOF.
   * @return Future response.
   */
  public io.vertx.core.Future bgrewriteaof() { 
    io.vertx.core.Future ret = delegate.bgrewriteaof().map(val -> val);
    return ret;
  }

  /**
   * Asynchronously rewrite the append-only file.
   * 

   * Redis command BGREWRITEAOF.
   * @return Future response.
   */
  public io.reactivex.Maybe rxBgrewriteaof() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bgrewriteaof().onComplete($handler);
    });
  }

  /**
   * Asynchronously save the dataset to disk.
   * 

   * Redis command BGSAVE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bgsave(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bgsave(args).map(val -> val);
    return ret;
  }

  /**
   * Asynchronously save the dataset to disk.
   * 

   * Redis command BGSAVE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBgsave(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bgsave(args).onComplete($handler);
    });
  }

  /**
   * Count set bits in a string.
   * 

   * Redis command BITCOUNT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bitcount(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bitcount(args).map(val -> val);
    return ret;
  }

  /**
   * Count set bits in a string.
   * 

   * Redis command BITCOUNT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBitcount(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bitcount(args).onComplete($handler);
    });
  }

  /**
   * Perform arbitrary bitfield integer operations on strings.
   * 

   * Redis command BITFIELD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bitfield(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bitfield(args).map(val -> val);
    return ret;
  }

  /**
   * Perform arbitrary bitfield integer operations on strings.
   * 

   * Redis command BITFIELD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBitfield(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bitfield(args).onComplete($handler);
    });
  }

  /**
   * Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD.
   * 

   * Redis command BITFIELD_RO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bitfieldRo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bitfieldRo(args).map(val -> val);
    return ret;
  }

  /**
   * Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD.
   * 

   * Redis command BITFIELD_RO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBitfieldRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bitfieldRo(args).onComplete($handler);
    });
  }

  /**
   * Perform bitwise operations between strings.
   * 

   * Redis command BITOP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bitop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bitop(args).map(val -> val);
    return ret;
  }

  /**
   * Perform bitwise operations between strings.
   * 

   * Redis command BITOP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBitop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bitop(args).onComplete($handler);
    });
  }

  /**
   * Find first bit set or clear in a string.
   * 

   * Redis command BITPOS.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bitpos(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bitpos(args).map(val -> val);
    return ret;
  }

  /**
   * Find first bit set or clear in a string.
   * 

   * Redis command BITPOS.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBitpos(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bitpos(args).onComplete($handler);
    });
  }

  /**
   * Pop an element from a list, push it to another list and return it; or block until one is available.
   * 

   * Redis command BLMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @param arg4 
   * @return Future response.
   */
  public io.vertx.core.Future blmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3, java.lang.String arg4) { 
    io.vertx.core.Future ret = delegate.blmove(arg0, arg1, arg2, arg3, arg4).map(val -> val);
    return ret;
  }

  /**
   * Pop an element from a list, push it to another list and return it; or block until one is available.
   * 

   * Redis command BLMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @param arg4 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBlmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3, java.lang.String arg4) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.blmove(arg0, arg1, arg2, arg3, arg4).onComplete($handler);
    });
  }

  /**
   * Pop elements from a list, or block until one is available.
   * 

   * Redis command BLMPOP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future blmpop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.blmpop(args).map(val -> val);
    return ret;
  }

  /**
   * Pop elements from a list, or block until one is available.
   * 

   * Redis command BLMPOP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBlmpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.blmpop(args).onComplete($handler);
    });
  }

  /**
   * Remove and get the first element in a list, or block until one is available.
   * 

   * Redis command BLPOP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future blpop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.blpop(args).map(val -> val);
    return ret;
  }

  /**
   * Remove and get the first element in a list, or block until one is available.
   * 

   * Redis command BLPOP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBlpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.blpop(args).onComplete($handler);
    });
  }

  /**
   * Remove and get the last element in a list, or block until one is available.
   * 

   * Redis command BRPOP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future brpop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.brpop(args).map(val -> val);
    return ret;
  }

  /**
   * Remove and get the last element in a list, or block until one is available.
   * 

   * Redis command BRPOP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBrpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.brpop(args).onComplete($handler);
    });
  }

  /**
   * Pop an element from a list, push it to another list and return it; or block until one is available.
   * 

   * Redis command BRPOPLPUSH.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future brpoplpush(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.brpoplpush(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Pop an element from a list, push it to another list and return it; or block until one is available.
   * 

   * Redis command BRPOPLPUSH.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxBrpoplpush(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.brpoplpush(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Remove and return members with scores in a sorted set or block until one is available.
   * 

   * Redis command BZMPOP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bzmpop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bzmpop(args).map(val -> val);
    return ret;
  }

  /**
   * Remove and return members with scores in a sorted set or block until one is available.
   * 

   * Redis command BZMPOP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBzmpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bzmpop(args).onComplete($handler);
    });
  }

  /**
   * Remove and return the member with the highest score from one or more sorted sets, or block until one is available.
   * 

   * Redis command BZPOPMAX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bzpopmax(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bzpopmax(args).map(val -> val);
    return ret;
  }

  /**
   * Remove and return the member with the highest score from one or more sorted sets, or block until one is available.
   * 

   * Redis command BZPOPMAX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBzpopmax(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bzpopmax(args).onComplete($handler);
    });
  }

  /**
   * Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.
   * 

   * Redis command BZPOPMIN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future bzpopmin(java.util.List args) { 
    io.vertx.core.Future ret = delegate.bzpopmin(args).map(val -> val);
    return ret;
  }

  /**
   * Remove and return the member with the lowest score from one or more sorted sets, or block until one is available.
   * 

   * Redis command BZPOPMIN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxBzpopmin(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.bzpopmin(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.ADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfAdd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfAdd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.ADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfAdd(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.ADDNX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfAddnx(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfAddnx(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.ADDNX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfAddnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfAddnx(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.COMPACT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfCompact(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfCompact(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.COMPACT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfCompact(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfCompact(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.COUNT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfCount(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfCount(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.COUNT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfCount(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfCount(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfDebug(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfDebug(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfDebug(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.DEL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfDel(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfDel(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.DEL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfDel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfDel(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.EXISTS.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfExists(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfExists(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.EXISTS.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfExists(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfExists(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.INFO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfInfo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfInfo(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.INFO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfInfo(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.INSERT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfInsert(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfInsert(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.INSERT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfInsert(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfInsert(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.INSERTNX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfInsertnx(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfInsertnx(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.INSERTNX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfInsertnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfInsertnx(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.LOADCHUNK.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfLoadchunk(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfLoadchunk(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.LOADCHUNK.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfLoadchunk(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfLoadchunk(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.MEXISTS.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfMexists(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfMexists(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.MEXISTS.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfMexists(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfMexists(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.RESERVE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfReserve(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfReserve(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.RESERVE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfReserve(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfReserve(args).onComplete($handler);
    });
  }

  /**
   * Redis command CF.SCANDUMP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cfScandump(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cfScandump(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CF.SCANDUMP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCfScandump(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cfScandump(args).onComplete($handler);
    });
  }

  /**
   * A container for client connection commands.
   * 

   * Redis command CLIENT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future client(java.util.List args) { 
    io.vertx.core.Future ret = delegate.client(args).map(val -> val);
    return ret;
  }

  /**
   * A container for client connection commands.
   * 

   * Redis command CLIENT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxClient(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.client(args).onComplete($handler);
    });
  }

  /**
   * A container for cluster commands.
   * 

   * Redis command CLUSTER.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cluster(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cluster(args).map(val -> val);
    return ret;
  }

  /**
   * A container for cluster commands.
   * 

   * Redis command CLUSTER.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCluster(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cluster(args).onComplete($handler);
    });
  }

  /**
   * Redis command CMS.INCRBY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cmsIncrby(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cmsIncrby(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CMS.INCRBY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCmsIncrby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cmsIncrby(args).onComplete($handler);
    });
  }

  /**
   * Redis command CMS.INFO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cmsInfo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cmsInfo(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CMS.INFO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCmsInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cmsInfo(args).onComplete($handler);
    });
  }

  /**
   * Redis command CMS.INITBYDIM.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cmsInitbydim(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cmsInitbydim(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CMS.INITBYDIM.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCmsInitbydim(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cmsInitbydim(args).onComplete($handler);
    });
  }

  /**
   * Redis command CMS.INITBYPROB.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cmsInitbyprob(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cmsInitbyprob(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CMS.INITBYPROB.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCmsInitbyprob(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cmsInitbyprob(args).onComplete($handler);
    });
  }

  /**
   * Redis command CMS.MERGE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cmsMerge(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cmsMerge(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CMS.MERGE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCmsMerge(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cmsMerge(args).onComplete($handler);
    });
  }

  /**
   * Redis command CMS.QUERY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future cmsQuery(java.util.List args) { 
    io.vertx.core.Future ret = delegate.cmsQuery(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command CMS.QUERY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCmsQuery(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.cmsQuery(args).onComplete($handler);
    });
  }

  /**
   * Get array of Redis command details.
   * 

   * Redis command COMMAND.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future command(java.util.List args) { 
    io.vertx.core.Future ret = delegate.command(args).map(val -> val);
    return ret;
  }

  /**
   * Get array of Redis command details.
   * 

   * Redis command COMMAND.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCommand(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.command(args).onComplete($handler);
    });
  }

  /**
   * A container for server configuration commands.
   * 

   * Redis command CONFIG.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future config(java.util.List args) { 
    io.vertx.core.Future ret = delegate.config(args).map(val -> val);
    return ret;
  }

  /**
   * A container for server configuration commands.
   * 

   * Redis command CONFIG.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxConfig(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.config(args).onComplete($handler);
    });
  }

  /**
   * Copy a key.
   * 

   * Redis command COPY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future copy(java.util.List args) { 
    io.vertx.core.Future ret = delegate.copy(args).map(val -> val);
    return ret;
  }

  /**
   * Copy a key.
   * 

   * Redis command COPY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxCopy(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.copy(args).onComplete($handler);
    });
  }

  /**
   * Return the number of keys in the selected database.
   * 

   * Redis command DBSIZE.
   * @return Future response.
   */
  public io.vertx.core.Future dbsize() { 
    io.vertx.core.Future ret = delegate.dbsize().map(val -> val);
    return ret;
  }

  /**
   * Return the number of keys in the selected database.
   * 

   * Redis command DBSIZE.
   * @return Future response.
   */
  public io.reactivex.Maybe rxDbsize() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.dbsize().onComplete($handler);
    });
  }

  /**
   * A container for debugging commands.
   * 

   * Redis command DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future debug(java.util.List args) { 
    io.vertx.core.Future ret = delegate.debug(args).map(val -> val);
    return ret;
  }

  /**
   * A container for debugging commands.
   * 

   * Redis command DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.debug(args).onComplete($handler);
    });
  }

  /**
   * Decrement the integer value of a key by one.
   * 

   * Redis command DECR.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future decr(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.decr(arg0).map(val -> val);
    return ret;
  }

  /**
   * Decrement the integer value of a key by one.
   * 

   * Redis command DECR.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxDecr(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.decr(arg0).onComplete($handler);
    });
  }

  /**
   * Decrement the integer value of a key by the given number.
   * 

   * Redis command DECRBY.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future decrby(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.decrby(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Decrement the integer value of a key by the given number.
   * 

   * Redis command DECRBY.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxDecrby(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.decrby(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Delete a key.
   * 

   * Redis command DEL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future del(java.util.List args) { 
    io.vertx.core.Future ret = delegate.del(args).map(val -> val);
    return ret;
  }

  /**
   * Delete a key.
   * 

   * Redis command DEL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxDel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.del(args).onComplete($handler);
    });
  }

  /**
   * Discard all commands issued after MULTI.
   * 

   * Redis command DISCARD.
   * @return Future response.
   */
  public io.vertx.core.Future discard() { 
    io.vertx.core.Future ret = delegate.discard().map(val -> val);
    return ret;
  }

  /**
   * Discard all commands issued after MULTI.
   * 

   * Redis command DISCARD.
   * @return Future response.
   */
  public io.reactivex.Maybe rxDiscard() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.discard().onComplete($handler);
    });
  }

  /**
   * Return a serialized version of the value stored at the specified key.
   * 

   * Redis command DUMP.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future dump(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.dump(arg0).map(val -> val);
    return ret;
  }

  /**
   * Return a serialized version of the value stored at the specified key.
   * 

   * Redis command DUMP.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxDump(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.dump(arg0).onComplete($handler);
    });
  }

  /**
   * Echo the given string.
   * 

   * Redis command ECHO.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future echo(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.echo(arg0).map(val -> val);
    return ret;
  }

  /**
   * Echo the given string.
   * 

   * Redis command ECHO.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxEcho(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.echo(arg0).onComplete($handler);
    });
  }

  /**
   * Execute a Lua script server side.
   * 

   * Redis command EVAL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future eval(java.util.List args) { 
    io.vertx.core.Future ret = delegate.eval(args).map(val -> val);
    return ret;
  }

  /**
   * Execute a Lua script server side.
   * 

   * Redis command EVAL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxEval(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.eval(args).onComplete($handler);
    });
  }

  /**
   * Execute a read-only Lua script server side.
   * 

   * Redis command EVAL_RO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future evalRo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.evalRo(args).map(val -> val);
    return ret;
  }

  /**
   * Execute a read-only Lua script server side.
   * 

   * Redis command EVAL_RO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxEvalRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.evalRo(args).onComplete($handler);
    });
  }

  /**
   * Execute a Lua script server side.
   * 

   * Redis command EVALSHA.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future evalsha(java.util.List args) { 
    io.vertx.core.Future ret = delegate.evalsha(args).map(val -> val);
    return ret;
  }

  /**
   * Execute a Lua script server side.
   * 

   * Redis command EVALSHA.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxEvalsha(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.evalsha(args).onComplete($handler);
    });
  }

  /**
   * Execute a read-only Lua script server side.
   * 

   * Redis command EVALSHA_RO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future evalshaRo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.evalshaRo(args).map(val -> val);
    return ret;
  }

  /**
   * Execute a read-only Lua script server side.
   * 

   * Redis command EVALSHA_RO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxEvalshaRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.evalshaRo(args).onComplete($handler);
    });
  }

  /**
   * Execute all commands issued after MULTI.
   * 

   * Redis command EXEC.
   * @return Future response.
   */
  public io.vertx.core.Future exec() { 
    io.vertx.core.Future ret = delegate.exec().map(val -> val);
    return ret;
  }

  /**
   * Execute all commands issued after MULTI.
   * 

   * Redis command EXEC.
   * @return Future response.
   */
  public io.reactivex.Maybe rxExec() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.exec().onComplete($handler);
    });
  }

  /**
   * Determine if a key exists.
   * 

   * Redis command EXISTS.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future exists(java.util.List args) { 
    io.vertx.core.Future ret = delegate.exists(args).map(val -> val);
    return ret;
  }

  /**
   * Determine if a key exists.
   * 

   * Redis command EXISTS.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxExists(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.exists(args).onComplete($handler);
    });
  }

  /**
   * Set a key's time to live in seconds.
   * 

   * Redis command EXPIRE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future expire(java.util.List args) { 
    io.vertx.core.Future ret = delegate.expire(args).map(val -> val);
    return ret;
  }

  /**
   * Set a key's time to live in seconds.
   * 

   * Redis command EXPIRE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxExpire(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.expire(args).onComplete($handler);
    });
  }

  /**
   * Set the expiration for a key as a UNIX timestamp.
   * 

   * Redis command EXPIREAT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future expireat(java.util.List args) { 
    io.vertx.core.Future ret = delegate.expireat(args).map(val -> val);
    return ret;
  }

  /**
   * Set the expiration for a key as a UNIX timestamp.
   * 

   * Redis command EXPIREAT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxExpireat(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.expireat(args).onComplete($handler);
    });
  }

  /**
   * Get the expiration Unix timestamp for a key.
   * 

   * Redis command EXPIRETIME.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future expiretime(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.expiretime(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get the expiration Unix timestamp for a key.
   * 

   * Redis command EXPIRETIME.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxExpiretime(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.expiretime(arg0).onComplete($handler);
    });
  }

  /**
   * Start a coordinated failover between this server and one of its replicas.
   * 

   * Redis command FAILOVER.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future failover(java.util.List args) { 
    io.vertx.core.Future ret = delegate.failover(args).map(val -> val);
    return ret;
  }

  /**
   * Start a coordinated failover between this server and one of its replicas.
   * 

   * Redis command FAILOVER.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFailover(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.failover(args).onComplete($handler);
    });
  }

  /**
   * Invoke a function.
   * 

   * Redis command FCALL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future fcall(java.util.List args) { 
    io.vertx.core.Future ret = delegate.fcall(args).map(val -> val);
    return ret;
  }

  /**
   * Invoke a function.
   * 

   * Redis command FCALL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFcall(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.fcall(args).onComplete($handler);
    });
  }

  /**
   * Invoke a read-only function.
   * 

   * Redis command FCALL_RO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future fcallRo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.fcallRo(args).map(val -> val);
    return ret;
  }

  /**
   * Invoke a read-only function.
   * 

   * Redis command FCALL_RO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFcallRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.fcallRo(args).onComplete($handler);
    });
  }

  /**
   * Remove all keys from all databases.
   * 

   * Redis command FLUSHALL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future flushall(java.util.List args) { 
    io.vertx.core.Future ret = delegate.flushall(args).map(val -> val);
    return ret;
  }

  /**
   * Remove all keys from all databases.
   * 

   * Redis command FLUSHALL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFlushall(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.flushall(args).onComplete($handler);
    });
  }

  /**
   * Remove all keys from the current database.
   * 

   * Redis command FLUSHDB.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future flushdb(java.util.List args) { 
    io.vertx.core.Future ret = delegate.flushdb(args).map(val -> val);
    return ret;
  }

  /**
   * Remove all keys from the current database.
   * 

   * Redis command FLUSHDB.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFlushdb(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.flushdb(args).onComplete($handler);
    });
  }

  /**
   * A container for function commands.
   * 

   * Redis command FUNCTION.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future function(java.util.List args) { 
    io.vertx.core.Future ret = delegate.function(args).map(val -> val);
    return ret;
  }

  /**
   * A container for function commands.
   * 

   * Redis command FUNCTION.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxFunction(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.function(args).onComplete($handler);
    });
  }

  /**
   * Add one or more geospatial items in the geospatial index represented using a sorted set.
   * 

   * Redis command GEOADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future geoadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.geoadd(args).map(val -> val);
    return ret;
  }

  /**
   * Add one or more geospatial items in the geospatial index represented using a sorted set.
   * 

   * Redis command GEOADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGeoadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.geoadd(args).onComplete($handler);
    });
  }

  /**
   * Returns the distance between two members of a geospatial index.
   * 

   * Redis command GEODIST.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future geodist(java.util.List args) { 
    io.vertx.core.Future ret = delegate.geodist(args).map(val -> val);
    return ret;
  }

  /**
   * Returns the distance between two members of a geospatial index.
   * 

   * Redis command GEODIST.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGeodist(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.geodist(args).onComplete($handler);
    });
  }

  /**
   * Returns members of a geospatial index as standard geohash strings.
   * 

   * Redis command GEOHASH.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future geohash(java.util.List args) { 
    io.vertx.core.Future ret = delegate.geohash(args).map(val -> val);
    return ret;
  }

  /**
   * Returns members of a geospatial index as standard geohash strings.
   * 

   * Redis command GEOHASH.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGeohash(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.geohash(args).onComplete($handler);
    });
  }

  /**
   * Returns longitude and latitude of members of a geospatial index.
   * 

   * Redis command GEOPOS.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future geopos(java.util.List args) { 
    io.vertx.core.Future ret = delegate.geopos(args).map(val -> val);
    return ret;
  }

  /**
   * Returns longitude and latitude of members of a geospatial index.
   * 

   * Redis command GEOPOS.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGeopos(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.geopos(args).onComplete($handler);
    });
  }

  /**
   * Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
   * 

   * Redis command GEORADIUS.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future georadius(java.util.List args) { 
    io.vertx.core.Future ret = delegate.georadius(args).map(val -> val);
    return ret;
  }

  /**
   * Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point.
   * 

   * Redis command GEORADIUS.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxGeoradius(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.georadius(args).onComplete($handler);
    });
  }

  /**
   * A read-only variant for GEORADIUS.
   * 

   * Redis command GEORADIUS_RO.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future georadiusRo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.georadiusRo(args).map(val -> val);
    return ret;
  }

  /**
   * A read-only variant for GEORADIUS.
   * 

   * Redis command GEORADIUS_RO.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxGeoradiusRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.georadiusRo(args).onComplete($handler);
    });
  }

  /**
   * Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
   * 

   * Redis command GEORADIUSBYMEMBER.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future georadiusbymember(java.util.List args) { 
    io.vertx.core.Future ret = delegate.georadiusbymember(args).map(val -> val);
    return ret;
  }

  /**
   * Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member.
   * 

   * Redis command GEORADIUSBYMEMBER.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxGeoradiusbymember(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.georadiusbymember(args).onComplete($handler);
    });
  }

  /**
   * A read-only variant for GEORADIUSBYMEMBER.
   * 

   * Redis command GEORADIUSBYMEMBER_RO.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future georadiusbymemberRo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.georadiusbymemberRo(args).map(val -> val);
    return ret;
  }

  /**
   * A read-only variant for GEORADIUSBYMEMBER.
   * 

   * Redis command GEORADIUSBYMEMBER_RO.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxGeoradiusbymemberRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.georadiusbymemberRo(args).onComplete($handler);
    });
  }

  /**
   * Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
   * 

   * Redis command GEOSEARCH.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future geosearch(java.util.List args) { 
    io.vertx.core.Future ret = delegate.geosearch(args).map(val -> val);
    return ret;
  }

  /**
   * Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.
   * 

   * Redis command GEOSEARCH.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGeosearch(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.geosearch(args).onComplete($handler);
    });
  }

  /**
   * Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.
   * 

   * Redis command GEOSEARCHSTORE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future geosearchstore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.geosearchstore(args).map(val -> val);
    return ret;
  }

  /**
   * Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.
   * 

   * Redis command GEOSEARCHSTORE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGeosearchstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.geosearchstore(args).onComplete($handler);
    });
  }

  /**
   * Get the value of a key.
   * 

   * Redis command GET.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future get(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.get(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get the value of a key.
   * 

   * Redis command GET.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGet(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.get(arg0).onComplete($handler);
    });
  }

  /**
   * Returns the bit value at offset in the string value stored at key.
   * 

   * Redis command GETBIT.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future getbit(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.getbit(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Returns the bit value at offset in the string value stored at key.
   * 

   * Redis command GETBIT.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGetbit(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.getbit(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Get the value of a key and delete the key.
   * 

   * Redis command GETDEL.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future getdel(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.getdel(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get the value of a key and delete the key.
   * 

   * Redis command GETDEL.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGetdel(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.getdel(arg0).onComplete($handler);
    });
  }

  /**
   * Get the value of a key and optionally set its expiration.
   * 

   * Redis command GETEX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future getex(java.util.List args) { 
    io.vertx.core.Future ret = delegate.getex(args).map(val -> val);
    return ret;
  }

  /**
   * Get the value of a key and optionally set its expiration.
   * 

   * Redis command GETEX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGetex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.getex(args).onComplete($handler);
    });
  }

  /**
   * Get a substring of the string stored at a key.
   * 

   * Redis command GETRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future getrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.getrange(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Get a substring of the string stored at a key.
   * 

   * Redis command GETRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGetrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.getrange(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Set the string value of a key and return its old value.
   * 

   * Redis command GETSET.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future getset(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.getset(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Set the string value of a key and return its old value.
   * 

   * Redis command GETSET.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxGetset(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.getset(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Redis command GRAPH.BULK.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future graphBulk(java.util.List args) { 
    io.vertx.core.Future ret = delegate.graphBulk(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command GRAPH.BULK.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGraphBulk(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.graphBulk(args).onComplete($handler);
    });
  }

  /**
   * Redis command GRAPH.CONFIG.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future graphConfig(java.util.List args) { 
    io.vertx.core.Future ret = delegate.graphConfig(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command GRAPH.CONFIG.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGraphConfig(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.graphConfig(args).onComplete($handler);
    });
  }

  /**
   * Redis command GRAPH.DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future graphDebug(java.util.List args) { 
    io.vertx.core.Future ret = delegate.graphDebug(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command GRAPH.DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGraphDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.graphDebug(args).onComplete($handler);
    });
  }

  /**
   * Redis command GRAPH.DELETE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future graphDelete(java.util.List args) { 
    io.vertx.core.Future ret = delegate.graphDelete(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command GRAPH.DELETE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGraphDelete(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.graphDelete(args).onComplete($handler);
    });
  }

  /**
   * Redis command GRAPH.EXPLAIN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future graphExplain(java.util.List args) { 
    io.vertx.core.Future ret = delegate.graphExplain(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command GRAPH.EXPLAIN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGraphExplain(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.graphExplain(args).onComplete($handler);
    });
  }

  /**
   * Redis command GRAPH.LIST.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future graphList(java.util.List args) { 
    io.vertx.core.Future ret = delegate.graphList(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command GRAPH.LIST.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGraphList(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.graphList(args).onComplete($handler);
    });
  }

  /**
   * Redis command GRAPH.PROFILE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future graphProfile(java.util.List args) { 
    io.vertx.core.Future ret = delegate.graphProfile(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command GRAPH.PROFILE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGraphProfile(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.graphProfile(args).onComplete($handler);
    });
  }

  /**
   * Redis command GRAPH.QUERY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future graphQuery(java.util.List args) { 
    io.vertx.core.Future ret = delegate.graphQuery(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command GRAPH.QUERY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGraphQuery(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.graphQuery(args).onComplete($handler);
    });
  }

  /**
   * Redis command GRAPH.RO_QUERY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future graphRoQuery(java.util.List args) { 
    io.vertx.core.Future ret = delegate.graphRoQuery(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command GRAPH.RO_QUERY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGraphRoQuery(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.graphRoQuery(args).onComplete($handler);
    });
  }

  /**
   * Redis command GRAPH.SLOWLOG.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future graphSlowlog(java.util.List args) { 
    io.vertx.core.Future ret = delegate.graphSlowlog(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command GRAPH.SLOWLOG.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxGraphSlowlog(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.graphSlowlog(args).onComplete($handler);
    });
  }

  /**
   * Delete one or more hash fields.
   * 

   * Redis command HDEL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future hdel(java.util.List args) { 
    io.vertx.core.Future ret = delegate.hdel(args).map(val -> val);
    return ret;
  }

  /**
   * Delete one or more hash fields.
   * 

   * Redis command HDEL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHdel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hdel(args).onComplete($handler);
    });
  }

  /**
   * Handshake with Redis.
   * 

   * Redis command HELLO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future hello(java.util.List args) { 
    io.vertx.core.Future ret = delegate.hello(args).map(val -> val);
    return ret;
  }

  /**
   * Handshake with Redis.
   * 

   * Redis command HELLO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHello(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hello(args).onComplete($handler);
    });
  }

  /**
   * Determine if a hash field exists.
   * 

   * Redis command HEXISTS.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future hexists(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.hexists(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Determine if a hash field exists.
   * 

   * Redis command HEXISTS.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHexists(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hexists(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Get the value of a hash field.
   * 

   * Redis command HGET.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future hget(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.hget(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Get the value of a hash field.
   * 

   * Redis command HGET.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHget(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hget(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Get all the fields and values in a hash.
   * 

   * Redis command HGETALL.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future hgetall(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.hgetall(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get all the fields and values in a hash.
   * 

   * Redis command HGETALL.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHgetall(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hgetall(arg0).onComplete($handler);
    });
  }

  /**
   * Increment the integer value of a hash field by the given number.
   * 

   * Redis command HINCRBY.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future hincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.hincrby(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Increment the integer value of a hash field by the given number.
   * 

   * Redis command HINCRBY.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hincrby(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Increment the float value of a hash field by the given amount.
   * 

   * Redis command HINCRBYFLOAT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future hincrbyfloat(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.hincrbyfloat(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Increment the float value of a hash field by the given amount.
   * 

   * Redis command HINCRBYFLOAT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHincrbyfloat(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hincrbyfloat(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Get all the fields in a hash.
   * 

   * Redis command HKEYS.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future hkeys(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.hkeys(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get all the fields in a hash.
   * 

   * Redis command HKEYS.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHkeys(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hkeys(arg0).onComplete($handler);
    });
  }

  /**
   * Get the number of fields in a hash.
   * 

   * Redis command HLEN.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future hlen(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.hlen(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get the number of fields in a hash.
   * 

   * Redis command HLEN.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHlen(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hlen(arg0).onComplete($handler);
    });
  }

  /**
   * Get the values of all the given hash fields.
   * 

   * Redis command HMGET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future hmget(java.util.List args) { 
    io.vertx.core.Future ret = delegate.hmget(args).map(val -> val);
    return ret;
  }

  /**
   * Get the values of all the given hash fields.
   * 

   * Redis command HMGET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHmget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hmget(args).onComplete($handler);
    });
  }

  /**
   * Set multiple hash fields to multiple values.
   * 

   * Redis command HMSET.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future hmset(java.util.List args) { 
    io.vertx.core.Future ret = delegate.hmset(args).map(val -> val);
    return ret;
  }

  /**
   * Set multiple hash fields to multiple values.
   * 

   * Redis command HMSET.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxHmset(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hmset(args).onComplete($handler);
    });
  }

  /**
   * Get one or multiple random fields from a hash.
   * 

   * Redis command HRANDFIELD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future hrandfield(java.util.List args) { 
    io.vertx.core.Future ret = delegate.hrandfield(args).map(val -> val);
    return ret;
  }

  /**
   * Get one or multiple random fields from a hash.
   * 

   * Redis command HRANDFIELD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHrandfield(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hrandfield(args).onComplete($handler);
    });
  }

  /**
   * Incrementally iterate hash fields and associated values.
   * 

   * Redis command HSCAN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future hscan(java.util.List args) { 
    io.vertx.core.Future ret = delegate.hscan(args).map(val -> val);
    return ret;
  }

  /**
   * Incrementally iterate hash fields and associated values.
   * 

   * Redis command HSCAN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHscan(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hscan(args).onComplete($handler);
    });
  }

  /**
   * Set the string value of a hash field.
   * 

   * Redis command HSET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future hset(java.util.List args) { 
    io.vertx.core.Future ret = delegate.hset(args).map(val -> val);
    return ret;
  }

  /**
   * Set the string value of a hash field.
   * 

   * Redis command HSET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHset(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hset(args).onComplete($handler);
    });
  }

  /**
   * Set the value of a hash field, only if the field does not exist.
   * 

   * Redis command HSETNX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future hsetnx(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.hsetnx(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Set the value of a hash field, only if the field does not exist.
   * 

   * Redis command HSETNX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHsetnx(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hsetnx(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Get the length of the value of a hash field.
   * 

   * Redis command HSTRLEN.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future hstrlen(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.hstrlen(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Get the length of the value of a hash field.
   * 

   * Redis command HSTRLEN.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHstrlen(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hstrlen(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Get all the values in a hash.
   * 

   * Redis command HVALS.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future hvals(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.hvals(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get all the values in a hash.
   * 

   * Redis command HVALS.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxHvals(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.hvals(arg0).onComplete($handler);
    });
  }

  /**
   * Increment the integer value of a key by one.
   * 

   * Redis command INCR.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future incr(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.incr(arg0).map(val -> val);
    return ret;
  }

  /**
   * Increment the integer value of a key by one.
   * 

   * Redis command INCR.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxIncr(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.incr(arg0).onComplete($handler);
    });
  }

  /**
   * Increment the integer value of a key by the given amount.
   * 

   * Redis command INCRBY.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future incrby(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.incrby(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Increment the integer value of a key by the given amount.
   * 

   * Redis command INCRBY.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxIncrby(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.incrby(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Increment the float value of a key by the given amount.
   * 

   * Redis command INCRBYFLOAT.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future incrbyfloat(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.incrbyfloat(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Increment the float value of a key by the given amount.
   * 

   * Redis command INCRBYFLOAT.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxIncrbyfloat(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.incrbyfloat(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Get information and statistics about the server.
   * 

   * Redis command INFO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future info(java.util.List args) { 
    io.vertx.core.Future ret = delegate.info(args).map(val -> val);
    return ret;
  }

  /**
   * Get information and statistics about the server.
   * 

   * Redis command INFO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.info(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.ARRAPPEND.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonArrappend(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonArrappend(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.ARRAPPEND.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonArrappend(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonArrappend(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.ARRINDEX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonArrindex(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonArrindex(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.ARRINDEX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonArrindex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonArrindex(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.ARRINSERT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonArrinsert(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonArrinsert(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.ARRINSERT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonArrinsert(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonArrinsert(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.ARRLEN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonArrlen(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonArrlen(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.ARRLEN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonArrlen(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonArrlen(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.ARRPOP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonArrpop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonArrpop(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.ARRPOP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonArrpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonArrpop(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.ARRTRIM.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonArrtrim(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonArrtrim(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.ARRTRIM.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonArrtrim(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonArrtrim(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.CLEAR.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonClear(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonClear(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.CLEAR.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonClear(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonClear(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonDebug(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonDebug(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.DEBUG.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonDebug(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.DEL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonDel(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonDel(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.DEL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonDel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonDel(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.FORGET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonForget(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonForget(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.FORGET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonForget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonForget(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.GET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonGet(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonGet(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.GET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonGet(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonGet(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.MGET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonMget(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonMget(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.MGET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonMget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonMget(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.NUMINCRBY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonNumincrby(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonNumincrby(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.NUMINCRBY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonNumincrby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonNumincrby(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.NUMMULTBY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonNummultby(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonNummultby(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.NUMMULTBY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonNummultby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonNummultby(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.NUMPOWBY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonNumpowby(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonNumpowby(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.NUMPOWBY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonNumpowby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonNumpowby(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.OBJKEYS.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonObjkeys(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonObjkeys(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.OBJKEYS.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonObjkeys(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonObjkeys(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.OBJLEN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonObjlen(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonObjlen(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.OBJLEN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonObjlen(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonObjlen(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.RESP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonResp(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonResp(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.RESP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonResp(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonResp(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.SET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonSet(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonSet(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.SET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonSet(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonSet(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.STRAPPEND.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonStrappend(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonStrappend(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.STRAPPEND.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonStrappend(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonStrappend(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.STRLEN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonStrlen(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonStrlen(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.STRLEN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonStrlen(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonStrlen(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.TOGGLE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonToggle(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonToggle(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.TOGGLE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonToggle(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonToggle(args).onComplete($handler);
    });
  }

  /**
   * Redis command JSON.TYPE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future jsonType(java.util.List args) { 
    io.vertx.core.Future ret = delegate.jsonType(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command JSON.TYPE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxJsonType(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.jsonType(args).onComplete($handler);
    });
  }

  /**
   * Find all keys matching the given pattern.
   * 

   * Redis command KEYS.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future keys(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.keys(arg0).map(val -> val);
    return ret;
  }

  /**
   * Find all keys matching the given pattern.
   * 

   * Redis command KEYS.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxKeys(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.keys(arg0).onComplete($handler);
    });
  }

  /**
   * Get the UNIX time stamp of the last successful save to disk.
   * 

   * Redis command LASTSAVE.
   * @return Future response.
   */
  public io.vertx.core.Future lastsave() { 
    io.vertx.core.Future ret = delegate.lastsave().map(val -> val);
    return ret;
  }

  /**
   * Get the UNIX time stamp of the last successful save to disk.
   * 

   * Redis command LASTSAVE.
   * @return Future response.
   */
  public io.reactivex.Maybe rxLastsave() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lastsave().onComplete($handler);
    });
  }

  /**
   * A container for latency diagnostics commands.
   * 

   * Redis command LATENCY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future latency(java.util.List args) { 
    io.vertx.core.Future ret = delegate.latency(args).map(val -> val);
    return ret;
  }

  /**
   * A container for latency diagnostics commands.
   * 

   * Redis command LATENCY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLatency(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.latency(args).onComplete($handler);
    });
  }

  /**
   * Find longest common substring.
   * 

   * Redis command LCS.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future lcs(java.util.List args) { 
    io.vertx.core.Future ret = delegate.lcs(args).map(val -> val);
    return ret;
  }

  /**
   * Find longest common substring.
   * 

   * Redis command LCS.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLcs(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lcs(args).onComplete($handler);
    });
  }

  /**
   * Get an element from a list by its index.
   * 

   * Redis command LINDEX.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future lindex(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.lindex(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Get an element from a list by its index.
   * 

   * Redis command LINDEX.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLindex(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lindex(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Insert an element before or after another element in a list.
   * 

   * Redis command LINSERT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return Future response.
   */
  public io.vertx.core.Future linsert(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3) { 
    io.vertx.core.Future ret = delegate.linsert(arg0, arg1, arg2, arg3).map(val -> val);
    return ret;
  }

  /**
   * Insert an element before or after another element in a list.
   * 

   * Redis command LINSERT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLinsert(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.linsert(arg0, arg1, arg2, arg3).onComplete($handler);
    });
  }

  /**
   * Get the length of a list.
   * 

   * Redis command LLEN.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future llen(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.llen(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get the length of a list.
   * 

   * Redis command LLEN.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLlen(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.llen(arg0).onComplete($handler);
    });
  }

  /**
   * Pop an element from a list, push it to another list and return it.
   * 

   * Redis command LMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return Future response.
   */
  public io.vertx.core.Future lmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3) { 
    io.vertx.core.Future ret = delegate.lmove(arg0, arg1, arg2, arg3).map(val -> val);
    return ret;
  }

  /**
   * Pop an element from a list, push it to another list and return it.
   * 

   * Redis command LMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lmove(arg0, arg1, arg2, arg3).onComplete($handler);
    });
  }

  /**
   * Pop elements from a list.
   * 

   * Redis command LMPOP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future lmpop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.lmpop(args).map(val -> val);
    return ret;
  }

  /**
   * Pop elements from a list.
   * 

   * Redis command LMPOP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLmpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lmpop(args).onComplete($handler);
    });
  }

  /**
   * Display some computer art and the Redis version.
   * 

   * Redis command LOLWUT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future lolwut(java.util.List args) { 
    io.vertx.core.Future ret = delegate.lolwut(args).map(val -> val);
    return ret;
  }

  /**
   * Display some computer art and the Redis version.
   * 

   * Redis command LOLWUT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLolwut(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lolwut(args).onComplete($handler);
    });
  }

  /**
   * Remove and get the first elements in a list.
   * 

   * Redis command LPOP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future lpop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.lpop(args).map(val -> val);
    return ret;
  }

  /**
   * Remove and get the first elements in a list.
   * 

   * Redis command LPOP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lpop(args).onComplete($handler);
    });
  }

  /**
   * Return the index of matching elements on a list.
   * 

   * Redis command LPOS.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future lpos(java.util.List args) { 
    io.vertx.core.Future ret = delegate.lpos(args).map(val -> val);
    return ret;
  }

  /**
   * Return the index of matching elements on a list.
   * 

   * Redis command LPOS.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLpos(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lpos(args).onComplete($handler);
    });
  }

  /**
   * Prepend one or multiple elements to a list.
   * 

   * Redis command LPUSH.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future lpush(java.util.List args) { 
    io.vertx.core.Future ret = delegate.lpush(args).map(val -> val);
    return ret;
  }

  /**
   * Prepend one or multiple elements to a list.
   * 

   * Redis command LPUSH.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLpush(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lpush(args).onComplete($handler);
    });
  }

  /**
   * Prepend an element to a list, only if the list exists.
   * 

   * Redis command LPUSHX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future lpushx(java.util.List args) { 
    io.vertx.core.Future ret = delegate.lpushx(args).map(val -> val);
    return ret;
  }

  /**
   * Prepend an element to a list, only if the list exists.
   * 

   * Redis command LPUSHX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLpushx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lpushx(args).onComplete($handler);
    });
  }

  /**
   * Get a range of elements from a list.
   * 

   * Redis command LRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future lrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.lrange(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Get a range of elements from a list.
   * 

   * Redis command LRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lrange(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Remove elements from a list.
   * 

   * Redis command LREM.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future lrem(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.lrem(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Remove elements from a list.
   * 

   * Redis command LREM.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLrem(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lrem(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Set the value of an element in a list by its index.
   * 

   * Redis command LSET.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future lset(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.lset(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Set the value of an element in a list by its index.
   * 

   * Redis command LSET.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLset(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.lset(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Trim a list to the specified range.
   * 

   * Redis command LTRIM.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future ltrim(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.ltrim(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Trim a list to the specified range.
   * 

   * Redis command LTRIM.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxLtrim(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ltrim(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * A container for memory diagnostics commands.
   * 

   * Redis command MEMORY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future memory(java.util.List args) { 
    io.vertx.core.Future ret = delegate.memory(args).map(val -> val);
    return ret;
  }

  /**
   * A container for memory diagnostics commands.
   * 

   * Redis command MEMORY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxMemory(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.memory(args).onComplete($handler);
    });
  }

  /**
   * Get the values of all the given keys.
   * 

   * Redis command MGET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future mget(java.util.List args) { 
    io.vertx.core.Future ret = delegate.mget(args).map(val -> val);
    return ret;
  }

  /**
   * Get the values of all the given keys.
   * 

   * Redis command MGET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxMget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.mget(args).onComplete($handler);
    });
  }

  /**
   * Atomically transfer a key from a Redis instance to another one.
   * 

   * Redis command MIGRATE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future migrate(java.util.List args) { 
    io.vertx.core.Future ret = delegate.migrate(args).map(val -> val);
    return ret;
  }

  /**
   * Atomically transfer a key from a Redis instance to another one.
   * 

   * Redis command MIGRATE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxMigrate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.migrate(args).onComplete($handler);
    });
  }

  /**
   * A container for module commands.
   * 

   * Redis command MODULE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future module(java.util.List args) { 
    io.vertx.core.Future ret = delegate.module(args).map(val -> val);
    return ret;
  }

  /**
   * A container for module commands.
   * 

   * Redis command MODULE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxModule(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.module(args).onComplete($handler);
    });
  }

  /**
   * Listen for all requests received by the server in real time.
   * 

   * Redis command MONITOR.
   * @return Future response.
   */
  public io.vertx.core.Future monitor() { 
    io.vertx.core.Future ret = delegate.monitor().map(val -> val);
    return ret;
  }

  /**
   * Listen for all requests received by the server in real time.
   * 

   * Redis command MONITOR.
   * @return Future response.
   */
  public io.reactivex.Maybe rxMonitor() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.monitor().onComplete($handler);
    });
  }

  /**
   * Move a key to another database.
   * 

   * Redis command MOVE.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future move(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.move(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Move a key to another database.
   * 

   * Redis command MOVE.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxMove(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.move(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Set multiple keys to multiple values.
   * 

   * Redis command MSET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future mset(java.util.List args) { 
    io.vertx.core.Future ret = delegate.mset(args).map(val -> val);
    return ret;
  }

  /**
   * Set multiple keys to multiple values.
   * 

   * Redis command MSET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxMset(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.mset(args).onComplete($handler);
    });
  }

  /**
   * Set multiple keys to multiple values, only if none of the keys exist.
   * 

   * Redis command MSETNX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future msetnx(java.util.List args) { 
    io.vertx.core.Future ret = delegate.msetnx(args).map(val -> val);
    return ret;
  }

  /**
   * Set multiple keys to multiple values, only if none of the keys exist.
   * 

   * Redis command MSETNX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxMsetnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.msetnx(args).onComplete($handler);
    });
  }

  /**
   * Mark the start of a transaction block.
   * 

   * Redis command MULTI.
   * @return Future response.
   */
  public io.vertx.core.Future multi() { 
    io.vertx.core.Future ret = delegate.multi().map(val -> val);
    return ret;
  }

  /**
   * Mark the start of a transaction block.
   * 

   * Redis command MULTI.
   * @return Future response.
   */
  public io.reactivex.Maybe rxMulti() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.multi().onComplete($handler);
    });
  }

  /**
   * A container for object introspection commands.
   * 

   * Redis command OBJECT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future object(java.util.List args) { 
    io.vertx.core.Future ret = delegate.object(args).map(val -> val);
    return ret;
  }

  /**
   * A container for object introspection commands.
   * 

   * Redis command OBJECT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxObject(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.object(args).onComplete($handler);
    });
  }

  /**
   * Remove the expiration from a key.
   * 

   * Redis command PERSIST.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future persist(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.persist(arg0).map(val -> val);
    return ret;
  }

  /**
   * Remove the expiration from a key.
   * 

   * Redis command PERSIST.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPersist(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.persist(arg0).onComplete($handler);
    });
  }

  /**
   * Set a key's time to live in milliseconds.
   * 

   * Redis command PEXPIRE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future pexpire(java.util.List args) { 
    io.vertx.core.Future ret = delegate.pexpire(args).map(val -> val);
    return ret;
  }

  /**
   * Set a key's time to live in milliseconds.
   * 

   * Redis command PEXPIRE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPexpire(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.pexpire(args).onComplete($handler);
    });
  }

  /**
   * Set the expiration for a key as a UNIX timestamp specified in milliseconds.
   * 

   * Redis command PEXPIREAT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future pexpireat(java.util.List args) { 
    io.vertx.core.Future ret = delegate.pexpireat(args).map(val -> val);
    return ret;
  }

  /**
   * Set the expiration for a key as a UNIX timestamp specified in milliseconds.
   * 

   * Redis command PEXPIREAT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPexpireat(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.pexpireat(args).onComplete($handler);
    });
  }

  /**
   * Get the expiration Unix timestamp for a key in milliseconds.
   * 

   * Redis command PEXPIRETIME.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future pexpiretime(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.pexpiretime(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get the expiration Unix timestamp for a key in milliseconds.
   * 

   * Redis command PEXPIRETIME.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPexpiretime(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.pexpiretime(arg0).onComplete($handler);
    });
  }

  /**
   * Adds the specified elements to the specified HyperLogLog.
   * 

   * Redis command PFADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future pfadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.pfadd(args).map(val -> val);
    return ret;
  }

  /**
   * Adds the specified elements to the specified HyperLogLog.
   * 

   * Redis command PFADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPfadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.pfadd(args).onComplete($handler);
    });
  }

  /**
   * Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
   * 

   * Redis command PFCOUNT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future pfcount(java.util.List args) { 
    io.vertx.core.Future ret = delegate.pfcount(args).map(val -> val);
    return ret;
  }

  /**
   * Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).
   * 

   * Redis command PFCOUNT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPfcount(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.pfcount(args).onComplete($handler);
    });
  }

  /**
   * Internal commands for debugging HyperLogLog values.
   * 

   * Redis command PFDEBUG.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future pfdebug(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.pfdebug(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Internal commands for debugging HyperLogLog values.
   * 

   * Redis command PFDEBUG.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPfdebug(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.pfdebug(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Merge N different HyperLogLogs into a single one.
   * 

   * Redis command PFMERGE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future pfmerge(java.util.List args) { 
    io.vertx.core.Future ret = delegate.pfmerge(args).map(val -> val);
    return ret;
  }

  /**
   * Merge N different HyperLogLogs into a single one.
   * 

   * Redis command PFMERGE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPfmerge(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.pfmerge(args).onComplete($handler);
    });
  }

  /**
   * An internal command for testing HyperLogLog values.
   * 

   * Redis command PFSELFTEST.
   * @return Future response.
   */
  public io.vertx.core.Future pfselftest() { 
    io.vertx.core.Future ret = delegate.pfselftest().map(val -> val);
    return ret;
  }

  /**
   * An internal command for testing HyperLogLog values.
   * 

   * Redis command PFSELFTEST.
   * @return Future response.
   */
  public io.reactivex.Maybe rxPfselftest() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.pfselftest().onComplete($handler);
    });
  }

  /**
   * Ping the server.
   * 

   * Redis command PING.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ping(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ping(args).map(val -> val);
    return ret;
  }

  /**
   * Ping the server.
   * 

   * Redis command PING.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPing(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ping(args).onComplete($handler);
    });
  }

  /**
   * Set the value and expiration in milliseconds of a key.
   * 

   * Redis command PSETEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future psetex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.psetex(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Set the value and expiration in milliseconds of a key.
   * 

   * Redis command PSETEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPsetex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.psetex(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Listen for messages published to channels matching the given patterns.
   * 

   * Redis command PSUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future psubscribe(java.util.List args) { 
    io.vertx.core.Future ret = delegate.psubscribe(args).map(val -> val);
    return ret;
  }

  /**
   * Listen for messages published to channels matching the given patterns.
   * 

   * Redis command PSUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPsubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.psubscribe(args).onComplete($handler);
    });
  }

  /**
   * Internal command used for replication.
   * 

   * Redis command PSYNC.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future psync(java.util.List args) { 
    io.vertx.core.Future ret = delegate.psync(args).map(val -> val);
    return ret;
  }

  /**
   * Internal command used for replication.
   * 

   * Redis command PSYNC.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPsync(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.psync(args).onComplete($handler);
    });
  }

  /**
   * Get the time to live for a key in milliseconds.
   * 

   * Redis command PTTL.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future pttl(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.pttl(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get the time to live for a key in milliseconds.
   * 

   * Redis command PTTL.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPttl(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.pttl(arg0).onComplete($handler);
    });
  }

  /**
   * Post a message to a channel.
   * 

   * Redis command PUBLISH.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future publish(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.publish(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Post a message to a channel.
   * 

   * Redis command PUBLISH.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPublish(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.publish(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * A container for Pub/Sub commands.
   * 

   * Redis command PUBSUB.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future pubsub(java.util.List args) { 
    io.vertx.core.Future ret = delegate.pubsub(args).map(val -> val);
    return ret;
  }

  /**
   * A container for Pub/Sub commands.
   * 

   * Redis command PUBSUB.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPubsub(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.pubsub(args).onComplete($handler);
    });
  }

  /**
   * Stop listening for messages posted to channels matching the given patterns.
   * 

   * Redis command PUNSUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future punsubscribe(java.util.List args) { 
    io.vertx.core.Future ret = delegate.punsubscribe(args).map(val -> val);
    return ret;
  }

  /**
   * Stop listening for messages posted to channels matching the given patterns.
   * 

   * Redis command PUNSUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxPunsubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.punsubscribe(args).onComplete($handler);
    });
  }

  /**
   * Close the connection.
   * 

   * Redis command QUIT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future quit(java.util.List args) { 
    io.vertx.core.Future ret = delegate.quit(args).map(val -> val);
    return ret;
  }

  /**
   * Close the connection.
   * 

   * Redis command QUIT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxQuit(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.quit(args).onComplete($handler);
    });
  }

  /**
   * Return a random key from the keyspace.
   * 

   * Redis command RANDOMKEY.
   * @return Future response.
   */
  public io.vertx.core.Future randomkey() { 
    io.vertx.core.Future ret = delegate.randomkey().map(val -> val);
    return ret;
  }

  /**
   * Return a random key from the keyspace.
   * 

   * Redis command RANDOMKEY.
   * @return Future response.
   */
  public io.reactivex.Maybe rxRandomkey() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.randomkey().onComplete($handler);
    });
  }

  /**
   * Enables read queries for a connection to a cluster replica node.
   * 

   * Redis command READONLY.
   * @return Future response.
   */
  public io.vertx.core.Future readonly() { 
    io.vertx.core.Future ret = delegate.readonly().map(val -> val);
    return ret;
  }

  /**
   * Enables read queries for a connection to a cluster replica node.
   * 

   * Redis command READONLY.
   * @return Future response.
   */
  public io.reactivex.Maybe rxReadonly() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.readonly().onComplete($handler);
    });
  }

  /**
   * Disables read queries for a connection to a cluster replica node.
   * 

   * Redis command READWRITE.
   * @return Future response.
   */
  public io.vertx.core.Future readwrite() { 
    io.vertx.core.Future ret = delegate.readwrite().map(val -> val);
    return ret;
  }

  /**
   * Disables read queries for a connection to a cluster replica node.
   * 

   * Redis command READWRITE.
   * @return Future response.
   */
  public io.reactivex.Maybe rxReadwrite() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.readwrite().onComplete($handler);
    });
  }

  /**
   * Rename a key.
   * 

   * Redis command RENAME.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future rename(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.rename(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Rename a key.
   * 

   * Redis command RENAME.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxRename(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.rename(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Rename a key, only if the new key does not exist.
   * 

   * Redis command RENAMENX.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future renamenx(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.renamenx(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Rename a key, only if the new key does not exist.
   * 

   * Redis command RENAMENX.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxRenamenx(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.renamenx(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * An internal command for configuring the replication stream.
   * 

   * Redis command REPLCONF.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future replconf(java.util.List args) { 
    io.vertx.core.Future ret = delegate.replconf(args).map(val -> val);
    return ret;
  }

  /**
   * An internal command for configuring the replication stream.
   * 

   * Redis command REPLCONF.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxReplconf(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.replconf(args).onComplete($handler);
    });
  }

  /**
   * Make the server a replica of another instance, or promote it as master.
   * 

   * Redis command REPLICAOF.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future replicaof(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.replicaof(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Make the server a replica of another instance, or promote it as master.
   * 

   * Redis command REPLICAOF.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxReplicaof(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.replicaof(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Reset the connection.
   * 

   * Redis command RESET.
   * @return Future response.
   */
  public io.vertx.core.Future reset() { 
    io.vertx.core.Future ret = delegate.reset().map(val -> val);
    return ret;
  }

  /**
   * Reset the connection.
   * 

   * Redis command RESET.
   * @return Future response.
   */
  public io.reactivex.Maybe rxReset() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.reset().onComplete($handler);
    });
  }

  /**
   * Create a key using the provided serialized value, previously obtained using DUMP.
   * 

   * Redis command RESTORE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future restore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.restore(args).map(val -> val);
    return ret;
  }

  /**
   * Create a key using the provided serialized value, previously obtained using DUMP.
   * 

   * Redis command RESTORE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxRestore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.restore(args).onComplete($handler);
    });
  }

  /**
   * An internal command for migrating keys in a cluster.
   * 

   * Redis command RESTORE-ASKING.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future restoreAsking(java.util.List args) { 
    io.vertx.core.Future ret = delegate.restoreAsking(args).map(val -> val);
    return ret;
  }

  /**
   * An internal command for migrating keys in a cluster.
   * 

   * Redis command RESTORE-ASKING.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxRestoreAsking(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.restoreAsking(args).onComplete($handler);
    });
  }

  /**
   * Return the role of the instance in the context of replication.
   * 

   * Redis command ROLE.
   * @return Future response.
   */
  public io.vertx.core.Future role() { 
    io.vertx.core.Future ret = delegate.role().map(val -> val);
    return ret;
  }

  /**
   * Return the role of the instance in the context of replication.
   * 

   * Redis command ROLE.
   * @return Future response.
   */
  public io.reactivex.Maybe rxRole() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.role().onComplete($handler);
    });
  }

  /**
   * Remove and get the last elements in a list.
   * 

   * Redis command RPOP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future rpop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.rpop(args).map(val -> val);
    return ret;
  }

  /**
   * Remove and get the last elements in a list.
   * 

   * Redis command RPOP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxRpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.rpop(args).onComplete($handler);
    });
  }

  /**
   * Remove the last element in a list, prepend it to another list and return it.
   * 

   * Redis command RPOPLPUSH.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future rpoplpush(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.rpoplpush(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Remove the last element in a list, prepend it to another list and return it.
   * 

   * Redis command RPOPLPUSH.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxRpoplpush(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.rpoplpush(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Append one or multiple elements to a list.
   * 

   * Redis command RPUSH.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future rpush(java.util.List args) { 
    io.vertx.core.Future ret = delegate.rpush(args).map(val -> val);
    return ret;
  }

  /**
   * Append one or multiple elements to a list.
   * 

   * Redis command RPUSH.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxRpush(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.rpush(args).onComplete($handler);
    });
  }

  /**
   * Append an element to a list, only if the list exists.
   * 

   * Redis command RPUSHX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future rpushx(java.util.List args) { 
    io.vertx.core.Future ret = delegate.rpushx(args).map(val -> val);
    return ret;
  }

  /**
   * Append an element to a list, only if the list exists.
   * 

   * Redis command RPUSHX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxRpushx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.rpushx(args).onComplete($handler);
    });
  }

  /**
   * Add one or more members to a set.
   * 

   * Redis command SADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sadd(args).map(val -> val);
    return ret;
  }

  /**
   * Add one or more members to a set.
   * 

   * Redis command SADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sadd(args).onComplete($handler);
    });
  }

  /**
   * Synchronously save the dataset to disk.
   * 

   * Redis command SAVE.
   * @return Future response.
   */
  public io.vertx.core.Future save() { 
    io.vertx.core.Future ret = delegate.save().map(val -> val);
    return ret;
  }

  /**
   * Synchronously save the dataset to disk.
   * 

   * Redis command SAVE.
   * @return Future response.
   */
  public io.reactivex.Maybe rxSave() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.save().onComplete($handler);
    });
  }

  /**
   * Incrementally iterate the keys space.
   * 

   * Redis command SCAN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future scan(java.util.List args) { 
    io.vertx.core.Future ret = delegate.scan(args).map(val -> val);
    return ret;
  }

  /**
   * Incrementally iterate the keys space.
   * 

   * Redis command SCAN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxScan(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.scan(args).onComplete($handler);
    });
  }

  /**
   * Get the number of members in a set.
   * 

   * Redis command SCARD.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future scard(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.scard(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get the number of members in a set.
   * 

   * Redis command SCARD.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxScard(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.scard(arg0).onComplete($handler);
    });
  }

  /**
   * A container for Lua scripts management commands.
   * 

   * Redis command SCRIPT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future script(java.util.List args) { 
    io.vertx.core.Future ret = delegate.script(args).map(val -> val);
    return ret;
  }

  /**
   * A container for Lua scripts management commands.
   * 

   * Redis command SCRIPT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxScript(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.script(args).onComplete($handler);
    });
  }

  /**
   * Subtract multiple sets.
   * 

   * Redis command SDIFF.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sdiff(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sdiff(args).map(val -> val);
    return ret;
  }

  /**
   * Subtract multiple sets.
   * 

   * Redis command SDIFF.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSdiff(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sdiff(args).onComplete($handler);
    });
  }

  /**
   * Subtract multiple sets and store the resulting set in a key.
   * 

   * Redis command SDIFFSTORE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sdiffstore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sdiffstore(args).map(val -> val);
    return ret;
  }

  /**
   * Subtract multiple sets and store the resulting set in a key.
   * 

   * Redis command SDIFFSTORE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSdiffstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sdiffstore(args).onComplete($handler);
    });
  }

  /**
   * Change the selected database for the current connection.
   * 

   * Redis command SELECT.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future select(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.select(arg0).map(val -> val);
    return ret;
  }

  /**
   * Change the selected database for the current connection.
   * 

   * Redis command SELECT.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSelect(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.select(arg0).onComplete($handler);
    });
  }

  /**
   * Set the string value of a key.
   * 

   * Redis command SET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future set(java.util.List args) { 
    io.vertx.core.Future ret = delegate.set(args).map(val -> val);
    return ret;
  }

  /**
   * Set the string value of a key.
   * 

   * Redis command SET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSet(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.set(args).onComplete($handler);
    });
  }

  /**
   * Sets or clears the bit at offset in the string value stored at key.
   * 

   * Redis command SETBIT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future setbit(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.setbit(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Sets or clears the bit at offset in the string value stored at key.
   * 

   * Redis command SETBIT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSetbit(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.setbit(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Set the value and expiration of a key.
   * 

   * Redis command SETEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future setex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.setex(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Set the value and expiration of a key.
   * 

   * Redis command SETEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSetex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.setex(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Set the value of a key, only if the key does not exist.
   * 

   * Redis command SETNX.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future setnx(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.setnx(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Set the value of a key, only if the key does not exist.
   * 

   * Redis command SETNX.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSetnx(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.setnx(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Overwrite part of a string at key starting at the specified offset.
   * 

   * Redis command SETRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future setrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.setrange(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Overwrite part of a string at key starting at the specified offset.
   * 

   * Redis command SETRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSetrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.setrange(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Synchronously save the dataset to disk and then shut down the server.
   * 

   * Redis command SHUTDOWN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future shutdown(java.util.List args) { 
    io.vertx.core.Future ret = delegate.shutdown(args).map(val -> val);
    return ret;
  }

  /**
   * Synchronously save the dataset to disk and then shut down the server.
   * 

   * Redis command SHUTDOWN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxShutdown(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.shutdown(args).onComplete($handler);
    });
  }

  /**
   * Intersect multiple sets.
   * 

   * Redis command SINTER.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sinter(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sinter(args).map(val -> val);
    return ret;
  }

  /**
   * Intersect multiple sets.
   * 

   * Redis command SINTER.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSinter(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sinter(args).onComplete($handler);
    });
  }

  /**
   * Intersect multiple sets and return the cardinality of the result.
   * 

   * Redis command SINTERCARD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sintercard(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sintercard(args).map(val -> val);
    return ret;
  }

  /**
   * Intersect multiple sets and return the cardinality of the result.
   * 

   * Redis command SINTERCARD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSintercard(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sintercard(args).onComplete($handler);
    });
  }

  /**
   * Intersect multiple sets and store the resulting set in a key.
   * 

   * Redis command SINTERSTORE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sinterstore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sinterstore(args).map(val -> val);
    return ret;
  }

  /**
   * Intersect multiple sets and store the resulting set in a key.
   * 

   * Redis command SINTERSTORE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSinterstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sinterstore(args).onComplete($handler);
    });
  }

  /**
   * Determine if a given value is a member of a set.
   * 

   * Redis command SISMEMBER.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future sismember(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.sismember(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Determine if a given value is a member of a set.
   * 

   * Redis command SISMEMBER.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSismember(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sismember(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Make the server a replica of another instance, or promote it as master.
   * 

   * Redis command SLAVEOF.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future slaveof(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.slaveof(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Make the server a replica of another instance, or promote it as master.
   * 

   * Redis command SLAVEOF.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxSlaveof(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.slaveof(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * A container for slow log commands.
   * 

   * Redis command SLOWLOG.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future slowlog(java.util.List args) { 
    io.vertx.core.Future ret = delegate.slowlog(args).map(val -> val);
    return ret;
  }

  /**
   * A container for slow log commands.
   * 

   * Redis command SLOWLOG.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSlowlog(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.slowlog(args).onComplete($handler);
    });
  }

  /**
   * Get all the members in a set.
   * 

   * Redis command SMEMBERS.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future smembers(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.smembers(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get all the members in a set.
   * 

   * Redis command SMEMBERS.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSmembers(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.smembers(arg0).onComplete($handler);
    });
  }

  /**
   * Returns the membership associated with the given elements for a set.
   * 

   * Redis command SMISMEMBER.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future smismember(java.util.List args) { 
    io.vertx.core.Future ret = delegate.smismember(args).map(val -> val);
    return ret;
  }

  /**
   * Returns the membership associated with the given elements for a set.
   * 

   * Redis command SMISMEMBER.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSmismember(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.smismember(args).onComplete($handler);
    });
  }

  /**
   * Move a member from one set to another.
   * 

   * Redis command SMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future smove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.smove(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Move a member from one set to another.
   * 

   * Redis command SMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.smove(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Sort the elements in a list, set or sorted set.
   * 

   * Redis command SORT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sort(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sort(args).map(val -> val);
    return ret;
  }

  /**
   * Sort the elements in a list, set or sorted set.
   * 

   * Redis command SORT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSort(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sort(args).onComplete($handler);
    });
  }

  /**
   * Sort the elements in a list, set or sorted set. Read-only variant of SORT.
   * 

   * Redis command SORT_RO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sortRo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sortRo(args).map(val -> val);
    return ret;
  }

  /**
   * Sort the elements in a list, set or sorted set. Read-only variant of SORT.
   * 

   * Redis command SORT_RO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSortRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sortRo(args).onComplete($handler);
    });
  }

  /**
   * Remove and return one or multiple random members from a set.
   * 

   * Redis command SPOP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future spop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.spop(args).map(val -> val);
    return ret;
  }

  /**
   * Remove and return one or multiple random members from a set.
   * 

   * Redis command SPOP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.spop(args).onComplete($handler);
    });
  }

  /**
   * Post a message to a shard channel.
   * 

   * Redis command SPUBLISH.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future spublish(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.spublish(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Post a message to a shard channel.
   * 

   * Redis command SPUBLISH.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSpublish(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.spublish(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Get one or multiple random members from a set.
   * 

   * Redis command SRANDMEMBER.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future srandmember(java.util.List args) { 
    io.vertx.core.Future ret = delegate.srandmember(args).map(val -> val);
    return ret;
  }

  /**
   * Get one or multiple random members from a set.
   * 

   * Redis command SRANDMEMBER.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSrandmember(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.srandmember(args).onComplete($handler);
    });
  }

  /**
   * Remove one or more members from a set.
   * 

   * Redis command SREM.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future srem(java.util.List args) { 
    io.vertx.core.Future ret = delegate.srem(args).map(val -> val);
    return ret;
  }

  /**
   * Remove one or more members from a set.
   * 

   * Redis command SREM.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSrem(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.srem(args).onComplete($handler);
    });
  }

  /**
   * Incrementally iterate Set elements.
   * 

   * Redis command SSCAN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sscan(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sscan(args).map(val -> val);
    return ret;
  }

  /**
   * Incrementally iterate Set elements.
   * 

   * Redis command SSCAN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSscan(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sscan(args).onComplete($handler);
    });
  }

  /**
   * Listen for messages published to the given shard channels.
   * 

   * Redis command SSUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future ssubscribe(java.util.List args) { 
    io.vertx.core.Future ret = delegate.ssubscribe(args).map(val -> val);
    return ret;
  }

  /**
   * Listen for messages published to the given shard channels.
   * 

   * Redis command SSUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSsubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ssubscribe(args).onComplete($handler);
    });
  }

  /**
   * Get the length of the value stored in a key.
   * 

   * Redis command STRLEN.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future strlen(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.strlen(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get the length of the value stored in a key.
   * 

   * Redis command STRLEN.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxStrlen(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.strlen(arg0).onComplete($handler);
    });
  }

  /**
   * Listen for messages published to the given channels.
   * 

   * Redis command SUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future subscribe(java.util.List args) { 
    io.vertx.core.Future ret = delegate.subscribe(args).map(val -> val);
    return ret;
  }

  /**
   * Listen for messages published to the given channels.
   * 

   * Redis command SUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.subscribe(args).onComplete($handler);
    });
  }

  /**
   * Get a substring of the string stored at a key.
   * 

   * Redis command SUBSTR.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future substr(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.substr(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Get a substring of the string stored at a key.
   * 

   * Redis command SUBSTR.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxSubstr(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.substr(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Add multiple sets.
   * 

   * Redis command SUNION.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sunion(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sunion(args).map(val -> val);
    return ret;
  }

  /**
   * Add multiple sets.
   * 

   * Redis command SUNION.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSunion(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sunion(args).onComplete($handler);
    });
  }

  /**
   * Add multiple sets and store the resulting set in a key.
   * 

   * Redis command SUNIONSTORE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sunionstore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sunionstore(args).map(val -> val);
    return ret;
  }

  /**
   * Add multiple sets and store the resulting set in a key.
   * 

   * Redis command SUNIONSTORE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSunionstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sunionstore(args).onComplete($handler);
    });
  }

  /**
   * Stop listening for messages posted to the given shard channels.
   * 

   * Redis command SUNSUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future sunsubscribe(java.util.List args) { 
    io.vertx.core.Future ret = delegate.sunsubscribe(args).map(val -> val);
    return ret;
  }

  /**
   * Stop listening for messages posted to the given shard channels.
   * 

   * Redis command SUNSUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSunsubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sunsubscribe(args).onComplete($handler);
    });
  }

  /**
   * Swaps two Redis databases.
   * 

   * Redis command SWAPDB.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future swapdb(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.swapdb(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Swaps two Redis databases.
   * 

   * Redis command SWAPDB.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxSwapdb(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.swapdb(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Internal command used for replication.
   * 

   * Redis command SYNC.
   * @return Future response.
   */
  public io.vertx.core.Future sync() { 
    io.vertx.core.Future ret = delegate.sync().map(val -> val);
    return ret;
  }

  /**
   * Internal command used for replication.
   * 

   * Redis command SYNC.
   * @return Future response.
   */
  public io.reactivex.Maybe rxSync() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.sync().onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.ADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestAdd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestAdd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.ADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestAdd(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.BYRANK.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestByrank(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestByrank(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.BYRANK.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestByrank(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestByrank(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.BYREVRANK.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestByrevrank(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestByrevrank(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.BYREVRANK.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestByrevrank(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestByrevrank(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.CDF.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestCdf(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestCdf(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.CDF.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestCdf(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestCdf(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.CREATE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestCreate(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestCreate(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.CREATE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestCreate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestCreate(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.INFO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestInfo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestInfo(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.INFO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestInfo(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.MAX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestMax(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestMax(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.MAX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestMax(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestMax(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.MERGE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestMerge(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestMerge(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.MERGE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestMerge(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestMerge(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.MIN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestMin(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestMin(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.MIN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestMin(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestMin(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.QUANTILE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestQuantile(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestQuantile(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.QUANTILE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestQuantile(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestQuantile(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.RANK.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestRank(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestRank(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.RANK.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestRank(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestRank(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.RESET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestReset(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestReset(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.RESET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestReset(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestReset(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.REVRANK.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestRevrank(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestRevrank(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.REVRANK.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestRevrank(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestRevrank(args).onComplete($handler);
    });
  }

  /**
   * Redis command TDIGEST.TRIMMED_MEAN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tdigestTrimmedMean(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tdigestTrimmedMean(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TDIGEST.TRIMMED_MEAN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTdigestTrimmedMean(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tdigestTrimmedMean(args).onComplete($handler);
    });
  }

  /**
   * Return the current server time.
   * 

   * Redis command TIME.
   * @return Future response.
   */
  public io.vertx.core.Future time() { 
    io.vertx.core.Future ret = delegate.time().map(val -> val);
    return ret;
  }

  /**
   * Return the current server time.
   * 

   * Redis command TIME.
   * @return Future response.
   */
  public io.reactivex.Maybe rxTime() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.time().onComplete($handler);
    });
  }

  /**
   * Redis command TIMESERIES.CLUSTERSET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future timeseriesClusterset(java.util.List args) { 
    io.vertx.core.Future ret = delegate.timeseriesClusterset(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TIMESERIES.CLUSTERSET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTimeseriesClusterset(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.timeseriesClusterset(args).onComplete($handler);
    });
  }

  /**
   * Redis command TIMESERIES.CLUSTERSETFROMSHARD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future timeseriesClustersetfromshard(java.util.List args) { 
    io.vertx.core.Future ret = delegate.timeseriesClustersetfromshard(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TIMESERIES.CLUSTERSETFROMSHARD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTimeseriesClustersetfromshard(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.timeseriesClustersetfromshard(args).onComplete($handler);
    });
  }

  /**
   * Redis command TIMESERIES.HELLO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future timeseriesHello(java.util.List args) { 
    io.vertx.core.Future ret = delegate.timeseriesHello(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TIMESERIES.HELLO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTimeseriesHello(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.timeseriesHello(args).onComplete($handler);
    });
  }

  /**
   * Redis command TIMESERIES.INFOCLUSTER.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future timeseriesInfocluster(java.util.List args) { 
    io.vertx.core.Future ret = delegate.timeseriesInfocluster(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TIMESERIES.INFOCLUSTER.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTimeseriesInfocluster(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.timeseriesInfocluster(args).onComplete($handler);
    });
  }

  /**
   * Redis command TIMESERIES.INNERCOMMUNICATION.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future timeseriesInnercommunication(java.util.List args) { 
    io.vertx.core.Future ret = delegate.timeseriesInnercommunication(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TIMESERIES.INNERCOMMUNICATION.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTimeseriesInnercommunication(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.timeseriesInnercommunication(args).onComplete($handler);
    });
  }

  /**
   * Redis command TIMESERIES.NETWORKTEST.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future timeseriesNetworktest(java.util.List args) { 
    io.vertx.core.Future ret = delegate.timeseriesNetworktest(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TIMESERIES.NETWORKTEST.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTimeseriesNetworktest(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.timeseriesNetworktest(args).onComplete($handler);
    });
  }

  /**
   * Redis command TIMESERIES.REFRESHCLUSTER.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future timeseriesRefreshcluster(java.util.List args) { 
    io.vertx.core.Future ret = delegate.timeseriesRefreshcluster(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TIMESERIES.REFRESHCLUSTER.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTimeseriesRefreshcluster(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.timeseriesRefreshcluster(args).onComplete($handler);
    });
  }

  /**
   * Redis command TOPK.ADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future topkAdd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.topkAdd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TOPK.ADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTopkAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.topkAdd(args).onComplete($handler);
    });
  }

  /**
   * Redis command TOPK.COUNT.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future topkCount(java.util.List args) { 
    io.vertx.core.Future ret = delegate.topkCount(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TOPK.COUNT.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTopkCount(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.topkCount(args).onComplete($handler);
    });
  }

  /**
   * Redis command TOPK.INCRBY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future topkIncrby(java.util.List args) { 
    io.vertx.core.Future ret = delegate.topkIncrby(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TOPK.INCRBY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTopkIncrby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.topkIncrby(args).onComplete($handler);
    });
  }

  /**
   * Redis command TOPK.INFO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future topkInfo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.topkInfo(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TOPK.INFO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTopkInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.topkInfo(args).onComplete($handler);
    });
  }

  /**
   * Redis command TOPK.LIST.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future topkList(java.util.List args) { 
    io.vertx.core.Future ret = delegate.topkList(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TOPK.LIST.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTopkList(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.topkList(args).onComplete($handler);
    });
  }

  /**
   * Redis command TOPK.QUERY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future topkQuery(java.util.List args) { 
    io.vertx.core.Future ret = delegate.topkQuery(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TOPK.QUERY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTopkQuery(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.topkQuery(args).onComplete($handler);
    });
  }

  /**
   * Redis command TOPK.RESERVE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future topkReserve(java.util.List args) { 
    io.vertx.core.Future ret = delegate.topkReserve(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TOPK.RESERVE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTopkReserve(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.topkReserve(args).onComplete($handler);
    });
  }

  /**
   * Alters the last access time of a key(s). Returns the number of existing keys specified.
   * 

   * Redis command TOUCH.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future touch(java.util.List args) { 
    io.vertx.core.Future ret = delegate.touch(args).map(val -> val);
    return ret;
  }

  /**
   * Alters the last access time of a key(s). Returns the number of existing keys specified.
   * 

   * Redis command TOUCH.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTouch(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.touch(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.ADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsAdd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsAdd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.ADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsAdd(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.ALTER.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsAlter(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsAlter(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.ALTER.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsAlter(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsAlter(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.CREATE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsCreate(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsCreate(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.CREATE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsCreate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsCreate(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.CREATERULE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsCreaterule(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsCreaterule(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.CREATERULE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsCreaterule(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsCreaterule(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.DECRBY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsDecrby(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsDecrby(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.DECRBY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsDecrby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsDecrby(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.DEL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsDel(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsDel(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.DEL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsDel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsDel(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.DELETERULE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsDeleterule(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsDeleterule(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.DELETERULE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsDeleterule(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsDeleterule(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.GET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsGet(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsGet(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.GET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsGet(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsGet(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.INCRBY.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsIncrby(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsIncrby(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.INCRBY.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsIncrby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsIncrby(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.INFO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsInfo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsInfo(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.INFO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsInfo(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.MADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsMadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsMadd(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.MADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsMadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsMadd(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.MGET.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsMget(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsMget(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.MGET.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsMget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsMget(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.MRANGE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsMrange(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsMrange(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.MRANGE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsMrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsMrange(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.MREVRANGE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsMrevrange(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsMrevrange(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.MREVRANGE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsMrevrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsMrevrange(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.QUERYINDEX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsQueryindex(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsQueryindex(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.QUERYINDEX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsQueryindex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsQueryindex(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.RANGE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsRange(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsRange(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.RANGE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsRange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsRange(args).onComplete($handler);
    });
  }

  /**
   * Redis command TS.REVRANGE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future tsRevrange(java.util.List args) { 
    io.vertx.core.Future ret = delegate.tsRevrange(args).map(val -> val);
    return ret;
  }

  /**
   * Redis command TS.REVRANGE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTsRevrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.tsRevrange(args).onComplete($handler);
    });
  }

  /**
   * Get the time to live for a key in seconds.
   * 

   * Redis command TTL.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future ttl(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.ttl(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get the time to live for a key in seconds.
   * 

   * Redis command TTL.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxTtl(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.ttl(arg0).onComplete($handler);
    });
  }

  /**
   * Determine the type stored at key.
   * 

   * Redis command TYPE.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future type(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.type(arg0).map(val -> val);
    return ret;
  }

  /**
   * Determine the type stored at key.
   * 

   * Redis command TYPE.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxType(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.type(arg0).onComplete($handler);
    });
  }

  /**
   * Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
   * 

   * Redis command UNLINK.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future unlink(java.util.List args) { 
    io.vertx.core.Future ret = delegate.unlink(args).map(val -> val);
    return ret;
  }

  /**
   * Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.
   * 

   * Redis command UNLINK.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxUnlink(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.unlink(args).onComplete($handler);
    });
  }

  /**
   * Stop listening for messages posted to the given channels.
   * 

   * Redis command UNSUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future unsubscribe(java.util.List args) { 
    io.vertx.core.Future ret = delegate.unsubscribe(args).map(val -> val);
    return ret;
  }

  /**
   * Stop listening for messages posted to the given channels.
   * 

   * Redis command UNSUBSCRIBE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxUnsubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.unsubscribe(args).onComplete($handler);
    });
  }

  /**
   * Forget about all watched keys.
   * 

   * Redis command UNWATCH.
   * @return Future response.
   */
  public io.vertx.core.Future unwatch() { 
    io.vertx.core.Future ret = delegate.unwatch().map(val -> val);
    return ret;
  }

  /**
   * Forget about all watched keys.
   * 

   * Redis command UNWATCH.
   * @return Future response.
   */
  public io.reactivex.Maybe rxUnwatch() { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.unwatch().onComplete($handler);
    });
  }

  /**
   * Wait for the synchronous replication of all the write commands sent in the context of the current connection.
   * 

   * Redis command WAIT.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future wait(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.wait(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Wait for the synchronous replication of all the write commands sent in the context of the current connection.
   * 

   * Redis command WAIT.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxWait(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.wait(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Watch the given keys to determine execution of the MULTI/EXEC block.
   * 

   * Redis command WATCH.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future watch(java.util.List args) { 
    io.vertx.core.Future ret = delegate.watch(args).map(val -> val);
    return ret;
  }

  /**
   * Watch the given keys to determine execution of the MULTI/EXEC block.
   * 

   * Redis command WATCH.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxWatch(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.watch(args).onComplete($handler);
    });
  }

  /**
   * Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.
   * 

   * Redis command XACK.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xack(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xack(args).map(val -> val);
    return ret;
  }

  /**
   * Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.
   * 

   * Redis command XACK.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXack(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xack(args).onComplete($handler);
    });
  }

  /**
   * Appends a new entry to a stream.
   * 

   * Redis command XADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xadd(args).map(val -> val);
    return ret;
  }

  /**
   * Appends a new entry to a stream.
   * 

   * Redis command XADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xadd(args).onComplete($handler);
    });
  }

  /**
   * Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
   * 

   * Redis command XAUTOCLAIM.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xautoclaim(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xautoclaim(args).map(val -> val);
    return ret;
  }

  /**
   * Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.
   * 

   * Redis command XAUTOCLAIM.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXautoclaim(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xautoclaim(args).onComplete($handler);
    });
  }

  /**
   * Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
   * 

   * Redis command XCLAIM.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xclaim(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xclaim(args).map(val -> val);
    return ret;
  }

  /**
   * Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.
   * 

   * Redis command XCLAIM.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXclaim(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xclaim(args).onComplete($handler);
    });
  }

  /**
   * Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.
   * 

   * Redis command XDEL.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xdel(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xdel(args).map(val -> val);
    return ret;
  }

  /**
   * Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.
   * 

   * Redis command XDEL.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXdel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xdel(args).onComplete($handler);
    });
  }

  /**
   * A container for consumer groups commands.
   * 

   * Redis command XGROUP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xgroup(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xgroup(args).map(val -> val);
    return ret;
  }

  /**
   * A container for consumer groups commands.
   * 

   * Redis command XGROUP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXgroup(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xgroup(args).onComplete($handler);
    });
  }

  /**
   * A container for stream introspection commands.
   * 

   * Redis command XINFO.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xinfo(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xinfo(args).map(val -> val);
    return ret;
  }

  /**
   * A container for stream introspection commands.
   * 

   * Redis command XINFO.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXinfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xinfo(args).onComplete($handler);
    });
  }

  /**
   * Return the number of entries in a stream.
   * 

   * Redis command XLEN.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future xlen(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.xlen(arg0).map(val -> val);
    return ret;
  }

  /**
   * Return the number of entries in a stream.
   * 

   * Redis command XLEN.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXlen(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xlen(arg0).onComplete($handler);
    });
  }

  /**
   * Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
   * 

   * Redis command XPENDING.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xpending(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xpending(args).map(val -> val);
    return ret;
  }

  /**
   * Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.
   * 

   * Redis command XPENDING.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXpending(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xpending(args).onComplete($handler);
    });
  }

  /**
   * Return a range of elements in a stream, with IDs matching the specified IDs interval.
   * 

   * Redis command XRANGE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xrange(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xrange(args).map(val -> val);
    return ret;
  }

  /**
   * Return a range of elements in a stream, with IDs matching the specified IDs interval.
   * 

   * Redis command XRANGE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xrange(args).onComplete($handler);
    });
  }

  /**
   * Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.
   * 

   * Redis command XREAD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xread(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xread(args).map(val -> val);
    return ret;
  }

  /**
   * Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.
   * 

   * Redis command XREAD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXread(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xread(args).onComplete($handler);
    });
  }

  /**
   * Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.
   * 

   * Redis command XREADGROUP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xreadgroup(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xreadgroup(args).map(val -> val);
    return ret;
  }

  /**
   * Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.
   * 

   * Redis command XREADGROUP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXreadgroup(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xreadgroup(args).onComplete($handler);
    });
  }

  /**
   * Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.
   * 

   * Redis command XREVRANGE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xrevrange(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xrevrange(args).map(val -> val);
    return ret;
  }

  /**
   * Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE.
   * 

   * Redis command XREVRANGE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXrevrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xrevrange(args).onComplete($handler);
    });
  }

  /**
   * An internal command for replicating stream values.
   * 

   * Redis command XSETID.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xsetid(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xsetid(args).map(val -> val);
    return ret;
  }

  /**
   * An internal command for replicating stream values.
   * 

   * Redis command XSETID.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXsetid(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xsetid(args).onComplete($handler);
    });
  }

  /**
   * Trims the stream to (approximately if '~' is passed) a certain size.
   * 

   * Redis command XTRIM.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future xtrim(java.util.List args) { 
    io.vertx.core.Future ret = delegate.xtrim(args).map(val -> val);
    return ret;
  }

  /**
   * Trims the stream to (approximately if '~' is passed) a certain size.
   * 

   * Redis command XTRIM.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxXtrim(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.xtrim(args).onComplete($handler);
    });
  }

  /**
   * Add one or more members to a sorted set, or update its score if it already exists.
   * 

   * Redis command ZADD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zadd(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zadd(args).map(val -> val);
    return ret;
  }

  /**
   * Add one or more members to a sorted set, or update its score if it already exists.
   * 

   * Redis command ZADD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zadd(args).onComplete($handler);
    });
  }

  /**
   * Get the number of members in a sorted set.
   * 

   * Redis command ZCARD.
   * @param arg0 
   * @return Future response.
   */
  public io.vertx.core.Future zcard(java.lang.String arg0) { 
    io.vertx.core.Future ret = delegate.zcard(arg0).map(val -> val);
    return ret;
  }

  /**
   * Get the number of members in a sorted set.
   * 

   * Redis command ZCARD.
   * @param arg0 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZcard(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zcard(arg0).onComplete($handler);
    });
  }

  /**
   * Count the members in a sorted set with scores within the given values.
   * 

   * Redis command ZCOUNT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future zcount(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.zcount(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Count the members in a sorted set with scores within the given values.
   * 

   * Redis command ZCOUNT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZcount(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zcount(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Subtract multiple sorted sets.
   * 

   * Redis command ZDIFF.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zdiff(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zdiff(args).map(val -> val);
    return ret;
  }

  /**
   * Subtract multiple sorted sets.
   * 

   * Redis command ZDIFF.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZdiff(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zdiff(args).onComplete($handler);
    });
  }

  /**
   * Subtract multiple sorted sets and store the resulting sorted set in a new key.
   * 

   * Redis command ZDIFFSTORE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zdiffstore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zdiffstore(args).map(val -> val);
    return ret;
  }

  /**
   * Subtract multiple sorted sets and store the resulting sorted set in a new key.
   * 

   * Redis command ZDIFFSTORE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZdiffstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zdiffstore(args).onComplete($handler);
    });
  }

  /**
   * Increment the score of a member in a sorted set.
   * 

   * Redis command ZINCRBY.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future zincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.zincrby(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Increment the score of a member in a sorted set.
   * 

   * Redis command ZINCRBY.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zincrby(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Intersect multiple sorted sets.
   * 

   * Redis command ZINTER.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zinter(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zinter(args).map(val -> val);
    return ret;
  }

  /**
   * Intersect multiple sorted sets.
   * 

   * Redis command ZINTER.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZinter(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zinter(args).onComplete($handler);
    });
  }

  /**
   * Intersect multiple sorted sets and return the cardinality of the result.
   * 

   * Redis command ZINTERCARD.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zintercard(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zintercard(args).map(val -> val);
    return ret;
  }

  /**
   * Intersect multiple sorted sets and return the cardinality of the result.
   * 

   * Redis command ZINTERCARD.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZintercard(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zintercard(args).onComplete($handler);
    });
  }

  /**
   * Intersect multiple sorted sets and store the resulting sorted set in a new key.
   * 

   * Redis command ZINTERSTORE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zinterstore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zinterstore(args).map(val -> val);
    return ret;
  }

  /**
   * Intersect multiple sorted sets and store the resulting sorted set in a new key.
   * 

   * Redis command ZINTERSTORE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZinterstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zinterstore(args).onComplete($handler);
    });
  }

  /**
   * Count the number of members in a sorted set between a given lexicographical range.
   * 

   * Redis command ZLEXCOUNT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future zlexcount(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.zlexcount(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Count the number of members in a sorted set between a given lexicographical range.
   * 

   * Redis command ZLEXCOUNT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZlexcount(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zlexcount(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Remove and return members with scores in a sorted set.
   * 

   * Redis command ZMPOP.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zmpop(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zmpop(args).map(val -> val);
    return ret;
  }

  /**
   * Remove and return members with scores in a sorted set.
   * 

   * Redis command ZMPOP.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZmpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zmpop(args).onComplete($handler);
    });
  }

  /**
   * Get the score associated with the given members in a sorted set.
   * 

   * Redis command ZMSCORE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zmscore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zmscore(args).map(val -> val);
    return ret;
  }

  /**
   * Get the score associated with the given members in a sorted set.
   * 

   * Redis command ZMSCORE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZmscore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zmscore(args).onComplete($handler);
    });
  }

  /**
   * Remove and return members with the highest scores in a sorted set.
   * 

   * Redis command ZPOPMAX.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zpopmax(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zpopmax(args).map(val -> val);
    return ret;
  }

  /**
   * Remove and return members with the highest scores in a sorted set.
   * 

   * Redis command ZPOPMAX.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZpopmax(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zpopmax(args).onComplete($handler);
    });
  }

  /**
   * Remove and return members with the lowest scores in a sorted set.
   * 

   * Redis command ZPOPMIN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zpopmin(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zpopmin(args).map(val -> val);
    return ret;
  }

  /**
   * Remove and return members with the lowest scores in a sorted set.
   * 

   * Redis command ZPOPMIN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZpopmin(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zpopmin(args).onComplete($handler);
    });
  }

  /**
   * Get one or multiple random elements from a sorted set.
   * 

   * Redis command ZRANDMEMBER.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zrandmember(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zrandmember(args).map(val -> val);
    return ret;
  }

  /**
   * Get one or multiple random elements from a sorted set.
   * 

   * Redis command ZRANDMEMBER.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZrandmember(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zrandmember(args).onComplete($handler);
    });
  }

  /**
   * Return a range of members in a sorted set.
   * 

   * Redis command ZRANGE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zrange(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zrange(args).map(val -> val);
    return ret;
  }

  /**
   * Return a range of members in a sorted set.
   * 

   * Redis command ZRANGE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zrange(args).onComplete($handler);
    });
  }

  /**
   * Return a range of members in a sorted set, by lexicographical range.
   * 

   * Redis command ZRANGEBYLEX.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future zrangebylex(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zrangebylex(args).map(val -> val);
    return ret;
  }

  /**
   * Return a range of members in a sorted set, by lexicographical range.
   * 

   * Redis command ZRANGEBYLEX.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxZrangebylex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zrangebylex(args).onComplete($handler);
    });
  }

  /**
   * Return a range of members in a sorted set, by score.
   * 

   * Redis command ZRANGEBYSCORE.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future zrangebyscore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zrangebyscore(args).map(val -> val);
    return ret;
  }

  /**
   * Return a range of members in a sorted set, by score.
   * 

   * Redis command ZRANGEBYSCORE.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxZrangebyscore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zrangebyscore(args).onComplete($handler);
    });
  }

  /**
   * Store a range of members from sorted set into another key.
   * 

   * Redis command ZRANGESTORE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zrangestore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zrangestore(args).map(val -> val);
    return ret;
  }

  /**
   * Store a range of members from sorted set into another key.
   * 

   * Redis command ZRANGESTORE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZrangestore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zrangestore(args).onComplete($handler);
    });
  }

  /**
   * Determine the index of a member in a sorted set.
   * 

   * Redis command ZRANK.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future zrank(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.zrank(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Determine the index of a member in a sorted set.
   * 

   * Redis command ZRANK.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZrank(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zrank(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Remove one or more members from a sorted set.
   * 

   * Redis command ZREM.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zrem(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zrem(args).map(val -> val);
    return ret;
  }

  /**
   * Remove one or more members from a sorted set.
   * 

   * Redis command ZREM.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZrem(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zrem(args).onComplete($handler);
    });
  }

  /**
   * Remove all members in a sorted set between the given lexicographical range.
   * 

   * Redis command ZREMRANGEBYLEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future zremrangebylex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.zremrangebylex(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Remove all members in a sorted set between the given lexicographical range.
   * 

   * Redis command ZREMRANGEBYLEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZremrangebylex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zremrangebylex(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Remove all members in a sorted set within the given indexes.
   * 

   * Redis command ZREMRANGEBYRANK.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future zremrangebyrank(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.zremrangebyrank(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Remove all members in a sorted set within the given indexes.
   * 

   * Redis command ZREMRANGEBYRANK.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZremrangebyrank(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zremrangebyrank(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Remove all members in a sorted set within the given scores.
   * 

   * Redis command ZREMRANGEBYSCORE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.vertx.core.Future zremrangebyscore(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.vertx.core.Future ret = delegate.zremrangebyscore(arg0, arg1, arg2).map(val -> val);
    return ret;
  }

  /**
   * Remove all members in a sorted set within the given scores.
   * 

   * Redis command ZREMRANGEBYSCORE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZremrangebyscore(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zremrangebyscore(arg0, arg1, arg2).onComplete($handler);
    });
  }

  /**
   * Return a range of members in a sorted set, by index, with scores ordered from high to low.
   * 

   * Redis command ZREVRANGE.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future zrevrange(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zrevrange(args).map(val -> val);
    return ret;
  }

  /**
   * Return a range of members in a sorted set, by index, with scores ordered from high to low.
   * 

   * Redis command ZREVRANGE.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxZrevrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zrevrange(args).onComplete($handler);
    });
  }

  /**
   * Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
   * 

   * Redis command ZREVRANGEBYLEX.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future zrevrangebylex(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zrevrangebylex(args).map(val -> val);
    return ret;
  }

  /**
   * Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.
   * 

   * Redis command ZREVRANGEBYLEX.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxZrevrangebylex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zrevrangebylex(args).onComplete($handler);
    });
  }

  /**
   * Return a range of members in a sorted set, by score, with scores ordered from high to low.
   * 

   * Redis command ZREVRANGEBYSCORE.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.vertx.core.Future zrevrangebyscore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zrevrangebyscore(args).map(val -> val);
    return ret;
  }

  /**
   * Return a range of members in a sorted set, by score, with scores ordered from high to low.
   * 

   * Redis command ZREVRANGEBYSCORE.
   * @param args 
   * @return Future response.
   */
  @Deprecated()
  public io.reactivex.Maybe rxZrevrangebyscore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zrevrangebyscore(args).onComplete($handler);
    });
  }

  /**
   * Determine the index of a member in a sorted set, with scores ordered from high to low.
   * 

   * Redis command ZREVRANK.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future zrevrank(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.zrevrank(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Determine the index of a member in a sorted set, with scores ordered from high to low.
   * 

   * Redis command ZREVRANK.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZrevrank(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zrevrank(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Incrementally iterate sorted sets elements and associated scores.
   * 

   * Redis command ZSCAN.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zscan(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zscan(args).map(val -> val);
    return ret;
  }

  /**
   * Incrementally iterate sorted sets elements and associated scores.
   * 

   * Redis command ZSCAN.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZscan(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zscan(args).onComplete($handler);
    });
  }

  /**
   * Get the score associated with the given member in a sorted set.
   * 

   * Redis command ZSCORE.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.vertx.core.Future zscore(java.lang.String arg0, java.lang.String arg1) { 
    io.vertx.core.Future ret = delegate.zscore(arg0, arg1).map(val -> val);
    return ret;
  }

  /**
   * Get the score associated with the given member in a sorted set.
   * 

   * Redis command ZSCORE.
   * @param arg0 
   * @param arg1 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZscore(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zscore(arg0, arg1).onComplete($handler);
    });
  }

  /**
   * Add multiple sorted sets.
   * 

   * Redis command ZUNION.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zunion(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zunion(args).map(val -> val);
    return ret;
  }

  /**
   * Add multiple sorted sets.
   * 

   * Redis command ZUNION.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZunion(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zunion(args).onComplete($handler);
    });
  }

  /**
   * Add multiple sorted sets and store the resulting sorted set in a new key.
   * 

   * Redis command ZUNIONSTORE.
   * @param args 
   * @return Future response.
   */
  public io.vertx.core.Future zunionstore(java.util.List args) { 
    io.vertx.core.Future ret = delegate.zunionstore(args).map(val -> val);
    return ret;
  }

  /**
   * Add multiple sorted sets and store the resulting sorted set in a new key.
   * 
   * Redis command ZUNIONSTORE.
   * @param args 
   * @return Future response.
   */
  public io.reactivex.Maybe rxZunionstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe($handler -> {
      this.zunionstore(args).onComplete($handler);
    });
  }

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

  public static io.vertx.reactivex.redis.client.RedisAPI api(io.vertx.reactivex.redis.client.RedisConnection connection) { 
    io.vertx.reactivex.redis.client.RedisAPI ret = io.vertx.reactivex.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;
  }

}