• Home
• io.vertx
• vertx-redis-client
• 4.2.4
• source code
• RedisAPI.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

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

/*
 * Copyright 2018 Red Hat, Inc.
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * and Apache License v2.0 which accompanies this distribution.
 *
 * The Eclipse Public License is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * The Apache License v2.0 is available at
 * http://www.opensource.org/licenses/apache2.0.php
 *
 * You may elect to redistribute this code under either of these licenses.
 */
package io.vertx.redis.client;

import io.vertx.codegen.annotations.Fluent;
import io.vertx.codegen.annotations.GenIgnore;
import io.vertx.codegen.annotations.Nullable;
import io.vertx.codegen.annotations.VertxGen;
import io.vertx.core.AsyncResult;
import io.vertx.core.Future;
import io.vertx.core.Handler;
import io.vertx.redis.client.impl.RedisAPIImpl;

import java.util.List;

import static io.vertx.codegen.annotations.GenIgnore.PERMITTED_TYPE;

/**
 * Auto generated Redis API client wrapper.
 * @version redis_version:6.2.4
 */
@VertxGen
public interface RedisAPI {

  @GenIgnore(PERMITTED_TYPE)
  static RedisAPI api(Redis client) {
    return new RedisAPIImpl(client);
  }

  @GenIgnore(PERMITTED_TYPE)
  static RedisAPI api(RedisConnection connection) {
    return new RedisAPIImpl(connection);
  }

  void close();

