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

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

package io.vertx.rxjava3.redis.client;

import io.vertx.rxjava3.RxHelper;
import io.vertx.rxjava3.ObservableHelper;
import io.vertx.rxjava3.FlowableHelper;
import io.vertx.rxjava3.impl.AsyncResultMaybe;
import io.vertx.rxjava3.impl.AsyncResultSingle;
import io.vertx.rxjava3.impl.AsyncResultCompletable;
import io.vertx.rxjava3.WriteStreamObserver;
import io.vertx.rxjava3.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.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 fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftAdd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtAdd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.ADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftAdd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.AGGREGATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftAggregate(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtAggregate(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.AGGREGATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtAggregate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftAggregate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.ALIASADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftAliasadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtAliasadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.ALIASADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtAliasadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftAliasadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.ALIASDEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftAliasdel(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtAliasdel(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.ALIASDEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtAliasdel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftAliasdel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.ALIASUPDATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftAliasupdate(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtAliasupdate(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.ALIASUPDATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtAliasupdate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftAliasupdate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.ALTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftAlter(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtAlter(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.ALTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtAlter(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftAlter(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.CONFIG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftConfig(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtConfig(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.CONFIG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtConfig(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftConfig(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.CREATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftCreate(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtCreate(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.CREATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtCreate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftCreate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.CURSOR.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftCursor(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtCursor(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.CURSOR.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtCursor(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftCursor(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftDebug(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtDebug(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftDebug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.DEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftDel(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtDel(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.DEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtDel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftDel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.DICTADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftDictadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtDictadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.DICTADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtDictadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftDictadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.DICTDEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftDictdel(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtDictdel(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.DICTDEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtDictdel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftDictdel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.DICTDUMP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftDictdump(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtDictdump(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.DICTDUMP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtDictdump(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftDictdump(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.DROP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftDrop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtDrop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.DROP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtDrop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftDrop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.DROPINDEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftDropindex(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtDropindex(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.DROPINDEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtDropindex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftDropindex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.EXPLAIN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftExplain(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtExplain(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.EXPLAIN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtExplain(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftExplain(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.EXPLAINCLI.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftExplaincli(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtExplaincli(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.EXPLAINCLI.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtExplaincli(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftExplaincli(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.GET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftGet(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtGet(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.GET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtGet(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftGet(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftInfo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtInfo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.MGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftMget(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtMget(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.MGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtMget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftMget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.PROFILE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftProfile(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtProfile(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.PROFILE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtProfile(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftProfile(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.SAFEADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftSafeadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtSafeadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.SAFEADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtSafeadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftSafeadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.SEARCH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftSearch(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtSearch(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.SEARCH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtSearch(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftSearch(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.SPELLCHECK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftSpellcheck(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtSpellcheck(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.SPELLCHECK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtSpellcheck(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftSpellcheck(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.SUGADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftSugadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtSugadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.SUGADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtSugadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftSugadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.SUGDEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftSugdel(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtSugdel(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.SUGDEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtSugdel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftSugdel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.SUGGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftSugget(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtSugget(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.SUGGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtSugget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftSugget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.SUGLEN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftSuglen(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtSuglen(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.SUGLEN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtSuglen(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftSuglen(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.SYNADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftSynadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtSynadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.SYNADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtSynadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftSynadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.SYNDUMP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftSyndump(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtSyndump(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.SYNDUMP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtSyndump(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftSyndump(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.SYNUPDATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftSynupdate(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtSynupdate(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.SYNUPDATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtSynupdate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftSynupdate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT.TAGVALS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftTagvals(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtTagvals(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT.TAGVALS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtTagvals(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftTagvals(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT._ALIASADDIFNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftAliasaddifnx(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtAliasaddifnx(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT._ALIASADDIFNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtAliasaddifnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftAliasaddifnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT._ALIASDELIFX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftAliasdelifx(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtAliasdelifx(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT._ALIASDELIFX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtAliasdelifx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftAliasdelifx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT._ALTERIFNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftAlterifnx(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtAlterifnx(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT._ALTERIFNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtAlterifnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftAlterifnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT._CREATEIFNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftCreateifnx(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtCreateifnx(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT._CREATEIFNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtCreateifnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftCreateifnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT._DROPIFX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftDropifx(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtDropifx(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT._DROPIFX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtDropifx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftDropifx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT._DROPINDEXIFX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftDropindexifx(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtDropindexifx(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT._DROPINDEXIFX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtDropindexifx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftDropindexifx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FT._LIST.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ftList(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFtList(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FT._LIST.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFtList(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ftList(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ACL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe acl(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxAcl(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ACL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxAcl(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.acl(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command APPEND.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe append(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxAppend(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command APPEND.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxAppend(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.append(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ASKING.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe asking() { 
    io.reactivex.rxjava3.core.Maybe ret = rxAsking();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ASKING.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxAsking() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.asking(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command AUTH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe auth(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxAuth(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command AUTH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxAuth(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.auth(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BF.ADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bfAdd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBfAdd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BF.ADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBfAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bfAdd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BF.CARD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bfCard(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBfCard(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BF.CARD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBfCard(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bfCard(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BF.DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bfDebug(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBfDebug(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BF.DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBfDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bfDebug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BF.EXISTS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bfExists(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBfExists(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BF.EXISTS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBfExists(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bfExists(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BF.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bfInfo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBfInfo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BF.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBfInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bfInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BF.INSERT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bfInsert(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBfInsert(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BF.INSERT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBfInsert(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bfInsert(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BF.LOADCHUNK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bfLoadchunk(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBfLoadchunk(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BF.LOADCHUNK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBfLoadchunk(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bfLoadchunk(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BF.MADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bfMadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBfMadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BF.MADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBfMadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bfMadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BF.MEXISTS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bfMexists(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBfMexists(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BF.MEXISTS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBfMexists(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bfMexists(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BF.RESERVE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bfReserve(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBfReserve(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BF.RESERVE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBfReserve(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bfReserve(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BF.SCANDUMP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bfScandump(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBfScandump(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BF.SCANDUMP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBfScandump(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bfScandump(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BGREWRITEAOF.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bgrewriteaof() { 
    io.reactivex.rxjava3.core.Maybe ret = rxBgrewriteaof();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BGREWRITEAOF.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBgrewriteaof() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bgrewriteaof(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BGSAVE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bgsave(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBgsave(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BGSAVE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBgsave(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bgsave(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BITCOUNT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bitcount(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBitcount(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BITCOUNT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBitcount(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bitcount(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BITFIELD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bitfield(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBitfield(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BITFIELD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBitfield(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bitfield(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BITFIELD_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bitfieldRo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBitfieldRo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BITFIELD_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBitfieldRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bitfieldRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BITOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bitop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBitop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BITOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBitop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bitop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BITPOS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bitpos(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBitpos(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BITPOS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBitpos(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bitpos(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BLMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @param arg4 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe blmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3, java.lang.String arg4) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBlmove(arg0, arg1, arg2, arg3, arg4);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BLMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @param arg4 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.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 -> {
      delegate.blmove(arg0, arg1, arg2, arg3, arg4, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BLMPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe blmpop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBlmpop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BLMPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBlmpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.blmpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BLPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe blpop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBlpop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BLPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBlpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.blpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BRPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe brpop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBrpop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BRPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBrpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.brpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BRPOPLPUSH.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe brpoplpush(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBrpoplpush(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BRPOPLPUSH.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBrpoplpush(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.brpoplpush(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BZMPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bzmpop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBzmpop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BZMPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBzmpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bzmpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BZPOPMAX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bzpopmax(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBzpopmax(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BZPOPMAX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBzpopmax(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bzpopmax(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command BZPOPMIN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe bzpopmin(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxBzpopmin(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command BZPOPMIN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxBzpopmin(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.bzpopmin(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.ADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfAdd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfAdd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.ADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfAdd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.ADDNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfAddnx(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfAddnx(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.ADDNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfAddnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfAddnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.COMPACT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfCompact(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfCompact(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.COMPACT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfCompact(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfCompact(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.COUNT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfCount(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfCount(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.COUNT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfCount(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfCount(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfDebug(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfDebug(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfDebug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.DEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfDel(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfDel(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.DEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfDel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfDel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.EXISTS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfExists(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfExists(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.EXISTS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfExists(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfExists(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfInfo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfInfo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.INSERT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfInsert(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfInsert(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.INSERT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfInsert(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfInsert(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.INSERTNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfInsertnx(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfInsertnx(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.INSERTNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfInsertnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfInsertnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.LOADCHUNK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfLoadchunk(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfLoadchunk(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.LOADCHUNK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfLoadchunk(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfLoadchunk(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.MEXISTS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfMexists(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfMexists(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.MEXISTS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfMexists(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfMexists(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.RESERVE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfReserve(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfReserve(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.RESERVE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfReserve(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfReserve(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CF.SCANDUMP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cfScandump(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCfScandump(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CF.SCANDUMP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCfScandump(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cfScandump(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CLIENT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe client(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxClient(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CLIENT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxClient(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.client(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CLUSTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cluster(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCluster(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CLUSTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCluster(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cluster(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CMS.INCRBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cmsIncrby(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCmsIncrby(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CMS.INCRBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCmsIncrby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cmsIncrby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CMS.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cmsInfo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCmsInfo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CMS.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCmsInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cmsInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CMS.INITBYDIM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cmsInitbydim(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCmsInitbydim(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CMS.INITBYDIM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCmsInitbydim(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cmsInitbydim(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CMS.INITBYPROB.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cmsInitbyprob(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCmsInitbyprob(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CMS.INITBYPROB.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCmsInitbyprob(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cmsInitbyprob(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CMS.MERGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cmsMerge(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCmsMerge(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CMS.MERGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCmsMerge(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cmsMerge(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CMS.QUERY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe cmsQuery(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCmsQuery(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CMS.QUERY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCmsQuery(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.cmsQuery(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command COMMAND.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe command(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCommand(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command COMMAND.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCommand(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.command(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command CONFIG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe config(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxConfig(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command CONFIG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxConfig(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.config(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command COPY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe copy(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxCopy(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command COPY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxCopy(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.copy(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command DBSIZE.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe dbsize() { 
    io.reactivex.rxjava3.core.Maybe ret = rxDbsize();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command DBSIZE.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxDbsize() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.dbsize(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe debug(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxDebug(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.debug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command DECR.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe decr(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxDecr(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command DECR.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxDecr(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.decr(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command DECRBY.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe decrby(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxDecrby(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command DECRBY.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxDecrby(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.decrby(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command DEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe del(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxDel(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command DEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxDel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.del(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command DISCARD.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe discard() { 
    io.reactivex.rxjava3.core.Maybe ret = rxDiscard();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command DISCARD.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxDiscard() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.discard(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command DUMP.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe dump(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxDump(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command DUMP.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxDump(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.dump(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ECHO.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe echo(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxEcho(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ECHO.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxEcho(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.echo(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command EVAL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe eval(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxEval(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command EVAL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxEval(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.eval(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command EVAL_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe evalRo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxEvalRo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command EVAL_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxEvalRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.evalRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command EVALSHA.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe evalsha(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxEvalsha(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command EVALSHA.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxEvalsha(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.evalsha(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command EVALSHA_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe evalshaRo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxEvalshaRo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command EVALSHA_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxEvalshaRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.evalshaRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command EXEC.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe exec() { 
    io.reactivex.rxjava3.core.Maybe ret = rxExec();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command EXEC.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxExec() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.exec(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command EXISTS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe exists(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxExists(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command EXISTS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxExists(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.exists(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command EXPIRE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe expire(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxExpire(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command EXPIRE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxExpire(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.expire(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command EXPIREAT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe expireat(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxExpireat(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command EXPIREAT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxExpireat(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.expireat(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command EXPIRETIME.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe expiretime(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxExpiretime(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command EXPIRETIME.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxExpiretime(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.expiretime(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FAILOVER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe failover(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFailover(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FAILOVER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFailover(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.failover(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FCALL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe fcall(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFcall(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FCALL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFcall(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.fcall(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FCALL_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe fcallRo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFcallRo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FCALL_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFcallRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.fcallRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FLUSHALL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe flushall(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFlushall(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FLUSHALL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFlushall(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.flushall(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FLUSHDB.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe flushdb(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFlushdb(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FLUSHDB.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFlushdb(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.flushdb(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command FUNCTION.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe function(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxFunction(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command FUNCTION.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxFunction(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.function(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GEOADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe geoadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGeoadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GEOADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGeoadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.geoadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GEODIST.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe geodist(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGeodist(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GEODIST.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGeodist(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.geodist(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GEOHASH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe geohash(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGeohash(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GEOHASH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGeohash(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.geohash(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GEOPOS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe geopos(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGeopos(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GEOPOS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGeopos(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.geopos(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GEORADIUS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe georadius(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGeoradius(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GEORADIUS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGeoradius(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.georadius(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GEORADIUS_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe georadiusRo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGeoradiusRo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GEORADIUS_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGeoradiusRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.georadiusRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GEORADIUSBYMEMBER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe georadiusbymember(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGeoradiusbymember(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GEORADIUSBYMEMBER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGeoradiusbymember(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.georadiusbymember(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GEORADIUSBYMEMBER_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe georadiusbymemberRo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGeoradiusbymemberRo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GEORADIUSBYMEMBER_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGeoradiusbymemberRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.georadiusbymemberRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GEOSEARCH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe geosearch(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGeosearch(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GEOSEARCH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGeosearch(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.geosearch(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GEOSEARCHSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe geosearchstore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGeosearchstore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GEOSEARCHSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGeosearchstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.geosearchstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GET.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe get(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGet(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GET.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGet(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.get(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GETBIT.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe getbit(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGetbit(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GETBIT.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGetbit(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.getbit(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GETDEL.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe getdel(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGetdel(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GETDEL.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGetdel(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.getdel(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GETEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe getex(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGetex(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GETEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGetex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.getex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GETRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe getrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGetrange(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GETRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGetrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.getrange(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GETSET.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe getset(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGetset(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GETSET.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGetset(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.getset(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GRAPH.BULK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe graphBulk(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGraphBulk(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GRAPH.BULK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGraphBulk(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.graphBulk(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GRAPH.CONFIG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe graphConfig(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGraphConfig(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GRAPH.CONFIG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGraphConfig(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.graphConfig(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GRAPH.DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe graphDebug(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGraphDebug(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GRAPH.DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGraphDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.graphDebug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GRAPH.DELETE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe graphDelete(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGraphDelete(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GRAPH.DELETE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGraphDelete(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.graphDelete(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GRAPH.EXPLAIN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe graphExplain(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGraphExplain(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GRAPH.EXPLAIN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGraphExplain(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.graphExplain(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GRAPH.LIST.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe graphList(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGraphList(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GRAPH.LIST.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGraphList(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.graphList(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GRAPH.PROFILE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe graphProfile(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGraphProfile(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GRAPH.PROFILE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGraphProfile(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.graphProfile(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GRAPH.QUERY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe graphQuery(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGraphQuery(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GRAPH.QUERY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGraphQuery(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.graphQuery(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GRAPH.RO_QUERY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe graphRoQuery(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGraphRoQuery(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GRAPH.RO_QUERY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGraphRoQuery(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.graphRoQuery(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command GRAPH.SLOWLOG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe graphSlowlog(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxGraphSlowlog(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command GRAPH.SLOWLOG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxGraphSlowlog(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.graphSlowlog(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HDEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hdel(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHdel(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HDEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHdel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hdel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HELLO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hello(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHello(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HELLO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHello(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hello(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HEXISTS.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hexists(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHexists(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HEXISTS.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHexists(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hexists(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HGET.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hget(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHget(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HGET.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHget(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hget(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HGETALL.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hgetall(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHgetall(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HGETALL.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHgetall(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hgetall(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HINCRBY.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHincrby(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HINCRBY.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hincrby(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HINCRBYFLOAT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hincrbyfloat(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHincrbyfloat(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HINCRBYFLOAT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHincrbyfloat(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hincrbyfloat(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HKEYS.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hkeys(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHkeys(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HKEYS.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHkeys(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hkeys(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HLEN.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hlen(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHlen(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HLEN.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHlen(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hlen(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HMGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hmget(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHmget(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HMGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHmget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hmget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HMSET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hmset(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHmset(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HMSET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHmset(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hmset(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HRANDFIELD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hrandfield(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHrandfield(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HRANDFIELD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHrandfield(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hrandfield(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HSCAN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hscan(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHscan(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HSCAN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHscan(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hscan(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HSET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hset(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHset(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HSET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHset(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hset(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HSETNX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hsetnx(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHsetnx(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HSETNX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHsetnx(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hsetnx(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HSTRLEN.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hstrlen(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHstrlen(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HSTRLEN.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHstrlen(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hstrlen(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command HVALS.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe hvals(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxHvals(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command HVALS.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxHvals(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.hvals(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command INCR.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe incr(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxIncr(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command INCR.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxIncr(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.incr(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command INCRBY.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe incrby(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxIncrby(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command INCRBY.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxIncrby(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.incrby(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command INCRBYFLOAT.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe incrbyfloat(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxIncrbyfloat(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command INCRBYFLOAT.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxIncrbyfloat(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.incrbyfloat(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe info(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxInfo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.info(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.ARRAPPEND.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonArrappend(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonArrappend(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.ARRAPPEND.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonArrappend(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonArrappend(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.ARRINDEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonArrindex(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonArrindex(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.ARRINDEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonArrindex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonArrindex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.ARRINSERT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonArrinsert(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonArrinsert(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.ARRINSERT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonArrinsert(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonArrinsert(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.ARRLEN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonArrlen(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonArrlen(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.ARRLEN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonArrlen(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonArrlen(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.ARRPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonArrpop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonArrpop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.ARRPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonArrpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonArrpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.ARRTRIM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonArrtrim(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonArrtrim(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.ARRTRIM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonArrtrim(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonArrtrim(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.CLEAR.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonClear(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonClear(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.CLEAR.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonClear(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonClear(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonDebug(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonDebug(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.DEBUG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonDebug(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonDebug(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.DEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonDel(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonDel(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.DEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonDel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonDel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.FORGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonForget(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonForget(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.FORGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonForget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonForget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.GET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonGet(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonGet(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.GET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonGet(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonGet(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.MGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonMget(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonMget(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.MGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonMget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonMget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.NUMINCRBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonNumincrby(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonNumincrby(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.NUMINCRBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonNumincrby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonNumincrby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.NUMMULTBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonNummultby(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonNummultby(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.NUMMULTBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonNummultby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonNummultby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.NUMPOWBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonNumpowby(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonNumpowby(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.NUMPOWBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonNumpowby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonNumpowby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.OBJKEYS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonObjkeys(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonObjkeys(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.OBJKEYS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonObjkeys(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonObjkeys(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.OBJLEN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonObjlen(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonObjlen(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.OBJLEN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonObjlen(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonObjlen(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.RESP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonResp(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonResp(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.RESP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonResp(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonResp(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.SET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonSet(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonSet(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.SET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonSet(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonSet(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.STRAPPEND.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonStrappend(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonStrappend(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.STRAPPEND.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonStrappend(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonStrappend(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.STRLEN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonStrlen(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonStrlen(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.STRLEN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonStrlen(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonStrlen(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.TOGGLE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonToggle(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonToggle(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.TOGGLE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonToggle(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonToggle(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command JSON.TYPE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe jsonType(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxJsonType(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command JSON.TYPE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxJsonType(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.jsonType(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command KEYS.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe keys(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxKeys(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command KEYS.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxKeys(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.keys(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LASTSAVE.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lastsave() { 
    io.reactivex.rxjava3.core.Maybe ret = rxLastsave();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LASTSAVE.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLastsave() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lastsave(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LATENCY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe latency(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLatency(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LATENCY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLatency(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.latency(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LCS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lcs(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLcs(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LCS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLcs(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lcs(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LINDEX.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lindex(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLindex(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LINDEX.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLindex(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lindex(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LINSERT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe linsert(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLinsert(arg0, arg1, arg2, arg3);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LINSERT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLinsert(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.linsert(arg0, arg1, arg2, arg3, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LLEN.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe llen(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLlen(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LLEN.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLlen(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.llen(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLmove(arg0, arg1, arg2, arg3);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @param arg3 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2, java.lang.String arg3) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lmove(arg0, arg1, arg2, arg3, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LMPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lmpop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLmpop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LMPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLmpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lmpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LOLWUT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lolwut(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLolwut(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LOLWUT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLolwut(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lolwut(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lpop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLpop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LPOS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lpos(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLpos(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LPOS.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLpos(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lpos(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LPUSH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lpush(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLpush(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LPUSH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLpush(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lpush(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LPUSHX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lpushx(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLpushx(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LPUSHX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLpushx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lpushx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLrange(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lrange(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LREM.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lrem(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLrem(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LREM.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLrem(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lrem(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LSET.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe lset(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLset(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LSET.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLset(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.lset(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command LTRIM.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ltrim(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxLtrim(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command LTRIM.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxLtrim(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ltrim(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command MEMORY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe memory(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxMemory(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command MEMORY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxMemory(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.memory(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command MGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe mget(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxMget(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command MGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxMget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.mget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command MIGRATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe migrate(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxMigrate(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command MIGRATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxMigrate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.migrate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command MODULE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe module(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxModule(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command MODULE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxModule(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.module(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command MONITOR.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe monitor() { 
    io.reactivex.rxjava3.core.Maybe ret = rxMonitor();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command MONITOR.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxMonitor() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.monitor(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command MOVE.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe move(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxMove(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command MOVE.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxMove(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.move(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command MSET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe mset(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxMset(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command MSET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxMset(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.mset(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command MSETNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe msetnx(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxMsetnx(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command MSETNX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxMsetnx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.msetnx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command MULTI.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe multi() { 
    io.reactivex.rxjava3.core.Maybe ret = rxMulti();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command MULTI.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxMulti() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.multi(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command OBJECT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe object(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxObject(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command OBJECT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxObject(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.object(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PERSIST.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe persist(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPersist(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PERSIST.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPersist(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.persist(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PEXPIRE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe pexpire(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPexpire(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PEXPIRE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPexpire(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.pexpire(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PEXPIREAT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe pexpireat(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPexpireat(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PEXPIREAT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPexpireat(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.pexpireat(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PEXPIRETIME.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe pexpiretime(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPexpiretime(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PEXPIRETIME.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPexpiretime(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.pexpiretime(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PFADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe pfadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPfadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PFADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPfadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.pfadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PFCOUNT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe pfcount(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPfcount(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PFCOUNT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPfcount(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.pfcount(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PFDEBUG.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe pfdebug(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPfdebug(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PFDEBUG.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPfdebug(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.pfdebug(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PFMERGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe pfmerge(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPfmerge(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PFMERGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPfmerge(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.pfmerge(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PFSELFTEST.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe pfselftest() { 
    io.reactivex.rxjava3.core.Maybe ret = rxPfselftest();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PFSELFTEST.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPfselftest() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.pfselftest(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PING.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ping(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPing(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PING.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPing(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ping(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PSETEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe psetex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPsetex(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PSETEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPsetex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.psetex(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PSUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe psubscribe(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPsubscribe(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PSUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPsubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.psubscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PSYNC.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe psync(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPsync(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PSYNC.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPsync(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.psync(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PTTL.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe pttl(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPttl(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PTTL.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPttl(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.pttl(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PUBLISH.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe publish(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPublish(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PUBLISH.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPublish(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.publish(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PUBSUB.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe pubsub(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPubsub(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PUBSUB.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPubsub(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.pubsub(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command PUNSUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe punsubscribe(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxPunsubscribe(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command PUNSUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxPunsubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.punsubscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command QUIT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe quit(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxQuit(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command QUIT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxQuit(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.quit(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command RANDOMKEY.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe randomkey() { 
    io.reactivex.rxjava3.core.Maybe ret = rxRandomkey();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command RANDOMKEY.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxRandomkey() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.randomkey(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command READONLY.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe readonly() { 
    io.reactivex.rxjava3.core.Maybe ret = rxReadonly();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command READONLY.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxReadonly() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.readonly(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command READWRITE.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe readwrite() { 
    io.reactivex.rxjava3.core.Maybe ret = rxReadwrite();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command READWRITE.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxReadwrite() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.readwrite(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command RENAME.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rename(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxRename(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command RENAME.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxRename(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.rename(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command RENAMENX.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe renamenx(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxRenamenx(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command RENAMENX.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxRenamenx(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.renamenx(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command REPLCONF.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe replconf(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxReplconf(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command REPLCONF.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxReplconf(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.replconf(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command REPLICAOF.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe replicaof(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxReplicaof(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command REPLICAOF.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxReplicaof(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.replicaof(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command RESET.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe reset() { 
    io.reactivex.rxjava3.core.Maybe ret = rxReset();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command RESET.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxReset() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.reset(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command RESTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe restore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxRestore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command RESTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxRestore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.restore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command RESTORE-ASKING.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe restoreAsking(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxRestoreAsking(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command RESTORE-ASKING.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxRestoreAsking(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.restoreAsking(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ROLE.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe role() { 
    io.reactivex.rxjava3.core.Maybe ret = rxRole();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ROLE.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxRole() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.role(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command RPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rpop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxRpop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command RPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxRpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.rpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command RPOPLPUSH.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rpoplpush(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxRpoplpush(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command RPOPLPUSH.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxRpoplpush(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.rpoplpush(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command RPUSH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rpush(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxRpush(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command RPUSH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxRpush(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.rpush(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command RPUSHX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rpushx(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxRpushx(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command RPUSHX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxRpushx(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.rpushx(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SAVE.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe save() { 
    io.reactivex.rxjava3.core.Maybe ret = rxSave();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SAVE.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSave() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.save(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SCAN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe scan(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxScan(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SCAN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxScan(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.scan(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SCARD.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe scard(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxScard(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SCARD.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxScard(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.scard(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SCRIPT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe script(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxScript(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SCRIPT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxScript(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.script(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SDIFF.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sdiff(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSdiff(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SDIFF.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSdiff(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sdiff(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SDIFFSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sdiffstore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSdiffstore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SDIFFSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSdiffstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sdiffstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SELECT.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe select(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSelect(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SELECT.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSelect(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.select(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe set(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSet(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSet(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.set(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SETBIT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe setbit(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSetbit(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SETBIT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSetbit(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.setbit(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SETEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe setex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSetex(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SETEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSetex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.setex(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SETNX.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe setnx(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSetnx(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SETNX.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSetnx(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.setnx(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SETRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe setrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSetrange(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SETRANGE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSetrange(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.setrange(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SHUTDOWN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe shutdown(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxShutdown(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SHUTDOWN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxShutdown(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.shutdown(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SINTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sinter(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSinter(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SINTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSinter(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sinter(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SINTERCARD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sintercard(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSintercard(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SINTERCARD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSintercard(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sintercard(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SINTERSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sinterstore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSinterstore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SINTERSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSinterstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sinterstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SISMEMBER.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sismember(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSismember(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SISMEMBER.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSismember(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sismember(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SLAVEOF.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe slaveof(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSlaveof(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SLAVEOF.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSlaveof(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.slaveof(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SLOWLOG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe slowlog(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSlowlog(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SLOWLOG.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSlowlog(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.slowlog(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SMEMBERS.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe smembers(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSmembers(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SMEMBERS.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSmembers(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.smembers(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SMISMEMBER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe smismember(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSmismember(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SMISMEMBER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSmismember(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.smismember(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe smove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSmove(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SMOVE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSmove(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.smove(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SORT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sort(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSort(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SORT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSort(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sort(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SORT_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sortRo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSortRo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SORT_RO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSortRo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sortRo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe spop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSpop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.spop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SPUBLISH.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe spublish(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSpublish(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SPUBLISH.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSpublish(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.spublish(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SRANDMEMBER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe srandmember(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSrandmember(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SRANDMEMBER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSrandmember(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.srandmember(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SREM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe srem(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSrem(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SREM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSrem(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.srem(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SSCAN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sscan(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSscan(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SSCAN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSscan(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sscan(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SSUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ssubscribe(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSsubscribe(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SSUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSsubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ssubscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command STRLEN.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe strlen(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxStrlen(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command STRLEN.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxStrlen(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.strlen(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe subscribe(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSubscribe(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.subscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SUBSTR.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe substr(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSubstr(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SUBSTR.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSubstr(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.substr(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SUNION.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sunion(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSunion(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SUNION.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSunion(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sunion(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SUNIONSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sunionstore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSunionstore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SUNIONSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSunionstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sunionstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SUNSUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sunsubscribe(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSunsubscribe(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SUNSUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSunsubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sunsubscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SWAPDB.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe swapdb(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxSwapdb(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SWAPDB.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSwapdb(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.swapdb(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command SYNC.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe sync() { 
    io.reactivex.rxjava3.core.Maybe ret = rxSync();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command SYNC.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxSync() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.sync(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.ADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestAdd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestAdd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.ADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestAdd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.BYRANK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestByrank(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestByrank(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.BYRANK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestByrank(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestByrank(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.BYREVRANK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestByrevrank(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestByrevrank(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.BYREVRANK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestByrevrank(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestByrevrank(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.CDF.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestCdf(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestCdf(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.CDF.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestCdf(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestCdf(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.CREATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestCreate(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestCreate(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.CREATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestCreate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestCreate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestInfo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestInfo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.MAX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestMax(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestMax(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.MAX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestMax(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestMax(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.MERGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestMerge(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestMerge(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.MERGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestMerge(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestMerge(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.MIN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestMin(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestMin(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.MIN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestMin(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestMin(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.QUANTILE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestQuantile(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestQuantile(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.QUANTILE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestQuantile(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestQuantile(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.RANK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestRank(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestRank(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.RANK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestRank(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestRank(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.RESET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestReset(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestReset(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.RESET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestReset(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestReset(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.REVRANK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestRevrank(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestRevrank(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.REVRANK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestRevrank(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestRevrank(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TDIGEST.TRIMMED_MEAN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tdigestTrimmedMean(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTdigestTrimmedMean(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TDIGEST.TRIMMED_MEAN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTdigestTrimmedMean(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tdigestTrimmedMean(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TIME.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe time() { 
    io.reactivex.rxjava3.core.Maybe ret = rxTime();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TIME.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTime() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.time(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TIMESERIES.CLUSTERSET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe timeseriesClusterset(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTimeseriesClusterset(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TIMESERIES.CLUSTERSET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTimeseriesClusterset(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.timeseriesClusterset(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TIMESERIES.CLUSTERSETFROMSHARD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe timeseriesClustersetfromshard(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTimeseriesClustersetfromshard(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TIMESERIES.CLUSTERSETFROMSHARD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTimeseriesClustersetfromshard(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.timeseriesClustersetfromshard(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TIMESERIES.HELLO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe timeseriesHello(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTimeseriesHello(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TIMESERIES.HELLO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTimeseriesHello(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.timeseriesHello(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TIMESERIES.INFOCLUSTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe timeseriesInfocluster(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTimeseriesInfocluster(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TIMESERIES.INFOCLUSTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTimeseriesInfocluster(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.timeseriesInfocluster(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TIMESERIES.INNERCOMMUNICATION.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe timeseriesInnercommunication(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTimeseriesInnercommunication(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TIMESERIES.INNERCOMMUNICATION.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTimeseriesInnercommunication(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.timeseriesInnercommunication(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TIMESERIES.NETWORKTEST.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe timeseriesNetworktest(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTimeseriesNetworktest(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TIMESERIES.NETWORKTEST.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTimeseriesNetworktest(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.timeseriesNetworktest(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TIMESERIES.REFRESHCLUSTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe timeseriesRefreshcluster(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTimeseriesRefreshcluster(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TIMESERIES.REFRESHCLUSTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTimeseriesRefreshcluster(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.timeseriesRefreshcluster(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TOPK.ADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe topkAdd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTopkAdd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TOPK.ADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTopkAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.topkAdd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TOPK.COUNT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe topkCount(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTopkCount(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TOPK.COUNT.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTopkCount(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.topkCount(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TOPK.INCRBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe topkIncrby(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTopkIncrby(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TOPK.INCRBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTopkIncrby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.topkIncrby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TOPK.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe topkInfo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTopkInfo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TOPK.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTopkInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.topkInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TOPK.LIST.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe topkList(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTopkList(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TOPK.LIST.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTopkList(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.topkList(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TOPK.QUERY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe topkQuery(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTopkQuery(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TOPK.QUERY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTopkQuery(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.topkQuery(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TOPK.RESERVE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe topkReserve(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTopkReserve(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TOPK.RESERVE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTopkReserve(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.topkReserve(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TOUCH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe touch(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTouch(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TOUCH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTouch(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.touch(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.ADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsAdd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsAdd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.ADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsAdd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsAdd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.ALTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsAlter(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsAlter(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.ALTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsAlter(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsAlter(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.CREATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsCreate(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsCreate(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.CREATE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsCreate(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsCreate(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.CREATERULE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsCreaterule(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsCreaterule(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.CREATERULE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsCreaterule(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsCreaterule(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.DECRBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsDecrby(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsDecrby(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.DECRBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsDecrby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsDecrby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.DEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsDel(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsDel(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.DEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsDel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsDel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.DELETERULE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsDeleterule(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsDeleterule(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.DELETERULE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsDeleterule(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsDeleterule(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.GET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsGet(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsGet(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.GET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsGet(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsGet(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.INCRBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsIncrby(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsIncrby(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.INCRBY.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsIncrby(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsIncrby(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsInfo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsInfo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.INFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsInfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsInfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.MADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsMadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsMadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.MADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsMadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsMadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.MGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsMget(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsMget(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.MGET.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsMget(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsMget(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.MRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsMrange(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsMrange(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.MRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsMrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsMrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.MREVRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsMrevrange(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsMrevrange(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.MREVRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsMrevrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsMrevrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.QUERYINDEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsQueryindex(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsQueryindex(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.QUERYINDEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsQueryindex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsQueryindex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.RANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsRange(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsRange(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.RANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsRange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsRange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TS.REVRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe tsRevrange(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTsRevrange(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TS.REVRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTsRevrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.tsRevrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TTL.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe ttl(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxTtl(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TTL.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxTtl(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.ttl(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command TYPE.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe type(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxType(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command TYPE.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxType(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.type(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command UNLINK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe unlink(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxUnlink(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command UNLINK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxUnlink(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.unlink(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command UNSUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe unsubscribe(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxUnsubscribe(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command UNSUBSCRIBE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxUnsubscribe(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.unsubscribe(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command UNWATCH.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe unwatch() { 
    io.reactivex.rxjava3.core.Maybe ret = rxUnwatch();
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command UNWATCH.
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxUnwatch() { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.unwatch(new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command WAIT.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe wait(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxWait(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command WAIT.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxWait(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.wait(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command WATCH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe watch(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxWatch(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command WATCH.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxWatch(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.watch(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XACK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xack(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXack(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XACK.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXack(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xack(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XAUTOCLAIM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xautoclaim(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXautoclaim(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XAUTOCLAIM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXautoclaim(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xautoclaim(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XCLAIM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xclaim(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXclaim(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XCLAIM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXclaim(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xclaim(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XDEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xdel(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXdel(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XDEL.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXdel(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xdel(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XGROUP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xgroup(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXgroup(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XGROUP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXgroup(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xgroup(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XINFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xinfo(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXinfo(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XINFO.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXinfo(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xinfo(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XLEN.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xlen(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXlen(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XLEN.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXlen(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xlen(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XPENDING.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xpending(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXpending(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XPENDING.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXpending(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xpending(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xrange(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXrange(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XREAD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xread(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXread(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XREAD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXread(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xread(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XREADGROUP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xreadgroup(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXreadgroup(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XREADGROUP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXreadgroup(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xreadgroup(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XREVRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xrevrange(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXrevrange(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XREVRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXrevrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xrevrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XSETID.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xsetid(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXsetid(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XSETID.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXsetid(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xsetid(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command XTRIM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe xtrim(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxXtrim(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command XTRIM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxXtrim(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.xtrim(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zadd(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZadd(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZADD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZadd(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zadd(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZCARD.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zcard(java.lang.String arg0) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZcard(arg0);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZCARD.
   * @param arg0 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZcard(java.lang.String arg0) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zcard(arg0, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZCOUNT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zcount(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZcount(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZCOUNT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZcount(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zcount(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZDIFF.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zdiff(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZdiff(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZDIFF.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZdiff(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zdiff(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZDIFFSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zdiffstore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZdiffstore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZDIFFSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZdiffstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zdiffstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZINCRBY.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZincrby(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZINCRBY.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZincrby(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zincrby(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZINTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zinter(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZinter(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZINTER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZinter(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zinter(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZINTERCARD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zintercard(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZintercard(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZINTERCARD.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZintercard(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zintercard(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZINTERSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zinterstore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZinterstore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZINTERSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZinterstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zinterstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZLEXCOUNT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zlexcount(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZlexcount(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZLEXCOUNT.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZlexcount(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zlexcount(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZMPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zmpop(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZmpop(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZMPOP.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZmpop(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zmpop(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZMSCORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zmscore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZmscore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZMSCORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZmscore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zmscore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZPOPMAX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zpopmax(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZpopmax(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZPOPMAX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZpopmax(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zpopmax(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZPOPMIN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zpopmin(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZpopmin(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZPOPMIN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZpopmin(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zpopmin(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZRANDMEMBER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zrandmember(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZrandmember(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZRANDMEMBER.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZrandmember(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zrandmember(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zrange(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZrange(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZRANGEBYLEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zrangebylex(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZrangebylex(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZRANGEBYLEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZrangebylex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zrangebylex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZRANGEBYSCORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zrangebyscore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZrangebyscore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZRANGEBYSCORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZrangebyscore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zrangebyscore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZRANGESTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zrangestore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZrangestore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZRANGESTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZrangestore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zrangestore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZRANK.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zrank(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZrank(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZRANK.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZrank(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zrank(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZREM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zrem(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZrem(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZREM.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZrem(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zrem(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZREMRANGEBYLEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zremrangebylex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZremrangebylex(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZREMRANGEBYLEX.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZremrangebylex(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zremrangebylex(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZREMRANGEBYRANK.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zremrangebyrank(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZremrangebyrank(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZREMRANGEBYRANK.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZremrangebyrank(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zremrangebyrank(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZREMRANGEBYSCORE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zremrangebyscore(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZremrangebyscore(arg0, arg1, arg2);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZREMRANGEBYSCORE.
   * @param arg0 
   * @param arg1 
   * @param arg2 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZremrangebyscore(java.lang.String arg0, java.lang.String arg1, java.lang.String arg2) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zremrangebyscore(arg0, arg1, arg2, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZREVRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zrevrange(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZrevrange(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZREVRANGE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZrevrange(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zrevrange(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZREVRANGEBYLEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zrevrangebylex(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZrevrangebylex(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZREVRANGEBYLEX.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZrevrangebylex(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zrevrangebylex(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZREVRANGEBYSCORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zrevrangebyscore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZrevrangebyscore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZREVRANGEBYSCORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZrevrangebyscore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zrevrangebyscore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZREVRANK.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zrevrank(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZrevrank(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZREVRANK.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZrevrank(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zrevrank(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZSCAN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zscan(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZscan(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZSCAN.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZscan(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zscan(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZSCORE.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zscore(java.lang.String arg0, java.lang.String arg1) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZscore(arg0, arg1);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZSCORE.
   * @param arg0 
   * @param arg1 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZscore(java.lang.String arg0, java.lang.String arg1) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zscore(arg0, arg1, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZUNION.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zunion(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZunion(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZUNION.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZunion(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zunion(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

  /**
   * Redis command ZUNIONSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe zunionstore(java.util.List args) { 
    io.reactivex.rxjava3.core.Maybe ret = rxZunionstore(args);
    ret = ret.cache();
    ret.subscribe(io.vertx.rxjava3.MaybeHelper.nullObserver());
    return ret;
  }

  /**
   * Redis command ZUNIONSTORE.
   * @param args 
   * @return fluent self
   */
  public io.reactivex.rxjava3.core.Maybe rxZunionstore(java.util.List args) { 
    return AsyncResultMaybe.toMaybe( handler -> {
      delegate.zunionstore(args, new io.vertx.lang.rx.DelegatingHandler<>(handler, ar -> ar.map(event -> io.vertx.rxjava3.redis.client.Response.newInstance((io.vertx.redis.client.Response)event))));
    });
  }

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

  public static io.vertx.rxjava3.redis.client.RedisAPI api(io.vertx.rxjava3.redis.client.RedisConnection connection) { 
    io.vertx.rxjava3.redis.client.RedisAPI ret = io.vertx.rxjava3.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;
  }

}