  /**
   * Redis command acl.
   * @return fluent self
   */
  @Fluent
  default RedisAPI acl(List args, Handler> handler) {
    send(Command.ACL, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command acl.
   * @return Future response.
   */
  default Future<@Nullable Response> acl(List args) {
    return send(Command.ACL, args.toArray(new String[0]));
  }
  /**
   * Redis command append.
   * @return fluent self
   */
  @Fluent
  default RedisAPI append(String arg0, String arg1, Handler> handler) {
    send(Command.APPEND, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command append.
   * @return Future response.
   */
  default Future<@Nullable Response> append(String arg0, String arg1) {
    return send(Command.APPEND, arg0, arg1);
  }
  /**
   * Redis command asking.
   * @return fluent self
   */
  @Fluent
  default RedisAPI asking(Handler> handler) {
    send(Command.ASKING).onComplete(handler);
    return this;
  }

  /**
   * Redis command asking.
   * @return Future response.
   */
  default Future<@Nullable Response> asking() {
    return send(Command.ASKING);
  }
  /**
   * Redis command auth.
   * @return fluent self
   */
  @Fluent
  default RedisAPI auth(List args, Handler> handler) {
    send(Command.AUTH, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command auth.
   * @return Future response.
   */
  default Future<@Nullable Response> auth(List args) {
    return send(Command.AUTH, args.toArray(new String[0]));
  }
  /**
   * Redis command bgrewriteaof.
   * @return fluent self
   */
  @Fluent
  default RedisAPI bgrewriteaof(Handler> handler) {
    send(Command.BGREWRITEAOF).onComplete(handler);
    return this;
  }

  /**
   * Redis command bgrewriteaof.
   * @return Future response.
   */
  default Future<@Nullable Response> bgrewriteaof() {
    return send(Command.BGREWRITEAOF);
  }
  /**
   * Redis command bgsave.
   * @return fluent self
   */
  @Fluent
  default RedisAPI bgsave(List args, Handler> handler) {
    send(Command.BGSAVE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command bgsave.
   * @return Future response.
   */
  default Future<@Nullable Response> bgsave(List args) {
    return send(Command.BGSAVE, args.toArray(new String[0]));
  }
  /**
   * Redis command bitcount.
   * @return fluent self
   */
  @Fluent
  default RedisAPI bitcount(List args, Handler> handler) {
    send(Command.BITCOUNT, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command bitcount.
   * @return Future response.
   */
  default Future<@Nullable Response> bitcount(List args) {
    return send(Command.BITCOUNT, args.toArray(new String[0]));
  }
  /**
   * Redis command bitfield.
   * @return fluent self
   */
  @Fluent
  default RedisAPI bitfield(List args, Handler> handler) {
    send(Command.BITFIELD, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command bitfield.
   * @return Future response.
   */
  default Future<@Nullable Response> bitfield(List args) {
    return send(Command.BITFIELD, args.toArray(new String[0]));
  }
  /**
   * Redis command bitfieldRo.
   * @return fluent self
   */
  @Fluent
  default RedisAPI bitfieldRo(List args, Handler> handler) {
    send(Command.BITFIELD_RO, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command bitfieldRo.
   * @return Future response.
   */
  default Future<@Nullable Response> bitfieldRo(List args) {
    return send(Command.BITFIELD_RO, args.toArray(new String[0]));
  }
  /**
   * Redis command bitop.
   * @return fluent self
   */
  @Fluent
  default RedisAPI bitop(List args, Handler> handler) {
    send(Command.BITOP, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command bitop.
   * @return Future response.
   */
  default Future<@Nullable Response> bitop(List args) {
    return send(Command.BITOP, args.toArray(new String[0]));
  }
  /**
   * Redis command bitpos.
   * @return fluent self
   */
  @Fluent
  default RedisAPI bitpos(List args, Handler> handler) {
    send(Command.BITPOS, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command bitpos.
   * @return Future response.
   */
  default Future<@Nullable Response> bitpos(List args) {
    return send(Command.BITPOS, args.toArray(new String[0]));
  }
  /**
   * Redis command blmove.
   * @return fluent self
   */
  @Fluent
  default RedisAPI blmove(String arg0, String arg1, String arg2, String arg3, String arg4, Handler> handler) {
    send(Command.BLMOVE, arg0, arg1, arg2, arg3, arg4).onComplete(handler);
    return this;
  }

  /**
   * Redis command blmove.
   * @return Future response.
   */
  default Future<@Nullable Response> blmove(String arg0, String arg1, String arg2, String arg3, String arg4) {
    return send(Command.BLMOVE, arg0, arg1, arg2, arg3, arg4);
  }
  /**
   * Redis command blpop.
   * @return fluent self
   */
  @Fluent
  default RedisAPI blpop(List args, Handler> handler) {
    send(Command.BLPOP, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command blpop.
   * @return Future response.
   */
  default Future<@Nullable Response> blpop(List args) {
    return send(Command.BLPOP, args.toArray(new String[0]));
  }
  /**
   * Redis command brpop.
   * @return fluent self
   */
  @Fluent
  default RedisAPI brpop(List args, Handler> handler) {
    send(Command.BRPOP, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command brpop.
   * @return Future response.
   */
  default Future<@Nullable Response> brpop(List args) {
    return send(Command.BRPOP, args.toArray(new String[0]));
  }
  /**
   * Redis command brpoplpush.
   * @return fluent self
   */
  @Fluent
  default RedisAPI brpoplpush(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.BRPOPLPUSH, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command brpoplpush.
   * @return Future response.
   */
  default Future<@Nullable Response> brpoplpush(String arg0, String arg1, String arg2) {
    return send(Command.BRPOPLPUSH, arg0, arg1, arg2);
  }
  /**
   * Redis command bzpopmax.
   * @return fluent self
   */
  @Fluent
  default RedisAPI bzpopmax(List args, Handler> handler) {
    send(Command.BZPOPMAX, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command bzpopmax.
   * @return Future response.
   */
  default Future<@Nullable Response> bzpopmax(List args) {
    return send(Command.BZPOPMAX, args.toArray(new String[0]));
  }
  /**
   * Redis command bzpopmin.
   * @return fluent self
   */
  @Fluent
  default RedisAPI bzpopmin(List args, Handler> handler) {
    send(Command.BZPOPMIN, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command bzpopmin.
   * @return Future response.
   */
  default Future<@Nullable Response> bzpopmin(List args) {
    return send(Command.BZPOPMIN, args.toArray(new String[0]));
  }
  /**
   * Redis command client.
   * @return fluent self
   */
  @Fluent
  default RedisAPI client(List args, Handler> handler) {
    send(Command.CLIENT, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command client.
   * @return Future response.
   */
  default Future<@Nullable Response> client(List args) {
    return send(Command.CLIENT, args.toArray(new String[0]));
  }
  /**
   * Redis command cluster.
   * @return fluent self
   */
  @Fluent
  default RedisAPI cluster(List args, Handler> handler) {
    send(Command.CLUSTER, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command cluster.
   * @return Future response.
   */
  default Future<@Nullable Response> cluster(List args) {
    return send(Command.CLUSTER, args.toArray(new String[0]));
  }
  /**
   * Redis command command.
   * @return fluent self
   */
  @Fluent
  default RedisAPI command(List args, Handler> handler) {
    send(Command.COMMAND, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command command.
   * @return Future response.
   */
  default Future<@Nullable Response> command(List args) {
    return send(Command.COMMAND, args.toArray(new String[0]));
  }
  /**
   * Redis command config.
   * @return fluent self
   */
  @Fluent
  default RedisAPI config(List args, Handler> handler) {
    send(Command.CONFIG, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command config.
   * @return Future response.
   */
  default Future<@Nullable Response> config(List args) {
    return send(Command.CONFIG, args.toArray(new String[0]));
  }
  /**
   * Redis command copy.
   * @return fluent self
   */
  @Fluent
  default RedisAPI copy(List args, Handler> handler) {
    send(Command.COPY, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command copy.
   * @return Future response.
   */
  default Future<@Nullable Response> copy(List args) {
    return send(Command.COPY, args.toArray(new String[0]));
  }
  /**
   * Redis command dbsize.
   * @return fluent self
   */
  @Fluent
  default RedisAPI dbsize(Handler> handler) {
    send(Command.DBSIZE).onComplete(handler);
    return this;
  }

  /**
   * Redis command dbsize.
   * @return Future response.
   */
  default Future<@Nullable Response> dbsize() {
    return send(Command.DBSIZE);
  }
  /**
   * Redis command debug.
   * @return fluent self
   */
  @Fluent
  default RedisAPI debug(List args, Handler> handler) {
    send(Command.DEBUG, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command debug.
   * @return Future response.
   */
  default Future<@Nullable Response> debug(List args) {
    return send(Command.DEBUG, args.toArray(new String[0]));
  }
  /**
   * Redis command decr.
   * @return fluent self
   */
  @Fluent
  default RedisAPI decr(String arg0, Handler> handler) {
    send(Command.DECR, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command decr.
   * @return Future response.
   */
  default Future<@Nullable Response> decr(String arg0) {
    return send(Command.DECR, arg0);
  }
  /**
   * Redis command decrby.
   * @return fluent self
   */
  @Fluent
  default RedisAPI decrby(String arg0, String arg1, Handler> handler) {
    send(Command.DECRBY, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command decrby.
   * @return Future response.
   */
  default Future<@Nullable Response> decrby(String arg0, String arg1) {
    return send(Command.DECRBY, arg0, arg1);
  }
  /**
   * Redis command del.
   * @return fluent self
   */
  @Fluent
  default RedisAPI del(List args, Handler> handler) {
    send(Command.DEL, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command del.
   * @return Future response.
   */
  default Future<@Nullable Response> del(List args) {
    return send(Command.DEL, args.toArray(new String[0]));
  }
  /**
   * Redis command discard.
   * @return fluent self
   */
  @Fluent
  default RedisAPI discard(Handler> handler) {
    send(Command.DISCARD).onComplete(handler);
    return this;
  }

  /**
   * Redis command discard.
   * @return Future response.
   */
  default Future<@Nullable Response> discard() {
    return send(Command.DISCARD);
  }
  /**
   * Redis command dump.
   * @return fluent self
   */
  @Fluent
  default RedisAPI dump(String arg0, Handler> handler) {
    send(Command.DUMP, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command dump.
   * @return Future response.
   */
  default Future<@Nullable Response> dump(String arg0) {
    return send(Command.DUMP, arg0);
  }
  /**
   * Redis command echo.
   * @return fluent self
   */
  @Fluent
  default RedisAPI echo(String arg0, Handler> handler) {
    send(Command.ECHO, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command echo.
   * @return Future response.
   */
  default Future<@Nullable Response> echo(String arg0) {
    return send(Command.ECHO, arg0);
  }
  /**
   * Redis command eval.
   * @return fluent self
   */
  @Fluent
  default RedisAPI eval(List args, Handler> handler) {
    send(Command.EVAL, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command eval.
   * @return Future response.
   */
  default Future<@Nullable Response> eval(List args) {
    return send(Command.EVAL, args.toArray(new String[0]));
  }
  /**
   * Redis command evalsha.
   * @return fluent self
   */
  @Fluent
  default RedisAPI evalsha(List args, Handler> handler) {
    send(Command.EVALSHA, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command evalsha.
   * @return Future response.
   */
  default Future<@Nullable Response> evalsha(List args) {
    return send(Command.EVALSHA, args.toArray(new String[0]));
  }
  /**
   * Redis command exec.
   * @return fluent self
   */
  @Fluent
  default RedisAPI exec(Handler> handler) {
    send(Command.EXEC).onComplete(handler);
    return this;
  }

  /**
   * Redis command exec.
   * @return Future response.
   */
  default Future<@Nullable Response> exec() {
    return send(Command.EXEC);
  }
  /**
   * Redis command exists.
   * @return fluent self
   */
  @Fluent
  default RedisAPI exists(List args, Handler> handler) {
    send(Command.EXISTS, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command exists.
   * @return Future response.
   */
  default Future<@Nullable Response> exists(List args) {
    return send(Command.EXISTS, args.toArray(new String[0]));
  }
  /**
   * Redis command expire.
   * @return fluent self
   */
  @Fluent
  default RedisAPI expire(String arg0, String arg1, Handler> handler) {
    send(Command.EXPIRE, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command expire.
   * @return Future response.
   */
  default Future<@Nullable Response> expire(String arg0, String arg1) {
    return send(Command.EXPIRE, arg0, arg1);
  }
  /**
   * Redis command expireat.
   * @return fluent self
   */
  @Fluent
  default RedisAPI expireat(String arg0, String arg1, Handler> handler) {
    send(Command.EXPIREAT, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command expireat.
   * @return Future response.
   */
  default Future<@Nullable Response> expireat(String arg0, String arg1) {
    return send(Command.EXPIREAT, arg0, arg1);
  }
  /**
   * Redis command failover.
   * @return fluent self
   */
  @Fluent
  default RedisAPI failover(List args, Handler> handler) {
    send(Command.FAILOVER, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command failover.
   * @return Future response.
   */
  default Future<@Nullable Response> failover(List args) {
    return send(Command.FAILOVER, args.toArray(new String[0]));
  }
  /**
   * Redis command flushall.
   * @return fluent self
   */
  @Fluent
  default RedisAPI flushall(List args, Handler> handler) {
    send(Command.FLUSHALL, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command flushall.
   * @return Future response.
   */
  default Future<@Nullable Response> flushall(List args) {
    return send(Command.FLUSHALL, args.toArray(new String[0]));
  }
  /**
   * Redis command flushdb.
   * @return fluent self
   */
  @Fluent
  default RedisAPI flushdb(List args, Handler> handler) {
    send(Command.FLUSHDB, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command flushdb.
   * @return Future response.
   */
  default Future<@Nullable Response> flushdb(List args) {
    return send(Command.FLUSHDB, args.toArray(new String[0]));
  }
  /**
   * Redis command geoadd.
   * @return fluent self
   */
  @Fluent
  default RedisAPI geoadd(List args, Handler> handler) {
    send(Command.GEOADD, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command geoadd.
   * @return Future response.
   */
  default Future<@Nullable Response> geoadd(List args) {
    return send(Command.GEOADD, args.toArray(new String[0]));
  }
  /**
   * Redis command geodist.
   * @return fluent self
   */
  @Fluent
  default RedisAPI geodist(List args, Handler> handler) {
    send(Command.GEODIST, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command geodist.
   * @return Future response.
   */
  default Future<@Nullable Response> geodist(List args) {
    return send(Command.GEODIST, args.toArray(new String[0]));
  }
  /**
   * Redis command geohash.
   * @return fluent self
   */
  @Fluent
  default RedisAPI geohash(List args, Handler> handler) {
    send(Command.GEOHASH, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command geohash.
   * @return Future response.
   */
  default Future<@Nullable Response> geohash(List args) {
    return send(Command.GEOHASH, args.toArray(new String[0]));
  }
  /**
   * Redis command geopos.
   * @return fluent self
   */
  @Fluent
  default RedisAPI geopos(List args, Handler> handler) {
    send(Command.GEOPOS, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command geopos.
   * @return Future response.
   */
  default Future<@Nullable Response> geopos(List args) {
    return send(Command.GEOPOS, args.toArray(new String[0]));
  }
  /**
   * Redis command georadius.
   * @return fluent self
   */
  @Fluent
  default RedisAPI georadius(List args, Handler> handler) {
    send(Command.GEORADIUS, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command georadius.
   * @return Future response.
   */
  default Future<@Nullable Response> georadius(List args) {
    return send(Command.GEORADIUS, args.toArray(new String[0]));
  }
  /**
   * Redis command georadiusRo.
   * @return fluent self
   */
  @Fluent
  default RedisAPI georadiusRo(List args, Handler> handler) {
    send(Command.GEORADIUS_RO, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command georadiusRo.
   * @return Future response.
   */
  default Future<@Nullable Response> georadiusRo(List args) {
    return send(Command.GEORADIUS_RO, args.toArray(new String[0]));
  }
  /**
   * Redis command georadiusbymember.
   * @return fluent self
   */
  @Fluent
  default RedisAPI georadiusbymember(List args, Handler> handler) {
    send(Command.GEORADIUSBYMEMBER, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command georadiusbymember.
   * @return Future response.
   */
  default Future<@Nullable Response> georadiusbymember(List args) {
    return send(Command.GEORADIUSBYMEMBER, args.toArray(new String[0]));
  }
  /**
   * Redis command georadiusbymemberRo.
   * @return fluent self
   */
  @Fluent
  default RedisAPI georadiusbymemberRo(List args, Handler> handler) {
    send(Command.GEORADIUSBYMEMBER_RO, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command georadiusbymemberRo.
   * @return Future response.
   */
  default Future<@Nullable Response> georadiusbymemberRo(List args) {
    return send(Command.GEORADIUSBYMEMBER_RO, args.toArray(new String[0]));
  }
  /**
   * Redis command geosearch.
   * @return fluent self
   */
  @Fluent
  default RedisAPI geosearch(List args, Handler> handler) {
    send(Command.GEOSEARCH, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command geosearch.
   * @return Future response.
   */
  default Future<@Nullable Response> geosearch(List args) {
    return send(Command.GEOSEARCH, args.toArray(new String[0]));
  }
  /**
   * Redis command geosearchstore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI geosearchstore(List args, Handler> handler) {
    send(Command.GEOSEARCHSTORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command geosearchstore.
   * @return Future response.
   */
  default Future<@Nullable Response> geosearchstore(List args) {
    return send(Command.GEOSEARCHSTORE, args.toArray(new String[0]));
  }
  /**
   * Redis command get.
   * @return fluent self
   */
  @Fluent
  default RedisAPI get(String arg0, Handler> handler) {
    send(Command.GET, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command get.
   * @return Future response.
   */
  default Future<@Nullable Response> get(String arg0) {
    return send(Command.GET, arg0);
  }
  /**
   * Redis command getbit.
   * @return fluent self
   */
  @Fluent
  default RedisAPI getbit(String arg0, String arg1, Handler> handler) {
    send(Command.GETBIT, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command getbit.
   * @return Future response.
   */
  default Future<@Nullable Response> getbit(String arg0, String arg1) {
    return send(Command.GETBIT, arg0, arg1);
  }
  /**
   * Redis command getdel.
   * @return fluent self
   */
  @Fluent
  default RedisAPI getdel(String arg0, Handler> handler) {
    send(Command.GETDEL, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command getdel.
   * @return Future response.
   */
  default Future<@Nullable Response> getdel(String arg0) {
    return send(Command.GETDEL, arg0);
  }
  /**
   * Redis command getex.
   * @return fluent self
   */
  @Fluent
  default RedisAPI getex(List args, Handler> handler) {
    send(Command.GETEX, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command getex.
   * @return Future response.
   */
  default Future<@Nullable Response> getex(List args) {
    return send(Command.GETEX, args.toArray(new String[0]));
  }
  /**
   * Redis command getrange.
   * @return fluent self
   */
  @Fluent
  default RedisAPI getrange(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.GETRANGE, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command getrange.
   * @return Future response.
   */
  default Future<@Nullable Response> getrange(String arg0, String arg1, String arg2) {
    return send(Command.GETRANGE, arg0, arg1, arg2);
  }
  /**
   * Redis command getset.
   * @return fluent self
   */
  @Fluent
  default RedisAPI getset(String arg0, String arg1, Handler> handler) {
    send(Command.GETSET, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command getset.
   * @return Future response.
   */
  default Future<@Nullable Response> getset(String arg0, String arg1) {
    return send(Command.GETSET, arg0, arg1);
  }
  /**
   * Redis command hdel.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hdel(List args, Handler> handler) {
    send(Command.HDEL, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command hdel.
   * @return Future response.
   */
  default Future<@Nullable Response> hdel(List args) {
    return send(Command.HDEL, args.toArray(new String[0]));
  }
  /**
   * Redis command hello.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hello(List args, Handler> handler) {
    send(Command.HELLO, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command hello.
   * @return Future response.
   */
  default Future<@Nullable Response> hello(List args) {
    return send(Command.HELLO, args.toArray(new String[0]));
  }
  /**
   * Redis command hexists.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hexists(String arg0, String arg1, Handler> handler) {
    send(Command.HEXISTS, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command hexists.
   * @return Future response.
   */
  default Future<@Nullable Response> hexists(String arg0, String arg1) {
    return send(Command.HEXISTS, arg0, arg1);
  }
  /**
   * Redis command hget.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hget(String arg0, String arg1, Handler> handler) {
    send(Command.HGET, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command hget.
   * @return Future response.
   */
  default Future<@Nullable Response> hget(String arg0, String arg1) {
    return send(Command.HGET, arg0, arg1);
  }
  /**
   * Redis command hgetall.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hgetall(String arg0, Handler> handler) {
    send(Command.HGETALL, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command hgetall.
   * @return Future response.
   */
  default Future<@Nullable Response> hgetall(String arg0) {
    return send(Command.HGETALL, arg0);
  }
  /**
   * Redis command hincrby.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hincrby(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.HINCRBY, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command hincrby.
   * @return Future response.
   */
  default Future<@Nullable Response> hincrby(String arg0, String arg1, String arg2) {
    return send(Command.HINCRBY, arg0, arg1, arg2);
  }
  /**
   * Redis command hincrbyfloat.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hincrbyfloat(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.HINCRBYFLOAT, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command hincrbyfloat.
   * @return Future response.
   */
  default Future<@Nullable Response> hincrbyfloat(String arg0, String arg1, String arg2) {
    return send(Command.HINCRBYFLOAT, arg0, arg1, arg2);
  }
  /**
   * Redis command hkeys.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hkeys(String arg0, Handler> handler) {
    send(Command.HKEYS, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command hkeys.
   * @return Future response.
   */
  default Future<@Nullable Response> hkeys(String arg0) {
    return send(Command.HKEYS, arg0);
  }
  /**
   * Redis command hlen.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hlen(String arg0, Handler> handler) {
    send(Command.HLEN, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command hlen.
   * @return Future response.
   */
  default Future<@Nullable Response> hlen(String arg0) {
    return send(Command.HLEN, arg0);
  }
  /**
   * Redis command hmget.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hmget(List args, Handler> handler) {
    send(Command.HMGET, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command hmget.
   * @return Future response.
   */
  default Future<@Nullable Response> hmget(List args) {
    return send(Command.HMGET, args.toArray(new String[0]));
  }
  /**
   * Redis command hmset.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hmset(List args, Handler> handler) {
    send(Command.HMSET, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command hmset.
   * @return Future response.
   */
  default Future<@Nullable Response> hmset(List args) {
    return send(Command.HMSET, args.toArray(new String[0]));
  }
  /**
   * Redis command host.
   * @return fluent self
   */
  @Fluent
  default RedisAPI host(List args, Handler> handler) {
    send(Command.HOST, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command host.
   * @return Future response.
   */
  default Future<@Nullable Response> host(List args) {
    return send(Command.HOST, args.toArray(new String[0]));
  }
  /**
   * Redis command hrandfield.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hrandfield(List args, Handler> handler) {
    send(Command.HRANDFIELD, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command hrandfield.
   * @return Future response.
   */
  default Future<@Nullable Response> hrandfield(List args) {
    return send(Command.HRANDFIELD, args.toArray(new String[0]));
  }
  /**
   * Redis command hscan.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hscan(List args, Handler> handler) {
    send(Command.HSCAN, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command hscan.
   * @return Future response.
   */
  default Future<@Nullable Response> hscan(List args) {
    return send(Command.HSCAN, args.toArray(new String[0]));
  }
  /**
   * Redis command hset.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hset(List args, Handler> handler) {
    send(Command.HSET, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command hset.
   * @return Future response.
   */
  default Future<@Nullable Response> hset(List args) {
    return send(Command.HSET, args.toArray(new String[0]));
  }
  /**
   * Redis command hsetnx.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hsetnx(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.HSETNX, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command hsetnx.
   * @return Future response.
   */
  default Future<@Nullable Response> hsetnx(String arg0, String arg1, String arg2) {
    return send(Command.HSETNX, arg0, arg1, arg2);
  }
  /**
   * Redis command hstrlen.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hstrlen(String arg0, String arg1, Handler> handler) {
    send(Command.HSTRLEN, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command hstrlen.
   * @return Future response.
   */
  default Future<@Nullable Response> hstrlen(String arg0, String arg1) {
    return send(Command.HSTRLEN, arg0, arg1);
  }
  /**
   * Redis command hvals.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hvals(String arg0, Handler> handler) {
    send(Command.HVALS, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command hvals.
   * @return Future response.
   */
  default Future<@Nullable Response> hvals(String arg0) {
    return send(Command.HVALS, arg0);
  }
  /**
   * Redis command incr.
   * @return fluent self
   */
  @Fluent
  default RedisAPI incr(String arg0, Handler> handler) {
    send(Command.INCR, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command incr.
   * @return Future response.
   */
  default Future<@Nullable Response> incr(String arg0) {
    return send(Command.INCR, arg0);
  }
  /**
   * Redis command incrby.
   * @return fluent self
   */
  @Fluent
  default RedisAPI incrby(String arg0, String arg1, Handler> handler) {
    send(Command.INCRBY, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command incrby.
   * @return Future response.
   */
  default Future<@Nullable Response> incrby(String arg0, String arg1) {
    return send(Command.INCRBY, arg0, arg1);
  }
  /**
   * Redis command incrbyfloat.
   * @return fluent self
   */
  @Fluent
  default RedisAPI incrbyfloat(String arg0, String arg1, Handler> handler) {
    send(Command.INCRBYFLOAT, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command incrbyfloat.
   * @return Future response.
   */
  default Future<@Nullable Response> incrbyfloat(String arg0, String arg1) {
    return send(Command.INCRBYFLOAT, arg0, arg1);
  }
  /**
   * Redis command info.
   * @return fluent self
   */
  @Fluent
  default RedisAPI info(List args, Handler> handler) {
    send(Command.INFO, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command info.
   * @return Future response.
   */
  default Future<@Nullable Response> info(List args) {
    return send(Command.INFO, args.toArray(new String[0]));
  }
  /**
   * Redis command keys.
   * @return fluent self
   */
  @Fluent
  default RedisAPI keys(String arg0, Handler> handler) {
    send(Command.KEYS, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command keys.
   * @return Future response.
   */
  default Future<@Nullable Response> keys(String arg0) {
    return send(Command.KEYS, arg0);
  }
  /**
   * Redis command lastsave.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lastsave(Handler> handler) {
    send(Command.LASTSAVE).onComplete(handler);
    return this;
  }

  /**
   * Redis command lastsave.
   * @return Future response.
   */
  default Future<@Nullable Response> lastsave() {
    return send(Command.LASTSAVE);
  }
  /**
   * Redis command latency.
   * @return fluent self
   */
  @Fluent
  default RedisAPI latency(List args, Handler> handler) {
    send(Command.LATENCY, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command latency.
   * @return Future response.
   */
  default Future<@Nullable Response> latency(List args) {
    return send(Command.LATENCY, args.toArray(new String[0]));
  }
  /**
   * Redis command lindex.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lindex(String arg0, String arg1, Handler> handler) {
    send(Command.LINDEX, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command lindex.
   * @return Future response.
   */
  default Future<@Nullable Response> lindex(String arg0, String arg1) {
    return send(Command.LINDEX, arg0, arg1);
  }
  /**
   * Redis command linsert.
   * @return fluent self
   */
  @Fluent
  default RedisAPI linsert(String arg0, String arg1, String arg2, String arg3, Handler> handler) {
    send(Command.LINSERT, arg0, arg1, arg2, arg3).onComplete(handler);
    return this;
  }

  /**
   * Redis command linsert.
   * @return Future response.
   */
  default Future<@Nullable Response> linsert(String arg0, String arg1, String arg2, String arg3) {
    return send(Command.LINSERT, arg0, arg1, arg2, arg3);
  }
  /**
   * Redis command llen.
   * @return fluent self
   */
  @Fluent
  default RedisAPI llen(String arg0, Handler> handler) {
    send(Command.LLEN, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command llen.
   * @return Future response.
   */
  default Future<@Nullable Response> llen(String arg0) {
    return send(Command.LLEN, arg0);
  }
  /**
   * Redis command lmove.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lmove(String arg0, String arg1, String arg2, String arg3, Handler> handler) {
    send(Command.LMOVE, arg0, arg1, arg2, arg3).onComplete(handler);
    return this;
  }

  /**
   * Redis command lmove.
   * @return Future response.
   */
  default Future<@Nullable Response> lmove(String arg0, String arg1, String arg2, String arg3) {
    return send(Command.LMOVE, arg0, arg1, arg2, arg3);
  }
  /**
   * Redis command lolwut.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lolwut(List args, Handler> handler) {
    send(Command.LOLWUT, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command lolwut.
   * @return Future response.
   */
  default Future<@Nullable Response> lolwut(List args) {
    return send(Command.LOLWUT, args.toArray(new String[0]));
  }
  /**
   * Redis command lpop.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lpop(List args, Handler> handler) {
    send(Command.LPOP, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command lpop.
   * @return Future response.
   */
  default Future<@Nullable Response> lpop(List args) {
    return send(Command.LPOP, args.toArray(new String[0]));
  }
  /**
   * Redis command lpos.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lpos(List args, Handler> handler) {
    send(Command.LPOS, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command lpos.
   * @return Future response.
   */
  default Future<@Nullable Response> lpos(List args) {
    return send(Command.LPOS, args.toArray(new String[0]));
  }
  /**
   * Redis command lpush.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lpush(List args, Handler> handler) {
    send(Command.LPUSH, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command lpush.
   * @return Future response.
   */
  default Future<@Nullable Response> lpush(List args) {
    return send(Command.LPUSH, args.toArray(new String[0]));
  }
  /**
   * Redis command lpushx.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lpushx(List args, Handler> handler) {
    send(Command.LPUSHX, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command lpushx.
   * @return Future response.
   */
  default Future<@Nullable Response> lpushx(List args) {
    return send(Command.LPUSHX, args.toArray(new String[0]));
  }
  /**
   * Redis command lrange.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lrange(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.LRANGE, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command lrange.
   * @return Future response.
   */
  default Future<@Nullable Response> lrange(String arg0, String arg1, String arg2) {
    return send(Command.LRANGE, arg0, arg1, arg2);
  }
  /**
   * Redis command lrem.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lrem(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.LREM, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command lrem.
   * @return Future response.
   */
  default Future<@Nullable Response> lrem(String arg0, String arg1, String arg2) {
    return send(Command.LREM, arg0, arg1, arg2);
  }
  /**
   * Redis command lset.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lset(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.LSET, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command lset.
   * @return Future response.
   */
  default Future<@Nullable Response> lset(String arg0, String arg1, String arg2) {
    return send(Command.LSET, arg0, arg1, arg2);
  }
  /**
   * Redis command ltrim.
   * @return fluent self
   */
  @Fluent
  default RedisAPI ltrim(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.LTRIM, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command ltrim.
   * @return Future response.
   */
  default Future<@Nullable Response> ltrim(String arg0, String arg1, String arg2) {
    return send(Command.LTRIM, arg0, arg1, arg2);
  }
  /**
   * Redis command memory.
   * @return fluent self
   */
  @Fluent
  default RedisAPI memory(List args, Handler> handler) {
    send(Command.MEMORY, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command memory.
   * @return Future response.
   */
  default Future<@Nullable Response> memory(List args) {
    return send(Command.MEMORY, args.toArray(new String[0]));
  }
  /**
   * Redis command mget.
   * @return fluent self
   */
  @Fluent
  default RedisAPI mget(List args, Handler> handler) {
    send(Command.MGET, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command mget.
   * @return Future response.
   */
  default Future<@Nullable Response> mget(List args) {
    return send(Command.MGET, args.toArray(new String[0]));
  }
  /**
   * Redis command migrate.
   * @return fluent self
   */
  @Fluent
  default RedisAPI migrate(List args, Handler> handler) {
    send(Command.MIGRATE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command migrate.
   * @return Future response.
   */
  default Future<@Nullable Response> migrate(List args) {
    return send(Command.MIGRATE, args.toArray(new String[0]));
  }
  /**
   * Redis command module.
   * @return fluent self
   */
  @Fluent
  default RedisAPI module(List args, Handler> handler) {
    send(Command.MODULE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command module.
   * @return Future response.
   */
  default Future<@Nullable Response> module(List args) {
    return send(Command.MODULE, args.toArray(new String[0]));
  }
  /**
   * Redis command monitor.
   * @return fluent self
   */
  @Fluent
  default RedisAPI monitor(Handler> handler) {
    send(Command.MONITOR).onComplete(handler);
    return this;
  }

  /**
   * Redis command monitor.
   * @return Future response.
   */
  default Future<@Nullable Response> monitor() {
    return send(Command.MONITOR);
  }
  /**
   * Redis command move.
   * @return fluent self
   */
  @Fluent
  default RedisAPI move(String arg0, String arg1, Handler> handler) {
    send(Command.MOVE, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command move.
   * @return Future response.
   */
  default Future<@Nullable Response> move(String arg0, String arg1) {
    return send(Command.MOVE, arg0, arg1);
  }
  /**
   * Redis command mset.
   * @return fluent self
   */
  @Fluent
  default RedisAPI mset(List args, Handler> handler) {
    send(Command.MSET, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command mset.
   * @return Future response.
   */
  default Future<@Nullable Response> mset(List args) {
    return send(Command.MSET, args.toArray(new String[0]));
  }
  /**
   * Redis command msetnx.
   * @return fluent self
   */
  @Fluent
  default RedisAPI msetnx(List args, Handler> handler) {
    send(Command.MSETNX, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command msetnx.
   * @return Future response.
   */
  default Future<@Nullable Response> msetnx(List args) {
    return send(Command.MSETNX, args.toArray(new String[0]));
  }
  /**
   * Redis command multi.
   * @return fluent self
   */
  @Fluent
  default RedisAPI multi(Handler> handler) {
    send(Command.MULTI).onComplete(handler);
    return this;
  }

  /**
   * Redis command multi.
   * @return Future response.
   */
  default Future<@Nullable Response> multi() {
    return send(Command.MULTI);
  }
  /**
   * Redis command object.
   * @return fluent self
   */
  @Fluent
  default RedisAPI object(List args, Handler> handler) {
    send(Command.OBJECT, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command object.
   * @return Future response.
   */
  default Future<@Nullable Response> object(List args) {
    return send(Command.OBJECT, args.toArray(new String[0]));
  }
  /**
   * Redis command persist.
   * @return fluent self
   */
  @Fluent
  default RedisAPI persist(String arg0, Handler> handler) {
    send(Command.PERSIST, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command persist.
   * @return Future response.
   */
  default Future<@Nullable Response> persist(String arg0) {
    return send(Command.PERSIST, arg0);
  }
  /**
   * Redis command pexpire.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pexpire(String arg0, String arg1, Handler> handler) {
    send(Command.PEXPIRE, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command pexpire.
   * @return Future response.
   */
  default Future<@Nullable Response> pexpire(String arg0, String arg1) {
    return send(Command.PEXPIRE, arg0, arg1);
  }
  /**
   * Redis command pexpireat.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pexpireat(String arg0, String arg1, Handler> handler) {
    send(Command.PEXPIREAT, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command pexpireat.
   * @return Future response.
   */
  default Future<@Nullable Response> pexpireat(String arg0, String arg1) {
    return send(Command.PEXPIREAT, arg0, arg1);
  }
  /**
   * Redis command pfadd.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pfadd(List args, Handler> handler) {
    send(Command.PFADD, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command pfadd.
   * @return Future response.
   */
  default Future<@Nullable Response> pfadd(List args) {
    return send(Command.PFADD, args.toArray(new String[0]));
  }
  /**
   * Redis command pfcount.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pfcount(List args, Handler> handler) {
    send(Command.PFCOUNT, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command pfcount.
   * @return Future response.
   */
  default Future<@Nullable Response> pfcount(List args) {
    return send(Command.PFCOUNT, args.toArray(new String[0]));
  }
  /**
   * Redis command pfdebug.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pfdebug(List args, Handler> handler) {
    send(Command.PFDEBUG, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command pfdebug.
   * @return Future response.
   */
  default Future<@Nullable Response> pfdebug(List args) {
    return send(Command.PFDEBUG, args.toArray(new String[0]));
  }
  /**
   * Redis command pfmerge.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pfmerge(List args, Handler> handler) {
    send(Command.PFMERGE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command pfmerge.
   * @return Future response.
   */
  default Future<@Nullable Response> pfmerge(List args) {
    return send(Command.PFMERGE, args.toArray(new String[0]));
  }
  /**
   * Redis command pfselftest.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pfselftest(Handler> handler) {
    send(Command.PFSELFTEST).onComplete(handler);
    return this;
  }

  /**
   * Redis command pfselftest.
   * @return Future response.
   */
  default Future<@Nullable Response> pfselftest() {
    return send(Command.PFSELFTEST);
  }
  /**
   * Redis command ping.
   * @return fluent self
   */
  @Fluent
  default RedisAPI ping(List args, Handler> handler) {
    send(Command.PING, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command ping.
   * @return Future response.
   */
  default Future<@Nullable Response> ping(List args) {
    return send(Command.PING, args.toArray(new String[0]));
  }
  /**
   * Redis command post.
   * @return fluent self
   */
  @Fluent
  default RedisAPI post(List args, Handler> handler) {
    send(Command.POST, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command post.
   * @return Future response.
   */
  default Future<@Nullable Response> post(List args) {
    return send(Command.POST, args.toArray(new String[0]));
  }
  /**
   * Redis command psetex.
   * @return fluent self
   */
  @Fluent
  default RedisAPI psetex(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.PSETEX, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command psetex.
   * @return Future response.
   */
  default Future<@Nullable Response> psetex(String arg0, String arg1, String arg2) {
    return send(Command.PSETEX, arg0, arg1, arg2);
  }
  /**
   * Redis command psubscribe.
   * @return fluent self
   */
  @Fluent
  default RedisAPI psubscribe(List args, Handler> handler) {
    send(Command.PSUBSCRIBE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command psubscribe.
   * @return Future response.
   */
  default Future<@Nullable Response> psubscribe(List args) {
    return send(Command.PSUBSCRIBE, args.toArray(new String[0]));
  }
  /**
   * Redis command psync.
   * @return fluent self
   */
  @Fluent
  default RedisAPI psync(List args, Handler> handler) {
    send(Command.PSYNC, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command psync.
   * @return Future response.
   */
  default Future<@Nullable Response> psync(List args) {
    return send(Command.PSYNC, args.toArray(new String[0]));
  }
  /**
   * Redis command pttl.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pttl(String arg0, Handler> handler) {
    send(Command.PTTL, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command pttl.
   * @return Future response.
   */
  default Future<@Nullable Response> pttl(String arg0) {
    return send(Command.PTTL, arg0);
  }
  /**
   * Redis command publish.
   * @return fluent self
   */
  @Fluent
  default RedisAPI publish(String arg0, String arg1, Handler> handler) {
    send(Command.PUBLISH, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command publish.
   * @return Future response.
   */
  default Future<@Nullable Response> publish(String arg0, String arg1) {
    return send(Command.PUBLISH, arg0, arg1);
  }
  /**
   * Redis command pubsub.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pubsub(List args, Handler> handler) {
    send(Command.PUBSUB, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command pubsub.
   * @return Future response.
   */
  default Future<@Nullable Response> pubsub(List args) {
    return send(Command.PUBSUB, args.toArray(new String[0]));
  }
  /**
   * Redis command punsubscribe.
   * @return fluent self
   */
  @Fluent
  default RedisAPI punsubscribe(List args, Handler> handler) {
    send(Command.PUNSUBSCRIBE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command punsubscribe.
   * @return Future response.
   */
  default Future<@Nullable Response> punsubscribe(List args) {
    return send(Command.PUNSUBSCRIBE, args.toArray(new String[0]));
  }
  /**
   * Redis command randomkey.
   * @return fluent self
   */
  @Fluent
  default RedisAPI randomkey(Handler> handler) {
    send(Command.RANDOMKEY).onComplete(handler);
    return this;
  }

  /**
   * Redis command randomkey.
   * @return Future response.
   */
  default Future<@Nullable Response> randomkey() {
    return send(Command.RANDOMKEY);
  }
  /**
   * Redis command readonly.
   * @return fluent self
   */
  @Fluent
  default RedisAPI readonly(Handler> handler) {
    send(Command.READONLY).onComplete(handler);
    return this;
  }

  /**
   * Redis command readonly.
   * @return Future response.
   */
  default Future<@Nullable Response> readonly() {
    return send(Command.READONLY);
  }
  /**
   * Redis command readwrite.
   * @return fluent self
   */
  @Fluent
  default RedisAPI readwrite(Handler> handler) {
    send(Command.READWRITE).onComplete(handler);
    return this;
  }

  /**
   * Redis command readwrite.
   * @return Future response.
   */
  default Future<@Nullable Response> readwrite() {
    return send(Command.READWRITE);
  }
  /**
   * Redis command rename.
   * @return fluent self
   */
  @Fluent
  default RedisAPI rename(String arg0, String arg1, Handler> handler) {
    send(Command.RENAME, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command rename.
   * @return Future response.
   */
  default Future<@Nullable Response> rename(String arg0, String arg1) {
    return send(Command.RENAME, arg0, arg1);
  }
  /**
   * Redis command renamenx.
   * @return fluent self
   */
  @Fluent
  default RedisAPI renamenx(String arg0, String arg1, Handler> handler) {
    send(Command.RENAMENX, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command renamenx.
   * @return Future response.
   */
  default Future<@Nullable Response> renamenx(String arg0, String arg1) {
    return send(Command.RENAMENX, arg0, arg1);
  }
  /**
   * Redis command replconf.
   * @return fluent self
   */
  @Fluent
  default RedisAPI replconf(List args, Handler> handler) {
    send(Command.REPLCONF, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command replconf.
   * @return Future response.
   */
  default Future<@Nullable Response> replconf(List args) {
    return send(Command.REPLCONF, args.toArray(new String[0]));
  }
  /**
   * Redis command replicaof.
   * @return fluent self
   */
  @Fluent
  default RedisAPI replicaof(String arg0, String arg1, Handler> handler) {
    send(Command.REPLICAOF, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command replicaof.
   * @return Future response.
   */
  default Future<@Nullable Response> replicaof(String arg0, String arg1) {
    return send(Command.REPLICAOF, arg0, arg1);
  }
  /**
   * Redis command reset.
   * @return fluent self
   */
  @Fluent
  default RedisAPI reset(Handler> handler) {
    send(Command.RESET).onComplete(handler);
    return this;
  }

  /**
   * Redis command reset.
   * @return Future response.
   */
  default Future<@Nullable Response> reset() {
    return send(Command.RESET);
  }
  /**
   * Redis command restore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI restore(List args, Handler> handler) {
    send(Command.RESTORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command restore.
   * @return Future response.
   */
  default Future<@Nullable Response> restore(List args) {
    return send(Command.RESTORE, args.toArray(new String[0]));
  }
  /**
   * Redis command restoreAsking.
   * @return fluent self
   */
  @Fluent
  default RedisAPI restoreAsking(List args, Handler> handler) {
    send(Command.RESTORE_ASKING, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command restoreAsking.
   * @return Future response.
   */
  default Future<@Nullable Response> restoreAsking(List args) {
    return send(Command.RESTORE_ASKING, args.toArray(new String[0]));
  }
  /**
   * Redis command role.
   * @return fluent self
   */
  @Fluent
  default RedisAPI role(Handler> handler) {
    send(Command.ROLE).onComplete(handler);
    return this;
  }

  /**
   * Redis command role.
   * @return Future response.
   */
  default Future<@Nullable Response> role() {
    return send(Command.ROLE);
  }
  /**
   * Redis command rpop.
   * @return fluent self
   */
  @Fluent
  default RedisAPI rpop(List args, Handler> handler) {
    send(Command.RPOP, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command rpop.
   * @return Future response.
   */
  default Future<@Nullable Response> rpop(List args) {
    return send(Command.RPOP, args.toArray(new String[0]));
  }
  /**
   * Redis command rpoplpush.
   * @return fluent self
   */
  @Fluent
  default RedisAPI rpoplpush(String arg0, String arg1, Handler> handler) {
    send(Command.RPOPLPUSH, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command rpoplpush.
   * @return Future response.
   */
  default Future<@Nullable Response> rpoplpush(String arg0, String arg1) {
    return send(Command.RPOPLPUSH, arg0, arg1);
  }
  /**
   * Redis command rpush.
   * @return fluent self
   */
  @Fluent
  default RedisAPI rpush(List args, Handler> handler) {
    send(Command.RPUSH, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command rpush.
   * @return Future response.
   */
  default Future<@Nullable Response> rpush(List args) {
    return send(Command.RPUSH, args.toArray(new String[0]));
  }
  /**
   * Redis command rpushx.
   * @return fluent self
   */
  @Fluent
  default RedisAPI rpushx(List args, Handler> handler) {
    send(Command.RPUSHX, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command rpushx.
   * @return Future response.
   */
  default Future<@Nullable Response> rpushx(List args) {
    return send(Command.RPUSHX, args.toArray(new String[0]));
  }
  /**
   * Redis command sadd.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sadd(List args, Handler> handler) {
    send(Command.SADD, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command sadd.
   * @return Future response.
   */
  default Future<@Nullable Response> sadd(List args) {
    return send(Command.SADD, args.toArray(new String[0]));
  }
  /**
   * Redis command save.
   * @return fluent self
   */
  @Fluent
  default RedisAPI save(Handler> handler) {
    send(Command.SAVE).onComplete(handler);
    return this;
  }

  /**
   * Redis command save.
   * @return Future response.
   */
  default Future<@Nullable Response> save() {
    return send(Command.SAVE);
  }
  /**
   * Redis command scan.
   * @return fluent self
   */
  @Fluent
  default RedisAPI scan(List args, Handler> handler) {
    send(Command.SCAN, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command scan.
   * @return Future response.
   */
  default Future<@Nullable Response> scan(List args) {
    return send(Command.SCAN, args.toArray(new String[0]));
  }
  /**
   * Redis command scard.
   * @return fluent self
   */
  @Fluent
  default RedisAPI scard(String arg0, Handler> handler) {
    send(Command.SCARD, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command scard.
   * @return Future response.
   */
  default Future<@Nullable Response> scard(String arg0) {
    return send(Command.SCARD, arg0);
  }
  /**
   * Redis command script.
   * @return fluent self
   */
  @Fluent
  default RedisAPI script(List args, Handler> handler) {
    send(Command.SCRIPT, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command script.
   * @return Future response.
   */
  default Future<@Nullable Response> script(List args) {
    return send(Command.SCRIPT, args.toArray(new String[0]));
  }
  /**
   * Redis command sdiff.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sdiff(List args, Handler> handler) {
    send(Command.SDIFF, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command sdiff.
   * @return Future response.
   */
  default Future<@Nullable Response> sdiff(List args) {
    return send(Command.SDIFF, args.toArray(new String[0]));
  }
  /**
   * Redis command sdiffstore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sdiffstore(List args, Handler> handler) {
    send(Command.SDIFFSTORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command sdiffstore.
   * @return Future response.
   */
  default Future<@Nullable Response> sdiffstore(List args) {
    return send(Command.SDIFFSTORE, args.toArray(new String[0]));
  }
  /**
   * Redis command select.
   * @return fluent self
   */
  @Fluent
  default RedisAPI select(String arg0, Handler> handler) {
    send(Command.SELECT, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command select.
   * @return Future response.
   */
  default Future<@Nullable Response> select(String arg0) {
    return send(Command.SELECT, arg0);
  }
  /**
   * Redis command set.
   * @return fluent self
   */
  @Fluent
  default RedisAPI set(List args, Handler> handler) {
    send(Command.SET, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command set.
   * @return Future response.
   */
  default Future<@Nullable Response> set(List args) {
    return send(Command.SET, args.toArray(new String[0]));
  }
  /**
   * Redis command setbit.
   * @return fluent self
   */
  @Fluent
  default RedisAPI setbit(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.SETBIT, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command setbit.
   * @return Future response.
   */
  default Future<@Nullable Response> setbit(String arg0, String arg1, String arg2) {
    return send(Command.SETBIT, arg0, arg1, arg2);
  }
  /**
   * Redis command setex.
   * @return fluent self
   */
  @Fluent
  default RedisAPI setex(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.SETEX, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command setex.
   * @return Future response.
   */
  default Future<@Nullable Response> setex(String arg0, String arg1, String arg2) {
    return send(Command.SETEX, arg0, arg1, arg2);
  }
  /**
   * Redis command setnx.
   * @return fluent self
   */
  @Fluent
  default RedisAPI setnx(String arg0, String arg1, Handler> handler) {
    send(Command.SETNX, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command setnx.
   * @return Future response.
   */
  default Future<@Nullable Response> setnx(String arg0, String arg1) {
    return send(Command.SETNX, arg0, arg1);
  }
  /**
   * Redis command setrange.
   * @return fluent self
   */
  @Fluent
  default RedisAPI setrange(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.SETRANGE, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command setrange.
   * @return Future response.
   */
  default Future<@Nullable Response> setrange(String arg0, String arg1, String arg2) {
    return send(Command.SETRANGE, arg0, arg1, arg2);
  }
  /**
   * Redis command shutdown.
   * @return fluent self
   */
  @Fluent
  default RedisAPI shutdown(List args, Handler> handler) {
    send(Command.SHUTDOWN, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command shutdown.
   * @return Future response.
   */
  default Future<@Nullable Response> shutdown(List args) {
    return send(Command.SHUTDOWN, args.toArray(new String[0]));
  }
  /**
   * Redis command sinter.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sinter(List args, Handler> handler) {
    send(Command.SINTER, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command sinter.
   * @return Future response.
   */
  default Future<@Nullable Response> sinter(List args) {
    return send(Command.SINTER, args.toArray(new String[0]));
  }
  /**
   * Redis command sinterstore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sinterstore(List args, Handler> handler) {
    send(Command.SINTERSTORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command sinterstore.
   * @return Future response.
   */
  default Future<@Nullable Response> sinterstore(List args) {
    return send(Command.SINTERSTORE, args.toArray(new String[0]));
  }
  /**
   * Redis command sismember.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sismember(String arg0, String arg1, Handler> handler) {
    send(Command.SISMEMBER, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command sismember.
   * @return Future response.
   */
  default Future<@Nullable Response> sismember(String arg0, String arg1) {
    return send(Command.SISMEMBER, arg0, arg1);
  }
  /**
   * Redis command slaveof.
   * @return fluent self
   */
  @Fluent
  default RedisAPI slaveof(String arg0, String arg1, Handler> handler) {
    send(Command.SLAVEOF, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command slaveof.
   * @return Future response.
   */
  default Future<@Nullable Response> slaveof(String arg0, String arg1) {
    return send(Command.SLAVEOF, arg0, arg1);
  }
  /**
   * Redis command slowlog.
   * @return fluent self
   */
  @Fluent
  default RedisAPI slowlog(List args, Handler> handler) {
    send(Command.SLOWLOG, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command slowlog.
   * @return Future response.
   */
  default Future<@Nullable Response> slowlog(List args) {
    return send(Command.SLOWLOG, args.toArray(new String[0]));
  }
  /**
   * Redis command smembers.
   * @return fluent self
   */
  @Fluent
  default RedisAPI smembers(String arg0, Handler> handler) {
    send(Command.SMEMBERS, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command smembers.
   * @return Future response.
   */
  default Future<@Nullable Response> smembers(String arg0) {
    return send(Command.SMEMBERS, arg0);
  }
  /**
   * Redis command smismember.
   * @return fluent self
   */
  @Fluent
  default RedisAPI smismember(List args, Handler> handler) {
    send(Command.SMISMEMBER, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command smismember.
   * @return Future response.
   */
  default Future<@Nullable Response> smismember(List args) {
    return send(Command.SMISMEMBER, args.toArray(new String[0]));
  }
  /**
   * Redis command smove.
   * @return fluent self
   */
  @Fluent
  default RedisAPI smove(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.SMOVE, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command smove.
   * @return Future response.
   */
  default Future<@Nullable Response> smove(String arg0, String arg1, String arg2) {
    return send(Command.SMOVE, arg0, arg1, arg2);
  }
  /**
   * Redis command sort.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sort(List args, Handler> handler) {
    send(Command.SORT, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command sort.
   * @return Future response.
   */
  default Future<@Nullable Response> sort(List args) {
    return send(Command.SORT, args.toArray(new String[0]));
  }
  /**
   * Redis command spop.
   * @return fluent self
   */
  @Fluent
  default RedisAPI spop(List args, Handler> handler) {
    send(Command.SPOP, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command spop.
   * @return Future response.
   */
  default Future<@Nullable Response> spop(List args) {
    return send(Command.SPOP, args.toArray(new String[0]));
  }
  /**
   * Redis command srandmember.
   * @return fluent self
   */
  @Fluent
  default RedisAPI srandmember(List args, Handler> handler) {
    send(Command.SRANDMEMBER, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command srandmember.
   * @return Future response.
   */
  default Future<@Nullable Response> srandmember(List args) {
    return send(Command.SRANDMEMBER, args.toArray(new String[0]));
  }
  /**
   * Redis command srem.
   * @return fluent self
   */
  @Fluent
  default RedisAPI srem(List args, Handler> handler) {
    send(Command.SREM, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command srem.
   * @return Future response.
   */
  default Future<@Nullable Response> srem(List args) {
    return send(Command.SREM, args.toArray(new String[0]));
  }
  /**
   * Redis command sscan.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sscan(List args, Handler> handler) {
    send(Command.SSCAN, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command sscan.
   * @return Future response.
   */
  default Future<@Nullable Response> sscan(List args) {
    return send(Command.SSCAN, args.toArray(new String[0]));
  }
  /**
   * Redis command stralgo.
   * @return fluent self
   */
  @Fluent
  default RedisAPI stralgo(List args, Handler> handler) {
    send(Command.STRALGO, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command stralgo.
   * @return Future response.
   */
  default Future<@Nullable Response> stralgo(List args) {
    return send(Command.STRALGO, args.toArray(new String[0]));
  }
  /**
   * Redis command strlen.
   * @return fluent self
   */
  @Fluent
  default RedisAPI strlen(String arg0, Handler> handler) {
    send(Command.STRLEN, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command strlen.
   * @return Future response.
   */
  default Future<@Nullable Response> strlen(String arg0) {
    return send(Command.STRLEN, arg0);
  }
  /**
   * Redis command subscribe.
   * @return fluent self
   */
  @Fluent
  default RedisAPI subscribe(List args, Handler> handler) {
    send(Command.SUBSCRIBE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command subscribe.
   * @return Future response.
   */
  default Future<@Nullable Response> subscribe(List args) {
    return send(Command.SUBSCRIBE, args.toArray(new String[0]));
  }
  /**
   * Redis command substr.
   * @return fluent self
   */
  @Fluent
  default RedisAPI substr(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.SUBSTR, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command substr.
   * @return Future response.
   */
  default Future<@Nullable Response> substr(String arg0, String arg1, String arg2) {
    return send(Command.SUBSTR, arg0, arg1, arg2);
  }
  /**
   * Redis command sunion.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sunion(List args, Handler> handler) {
    send(Command.SUNION, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command sunion.
   * @return Future response.
   */
  default Future<@Nullable Response> sunion(List args) {
    return send(Command.SUNION, args.toArray(new String[0]));
  }
  /**
   * Redis command sunionstore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sunionstore(List args, Handler> handler) {
    send(Command.SUNIONSTORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command sunionstore.
   * @return Future response.
   */
  default Future<@Nullable Response> sunionstore(List args) {
    return send(Command.SUNIONSTORE, args.toArray(new String[0]));
  }
  /**
   * Redis command swapdb.
   * @return fluent self
   */
  @Fluent
  default RedisAPI swapdb(String arg0, String arg1, Handler> handler) {
    send(Command.SWAPDB, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command swapdb.
   * @return Future response.
   */
  default Future<@Nullable Response> swapdb(String arg0, String arg1) {
    return send(Command.SWAPDB, arg0, arg1);
  }
  /**
   * Redis command sync.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sync(Handler> handler) {
    send(Command.SYNC).onComplete(handler);
    return this;
  }

  /**
   * Redis command sync.
   * @return Future response.
   */
  default Future<@Nullable Response> sync() {
    return send(Command.SYNC);
  }
  /**
   * Redis command time.
   * @return fluent self
   */
  @Fluent
  default RedisAPI time(Handler> handler) {
    send(Command.TIME).onComplete(handler);
    return this;
  }

  /**
   * Redis command time.
   * @return Future response.
   */
  default Future<@Nullable Response> time() {
    return send(Command.TIME);
  }
  /**
   * Redis command touch.
   * @return fluent self
   */
  @Fluent
  default RedisAPI touch(List args, Handler> handler) {
    send(Command.TOUCH, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command touch.
   * @return Future response.
   */
  default Future<@Nullable Response> touch(List args) {
    return send(Command.TOUCH, args.toArray(new String[0]));
  }
  /**
   * Redis command ttl.
   * @return fluent self
   */
  @Fluent
  default RedisAPI ttl(String arg0, Handler> handler) {
    send(Command.TTL, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command ttl.
   * @return Future response.
   */
  default Future<@Nullable Response> ttl(String arg0) {
    return send(Command.TTL, arg0);
  }
  /**
   * Redis command type.
   * @return fluent self
   */
  @Fluent
  default RedisAPI type(String arg0, Handler> handler) {
    send(Command.TYPE, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command type.
   * @return Future response.
   */
  default Future<@Nullable Response> type(String arg0) {
    return send(Command.TYPE, arg0);
  }
  /**
   * Redis command unlink.
   * @return fluent self
   */
  @Fluent
  default RedisAPI unlink(List args, Handler> handler) {
    send(Command.UNLINK, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command unlink.
   * @return Future response.
   */
  default Future<@Nullable Response> unlink(List args) {
    return send(Command.UNLINK, args.toArray(new String[0]));
  }
  /**
   * Redis command unsubscribe.
   * @return fluent self
   */
  @Fluent
  default RedisAPI unsubscribe(List args, Handler> handler) {
    send(Command.UNSUBSCRIBE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command unsubscribe.
   * @return Future response.
   */
  default Future<@Nullable Response> unsubscribe(List args) {
    return send(Command.UNSUBSCRIBE, args.toArray(new String[0]));
  }
  /**
   * Redis command unwatch.
   * @return fluent self
   */
  @Fluent
  default RedisAPI unwatch(Handler> handler) {
    send(Command.UNWATCH).onComplete(handler);
    return this;
  }

  /**
   * Redis command unwatch.
   * @return Future response.
   */
  default Future<@Nullable Response> unwatch() {
    return send(Command.UNWATCH);
  }
  /**
   * Redis command wait.
   * @return fluent self
   */
  @Fluent
  default RedisAPI wait(String arg0, String arg1, Handler> handler) {
    send(Command.WAIT, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command wait.
   * @return Future response.
   */
  default Future<@Nullable Response> wait(String arg0, String arg1) {
    return send(Command.WAIT, arg0, arg1);
  }
  /**
   * Redis command watch.
   * @return fluent self
   */
  @Fluent
  default RedisAPI watch(List args, Handler> handler) {
    send(Command.WATCH, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command watch.
   * @return Future response.
   */
  default Future<@Nullable Response> watch(List args) {
    return send(Command.WATCH, args.toArray(new String[0]));
  }
  /**
   * Redis command xack.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xack(List args, Handler> handler) {
    send(Command.XACK, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xack.
   * @return Future response.
   */
  default Future<@Nullable Response> xack(List args) {
    return send(Command.XACK, args.toArray(new String[0]));
  }
  /**
   * Redis command xadd.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xadd(List args, Handler> handler) {
    send(Command.XADD, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xadd.
   * @return Future response.
   */
  default Future<@Nullable Response> xadd(List args) {
    return send(Command.XADD, args.toArray(new String[0]));
  }
  /**
   * Redis command xautoclaim.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xautoclaim(List args, Handler> handler) {
    send(Command.XAUTOCLAIM, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xautoclaim.
   * @return Future response.
   */
  default Future<@Nullable Response> xautoclaim(List args) {
    return send(Command.XAUTOCLAIM, args.toArray(new String[0]));
  }
  /**
   * Redis command xclaim.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xclaim(List args, Handler> handler) {
    send(Command.XCLAIM, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xclaim.
   * @return Future response.
   */
  default Future<@Nullable Response> xclaim(List args) {
    return send(Command.XCLAIM, args.toArray(new String[0]));
  }
  /**
   * Redis command xdel.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xdel(List args, Handler> handler) {
    send(Command.XDEL, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xdel.
   * @return Future response.
   */
  default Future<@Nullable Response> xdel(List args) {
    return send(Command.XDEL, args.toArray(new String[0]));
  }
  /**
   * Redis command xgroup.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xgroup(List args, Handler> handler) {
    send(Command.XGROUP, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xgroup.
   * @return Future response.
   */
  default Future<@Nullable Response> xgroup(List args) {
    return send(Command.XGROUP, args.toArray(new String[0]));
  }
  /**
   * Redis command xinfo.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xinfo(List args, Handler> handler) {
    send(Command.XINFO, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xinfo.
   * @return Future response.
   */
  default Future<@Nullable Response> xinfo(List args) {
    return send(Command.XINFO, args.toArray(new String[0]));
  }
  /**
   * Redis command xlen.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xlen(String arg0, Handler> handler) {
    send(Command.XLEN, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command xlen.
   * @return Future response.
   */
  default Future<@Nullable Response> xlen(String arg0) {
    return send(Command.XLEN, arg0);
  }
  /**
   * Redis command xpending.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xpending(List args, Handler> handler) {
    send(Command.XPENDING, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xpending.
   * @return Future response.
   */
  default Future<@Nullable Response> xpending(List args) {
    return send(Command.XPENDING, args.toArray(new String[0]));
  }
  /**
   * Redis command xrange.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xrange(List args, Handler> handler) {
    send(Command.XRANGE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xrange.
   * @return Future response.
   */
  default Future<@Nullable Response> xrange(List args) {
    return send(Command.XRANGE, args.toArray(new String[0]));
  }
  /**
   * Redis command xread.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xread(List args, Handler> handler) {
    send(Command.XREAD, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xread.
   * @return Future response.
   */
  default Future<@Nullable Response> xread(List args) {
    return send(Command.XREAD, args.toArray(new String[0]));
  }
  /**
   * Redis command xreadgroup.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xreadgroup(List args, Handler> handler) {
    send(Command.XREADGROUP, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xreadgroup.
   * @return Future response.
   */
  default Future<@Nullable Response> xreadgroup(List args) {
    return send(Command.XREADGROUP, args.toArray(new String[0]));
  }
  /**
   * Redis command xrevrange.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xrevrange(List args, Handler> handler) {
    send(Command.XREVRANGE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xrevrange.
   * @return Future response.
   */
  default Future<@Nullable Response> xrevrange(List args) {
    return send(Command.XREVRANGE, args.toArray(new String[0]));
  }
  /**
   * Redis command xsetid.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xsetid(String arg0, String arg1, Handler> handler) {
    send(Command.XSETID, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command xsetid.
   * @return Future response.
   */
  default Future<@Nullable Response> xsetid(String arg0, String arg1) {
    return send(Command.XSETID, arg0, arg1);
  }
  /**
   * Redis command xtrim.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xtrim(List args, Handler> handler) {
    send(Command.XTRIM, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command xtrim.
   * @return Future response.
   */
  default Future<@Nullable Response> xtrim(List args) {
    return send(Command.XTRIM, args.toArray(new String[0]));
  }
  /**
   * Redis command zadd.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zadd(List args, Handler> handler) {
    send(Command.ZADD, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zadd.
   * @return Future response.
   */
  default Future<@Nullable Response> zadd(List args) {
    return send(Command.ZADD, args.toArray(new String[0]));
  }
  /**
   * Redis command zcard.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zcard(String arg0, Handler> handler) {
    send(Command.ZCARD, arg0).onComplete(handler);
    return this;
  }

  /**
   * Redis command zcard.
   * @return Future response.
   */
  default Future<@Nullable Response> zcard(String arg0) {
    return send(Command.ZCARD, arg0);
  }
  /**
   * Redis command zcount.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zcount(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZCOUNT, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command zcount.
   * @return Future response.
   */
  default Future<@Nullable Response> zcount(String arg0, String arg1, String arg2) {
    return send(Command.ZCOUNT, arg0, arg1, arg2);
  }
  /**
   * Redis command zdiff.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zdiff(List args, Handler> handler) {
    send(Command.ZDIFF, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zdiff.
   * @return Future response.
   */
  default Future<@Nullable Response> zdiff(List args) {
    return send(Command.ZDIFF, args.toArray(new String[0]));
  }
  /**
   * Redis command zdiffstore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zdiffstore(List args, Handler> handler) {
    send(Command.ZDIFFSTORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zdiffstore.
   * @return Future response.
   */
  default Future<@Nullable Response> zdiffstore(List args) {
    return send(Command.ZDIFFSTORE, args.toArray(new String[0]));
  }
  /**
   * Redis command zincrby.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zincrby(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZINCRBY, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command zincrby.
   * @return Future response.
   */
  default Future<@Nullable Response> zincrby(String arg0, String arg1, String arg2) {
    return send(Command.ZINCRBY, arg0, arg1, arg2);
  }
  /**
   * Redis command zinter.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zinter(List args, Handler> handler) {
    send(Command.ZINTER, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zinter.
   * @return Future response.
   */
  default Future<@Nullable Response> zinter(List args) {
    return send(Command.ZINTER, args.toArray(new String[0]));
  }
  /**
   * Redis command zinterstore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zinterstore(List args, Handler> handler) {
    send(Command.ZINTERSTORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zinterstore.
   * @return Future response.
   */
  default Future<@Nullable Response> zinterstore(List args) {
    return send(Command.ZINTERSTORE, args.toArray(new String[0]));
  }
  /**
   * Redis command zlexcount.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zlexcount(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZLEXCOUNT, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command zlexcount.
   * @return Future response.
   */
  default Future<@Nullable Response> zlexcount(String arg0, String arg1, String arg2) {
    return send(Command.ZLEXCOUNT, arg0, arg1, arg2);
  }
  /**
   * Redis command zmscore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zmscore(List args, Handler> handler) {
    send(Command.ZMSCORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zmscore.
   * @return Future response.
   */
  default Future<@Nullable Response> zmscore(List args) {
    return send(Command.ZMSCORE, args.toArray(new String[0]));
  }
  /**
   * Redis command zpopmax.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zpopmax(List args, Handler> handler) {
    send(Command.ZPOPMAX, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zpopmax.
   * @return Future response.
   */
  default Future<@Nullable Response> zpopmax(List args) {
    return send(Command.ZPOPMAX, args.toArray(new String[0]));
  }
  /**
   * Redis command zpopmin.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zpopmin(List args, Handler> handler) {
    send(Command.ZPOPMIN, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zpopmin.
   * @return Future response.
   */
  default Future<@Nullable Response> zpopmin(List args) {
    return send(Command.ZPOPMIN, args.toArray(new String[0]));
  }
  /**
   * Redis command zrandmember.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrandmember(List args, Handler> handler) {
    send(Command.ZRANDMEMBER, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zrandmember.
   * @return Future response.
   */
  default Future<@Nullable Response> zrandmember(List args) {
    return send(Command.ZRANDMEMBER, args.toArray(new String[0]));
  }
  /**
   * Redis command zrange.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrange(List args, Handler> handler) {
    send(Command.ZRANGE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zrange.
   * @return Future response.
   */
  default Future<@Nullable Response> zrange(List args) {
    return send(Command.ZRANGE, args.toArray(new String[0]));
  }
  /**
   * Redis command zrangebylex.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrangebylex(List args, Handler> handler) {
    send(Command.ZRANGEBYLEX, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zrangebylex.
   * @return Future response.
   */
  default Future<@Nullable Response> zrangebylex(List args) {
    return send(Command.ZRANGEBYLEX, args.toArray(new String[0]));
  }
  /**
   * Redis command zrangebyscore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrangebyscore(List args, Handler> handler) {
    send(Command.ZRANGEBYSCORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zrangebyscore.
   * @return Future response.
   */
  default Future<@Nullable Response> zrangebyscore(List args) {
    return send(Command.ZRANGEBYSCORE, args.toArray(new String[0]));
  }
  /**
   * Redis command zrangestore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrangestore(List args, Handler> handler) {
    send(Command.ZRANGESTORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zrangestore.
   * @return Future response.
   */
  default Future<@Nullable Response> zrangestore(List args) {
    return send(Command.ZRANGESTORE, args.toArray(new String[0]));
  }
  /**
   * Redis command zrank.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrank(String arg0, String arg1, Handler> handler) {
    send(Command.ZRANK, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command zrank.
   * @return Future response.
   */
  default Future<@Nullable Response> zrank(String arg0, String arg1) {
    return send(Command.ZRANK, arg0, arg1);
  }
  /**
   * Redis command zrem.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrem(List args, Handler> handler) {
    send(Command.ZREM, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zrem.
   * @return Future response.
   */
  default Future<@Nullable Response> zrem(List args) {
    return send(Command.ZREM, args.toArray(new String[0]));
  }
  /**
   * Redis command zremrangebylex.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zremrangebylex(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZREMRANGEBYLEX, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command zremrangebylex.
   * @return Future response.
   */
  default Future<@Nullable Response> zremrangebylex(String arg0, String arg1, String arg2) {
    return send(Command.ZREMRANGEBYLEX, arg0, arg1, arg2);
  }
  /**
   * Redis command zremrangebyrank.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zremrangebyrank(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZREMRANGEBYRANK, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command zremrangebyrank.
   * @return Future response.
   */
  default Future<@Nullable Response> zremrangebyrank(String arg0, String arg1, String arg2) {
    return send(Command.ZREMRANGEBYRANK, arg0, arg1, arg2);
  }
  /**
   * Redis command zremrangebyscore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zremrangebyscore(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZREMRANGEBYSCORE, arg0, arg1, arg2).onComplete(handler);
    return this;
  }

  /**
   * Redis command zremrangebyscore.
   * @return Future response.
   */
  default Future<@Nullable Response> zremrangebyscore(String arg0, String arg1, String arg2) {
    return send(Command.ZREMRANGEBYSCORE, arg0, arg1, arg2);
  }
  /**
   * Redis command zrevrange.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrevrange(List args, Handler> handler) {
    send(Command.ZREVRANGE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zrevrange.
   * @return Future response.
   */
  default Future<@Nullable Response> zrevrange(List args) {
    return send(Command.ZREVRANGE, args.toArray(new String[0]));
  }
  /**
   * Redis command zrevrangebylex.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrevrangebylex(List args, Handler> handler) {
    send(Command.ZREVRANGEBYLEX, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zrevrangebylex.
   * @return Future response.
   */
  default Future<@Nullable Response> zrevrangebylex(List args) {
    return send(Command.ZREVRANGEBYLEX, args.toArray(new String[0]));
  }
  /**
   * Redis command zrevrangebyscore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrevrangebyscore(List args, Handler> handler) {
    send(Command.ZREVRANGEBYSCORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zrevrangebyscore.
   * @return Future response.
   */
  default Future<@Nullable Response> zrevrangebyscore(List args) {
    return send(Command.ZREVRANGEBYSCORE, args.toArray(new String[0]));
  }
  /**
   * Redis command zrevrank.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrevrank(String arg0, String arg1, Handler> handler) {
    send(Command.ZREVRANK, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command zrevrank.
   * @return Future response.
   */
  default Future<@Nullable Response> zrevrank(String arg0, String arg1) {
    return send(Command.ZREVRANK, arg0, arg1);
  }
  /**
   * Redis command zscan.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zscan(List args, Handler> handler) {
    send(Command.ZSCAN, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zscan.
   * @return Future response.
   */
  default Future<@Nullable Response> zscan(List args) {
    return send(Command.ZSCAN, args.toArray(new String[0]));
  }
  /**
   * Redis command zscore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zscore(String arg0, String arg1, Handler> handler) {
    send(Command.ZSCORE, arg0, arg1).onComplete(handler);
    return this;
  }

  /**
   * Redis command zscore.
   * @return Future response.
   */
  default Future<@Nullable Response> zscore(String arg0, String arg1) {
    return send(Command.ZSCORE, arg0, arg1);
  }
  /**
   * Redis command zunion.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zunion(List args, Handler> handler) {
    send(Command.ZUNION, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zunion.
   * @return Future response.
   */
  default Future<@Nullable Response> zunion(List args) {
    return send(Command.ZUNION, args.toArray(new String[0]));
  }
  /**
   * Redis command zunionstore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zunionstore(List args, Handler> handler) {
    send(Command.ZUNIONSTORE, args.toArray(new String[0])).onComplete(handler);
    return this;
  }

  /**
   * Redis command zunionstore.
   * @return Future response.
   */
  default Future<@Nullable Response> zunionstore(List args) {
    return send(Command.ZUNIONSTORE, args.toArray(new String[0]));
  }

  /**
   * Send untyped command to redis.
   *
   * @param cmd the command
   * @param args var args
   * @return Future response.
   */
  @GenIgnore
  Future<@Nullable Response> send(Command cmd, String... args);
}