• Home
• io.vertx
• vertx-redis-client
• 3.9.5
• 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.
 */
@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 append.
   * @return fluent self
   */
  @Fluent
  default RedisAPI append(String arg0, String arg1, Handler> handler) {
    send(Command.APPEND, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command asking.
   * @return fluent self
   */
  @Fluent
  default RedisAPI asking(Handler> handler) {
    send(Command.ASKING).setHandler(handler);
    return this;
  }

  /**
   * Redis command auth.
   * @return fluent self
   */
  @Fluent
  default RedisAPI auth(String arg0, Handler> handler) {
    send(Command.AUTH, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command bgrewriteaof.
   * @return fluent self
   */
  @Fluent
  default RedisAPI bgrewriteaof(Handler> handler) {
    send(Command.BGREWRITEAOF).setHandler(handler);
    return this;
  }

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

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

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

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

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

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

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

  /**
   * Redis command brpoplpush.
   * @return fluent self
   */
  @Fluent
  default RedisAPI brpoplpush(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.BRPOPLPUSH, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

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

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

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

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

  /**
   * Redis command command.
   * @return fluent self
   */
  @Fluent
  default RedisAPI command(Handler> handler) {
    send(Command.COMMAND).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command dbsize.
   * @return fluent self
   */
  @Fluent
  default RedisAPI dbsize(Handler> handler) {
    send(Command.DBSIZE).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command decr.
   * @return fluent self
   */
  @Fluent
  default RedisAPI decr(String arg0, Handler> handler) {
    send(Command.DECR, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command decrby.
   * @return fluent self
   */
  @Fluent
  default RedisAPI decrby(String arg0, String arg1, Handler> handler) {
    send(Command.DECRBY, arg0, arg1).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command discard.
   * @return fluent self
   */
  @Fluent
  default RedisAPI discard(Handler> handler) {
    send(Command.DISCARD).setHandler(handler);
    return this;
  }

  /**
   * Redis command dump.
   * @return fluent self
   */
  @Fluent
  default RedisAPI dump(String arg0, Handler> handler) {
    send(Command.DUMP, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command echo.
   * @return fluent self
   */
  @Fluent
  default RedisAPI echo(String arg0, Handler> handler) {
    send(Command.ECHO, arg0).setHandler(handler);
    return this;
  }

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

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

  /**
   * Redis command exec.
   * @return fluent self
   */
  @Fluent
  default RedisAPI exec(Handler> handler) {
    send(Command.EXEC).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command expire.
   * @return fluent self
   */
  @Fluent
  default RedisAPI expire(String arg0, String arg1, Handler> handler) {
    send(Command.EXPIRE, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command expireat.
   * @return fluent self
   */
  @Fluent
  default RedisAPI expireat(String arg0, String arg1, Handler> handler) {
    send(Command.EXPIREAT, arg0, arg1).setHandler(handler);
    return this;
  }

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

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

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

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

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

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

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

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

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

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

  /**
   * Redis command get.
   * @return fluent self
   */
  @Fluent
  default RedisAPI get(String arg0, Handler> handler) {
    send(Command.GET, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command getbit.
   * @return fluent self
   */
  @Fluent
  default RedisAPI getbit(String arg0, String arg1, Handler> handler) {
    send(Command.GETBIT, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command getrange.
   * @return fluent self
   */
  @Fluent
  default RedisAPI getrange(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.GETRANGE, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command getset.
   * @return fluent self
   */
  @Fluent
  default RedisAPI getset(String arg0, String arg1, Handler> handler) {
    send(Command.GETSET, arg0, arg1).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command hexists.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hexists(String arg0, String arg1, Handler> handler) {
    send(Command.HEXISTS, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command hget.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hget(String arg0, String arg1, Handler> handler) {
    send(Command.HGET, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command hgetall.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hgetall(String arg0, Handler> handler) {
    send(Command.HGETALL, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command hincrby.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hincrby(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.HINCRBY, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command hincrbyfloat.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hincrbyfloat(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.HINCRBYFLOAT, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command hkeys.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hkeys(String arg0, Handler> handler) {
    send(Command.HKEYS, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command hlen.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hlen(String arg0, Handler> handler) {
    send(Command.HLEN, arg0).setHandler(handler);
    return this;
  }

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

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

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

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

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

  /**
   * Redis command hsetnx.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hsetnx(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.HSETNX, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command hstrlen.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hstrlen(String arg0, String arg1, Handler> handler) {
    send(Command.HSTRLEN, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command hvals.
   * @return fluent self
   */
  @Fluent
  default RedisAPI hvals(String arg0, Handler> handler) {
    send(Command.HVALS, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command incr.
   * @return fluent self
   */
  @Fluent
  default RedisAPI incr(String arg0, Handler> handler) {
    send(Command.INCR, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command incrby.
   * @return fluent self
   */
  @Fluent
  default RedisAPI incrby(String arg0, String arg1, Handler> handler) {
    send(Command.INCRBY, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command incrbyfloat.
   * @return fluent self
   */
  @Fluent
  default RedisAPI incrbyfloat(String arg0, String arg1, Handler> handler) {
    send(Command.INCRBYFLOAT, arg0, arg1).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command keys.
   * @return fluent self
   */
  @Fluent
  default RedisAPI keys(String arg0, Handler> handler) {
    send(Command.KEYS, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command lastsave.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lastsave(Handler> handler) {
    send(Command.LASTSAVE).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command lindex.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lindex(String arg0, String arg1, Handler> handler) {
    send(Command.LINDEX, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * 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).setHandler(handler);
    return this;
  }

  /**
   * Redis command llen.
   * @return fluent self
   */
  @Fluent
  default RedisAPI llen(String arg0, Handler> handler) {
    send(Command.LLEN, arg0).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command lpop.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lpop(String arg0, Handler> handler) {
    send(Command.LPOP, arg0).setHandler(handler);
    return this;
  }

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

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

  /**
   * Redis command lrange.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lrange(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.LRANGE, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command lrem.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lrem(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.LREM, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command lset.
   * @return fluent self
   */
  @Fluent
  default RedisAPI lset(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.LSET, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command ltrim.
   * @return fluent self
   */
  @Fluent
  default RedisAPI ltrim(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.LTRIM, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

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

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

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

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

  /**
   * Redis command monitor.
   * @return fluent self
   */
  @Fluent
  default RedisAPI monitor(Handler> handler) {
    send(Command.MONITOR).setHandler(handler);
    return this;
  }

  /**
   * Redis command move.
   * @return fluent self
   */
  @Fluent
  default RedisAPI move(String arg0, String arg1, Handler> handler) {
    send(Command.MOVE, arg0, arg1).setHandler(handler);
    return this;
  }

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

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

  /**
   * Redis command multi.
   * @return fluent self
   */
  @Fluent
  default RedisAPI multi(Handler> handler) {
    send(Command.MULTI).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command persist.
   * @return fluent self
   */
  @Fluent
  default RedisAPI persist(String arg0, Handler> handler) {
    send(Command.PERSIST, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command pexpire.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pexpire(String arg0, String arg1, Handler> handler) {
    send(Command.PEXPIRE, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command pexpireat.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pexpireat(String arg0, String arg1, Handler> handler) {
    send(Command.PEXPIREAT, arg0, arg1).setHandler(handler);
    return this;
  }

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

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

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

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

  /**
   * Redis command pfselftest.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pfselftest(Handler> handler) {
    send(Command.PFSELFTEST).setHandler(handler);
    return this;
  }

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

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

  /**
   * Redis command psetex.
   * @return fluent self
   */
  @Fluent
  default RedisAPI psetex(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.PSETEX, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command psync.
   * @return fluent self
   */
  @Fluent
  default RedisAPI psync(String arg0, String arg1, Handler> handler) {
    send(Command.PSYNC, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command pttl.
   * @return fluent self
   */
  @Fluent
  default RedisAPI pttl(String arg0, Handler> handler) {
    send(Command.PTTL, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command publish.
   * @return fluent self
   */
  @Fluent
  default RedisAPI publish(String arg0, String arg1, Handler> handler) {
    send(Command.PUBLISH, arg0, arg1).setHandler(handler);
    return this;
  }

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

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

  /**
   * Redis command randomkey.
   * @return fluent self
   */
  @Fluent
  default RedisAPI randomkey(Handler> handler) {
    send(Command.RANDOMKEY).setHandler(handler);
    return this;
  }

  /**
   * Redis command readonly.
   * @return fluent self
   */
  @Fluent
  default RedisAPI readonly(Handler> handler) {
    send(Command.READONLY).setHandler(handler);
    return this;
  }

  /**
   * Redis command readwrite.
   * @return fluent self
   */
  @Fluent
  default RedisAPI readwrite(Handler> handler) {
    send(Command.READWRITE).setHandler(handler);
    return this;
  }

  /**
   * Redis command rename.
   * @return fluent self
   */
  @Fluent
  default RedisAPI rename(String arg0, String arg1, Handler> handler) {
    send(Command.RENAME, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command renamenx.
   * @return fluent self
   */
  @Fluent
  default RedisAPI renamenx(String arg0, String arg1, Handler> handler) {
    send(Command.RENAMENX, arg0, arg1).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command replicaof.
   * @return fluent self
   */
  @Fluent
  default RedisAPI replicaof(String arg0, String arg1, Handler> handler) {
    send(Command.REPLICAOF, arg0, arg1).setHandler(handler);
    return this;
  }

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

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

  /**
   * Redis command role.
   * @return fluent self
   */
  @Fluent
  default RedisAPI role(Handler> handler) {
    send(Command.ROLE).setHandler(handler);
    return this;
  }

  /**
   * Redis command rpop.
   * @return fluent self
   */
  @Fluent
  default RedisAPI rpop(String arg0, Handler> handler) {
    send(Command.RPOP, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command rpoplpush.
   * @return fluent self
   */
  @Fluent
  default RedisAPI rpoplpush(String arg0, String arg1, Handler> handler) {
    send(Command.RPOPLPUSH, arg0, arg1).setHandler(handler);
    return this;
  }

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

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

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

  /**
   * Redis command save.
   * @return fluent self
   */
  @Fluent
  default RedisAPI save(Handler> handler) {
    send(Command.SAVE).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command scard.
   * @return fluent self
   */
  @Fluent
  default RedisAPI scard(String arg0, Handler> handler) {
    send(Command.SCARD, arg0).setHandler(handler);
    return this;
  }

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

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

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

  /**
   * Redis command select.
   * @return fluent self
   */
  @Fluent
  default RedisAPI select(String arg0, Handler> handler) {
    send(Command.SELECT, arg0).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command setbit.
   * @return fluent self
   */
  @Fluent
  default RedisAPI setbit(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.SETBIT, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command setex.
   * @return fluent self
   */
  @Fluent
  default RedisAPI setex(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.SETEX, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command setnx.
   * @return fluent self
   */
  @Fluent
  default RedisAPI setnx(String arg0, String arg1, Handler> handler) {
    send(Command.SETNX, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command setrange.
   * @return fluent self
   */
  @Fluent
  default RedisAPI setrange(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.SETRANGE, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

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

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

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

  /**
   * Redis command sismember.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sismember(String arg0, String arg1, Handler> handler) {
    send(Command.SISMEMBER, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command slaveof.
   * @return fluent self
   */
  @Fluent
  default RedisAPI slaveof(String arg0, String arg1, Handler> handler) {
    send(Command.SLAVEOF, arg0, arg1).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command smembers.
   * @return fluent self
   */
  @Fluent
  default RedisAPI smembers(String arg0, Handler> handler) {
    send(Command.SMEMBERS, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command smove.
   * @return fluent self
   */
  @Fluent
  default RedisAPI smove(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.SMOVE, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

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

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

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

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

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

  /**
   * Redis command strlen.
   * @return fluent self
   */
  @Fluent
  default RedisAPI strlen(String arg0, Handler> handler) {
    send(Command.STRLEN, arg0).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command substr.
   * @return fluent self
   */
  @Fluent
  default RedisAPI substr(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.SUBSTR, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

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

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

  /**
   * Redis command swapdb.
   * @return fluent self
   */
  @Fluent
  default RedisAPI swapdb(String arg0, String arg1, Handler> handler) {
    send(Command.SWAPDB, arg0, arg1).setHandler(handler);
    return this;
  }

  /**
   * Redis command sync.
   * @return fluent self
   */
  @Fluent
  default RedisAPI sync(Handler> handler) {
    send(Command.SYNC).setHandler(handler);
    return this;
  }

  /**
   * Redis command time.
   * @return fluent self
   */
  @Fluent
  default RedisAPI time(Handler> handler) {
    send(Command.TIME).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command ttl.
   * @return fluent self
   */
  @Fluent
  default RedisAPI ttl(String arg0, Handler> handler) {
    send(Command.TTL, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command type.
   * @return fluent self
   */
  @Fluent
  default RedisAPI type(String arg0, Handler> handler) {
    send(Command.TYPE, arg0).setHandler(handler);
    return this;
  }

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

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

  /**
   * Redis command unwatch.
   * @return fluent self
   */
  @Fluent
  default RedisAPI unwatch(Handler> handler) {
    send(Command.UNWATCH).setHandler(handler);
    return this;
  }

  /**
   * Redis command wait.
   * @return fluent self
   */
  @Fluent
  default RedisAPI wait(String arg0, String arg1, Handler> handler) {
    send(Command.WAIT, arg0, arg1).setHandler(handler);
    return this;
  }

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

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

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

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

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

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

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

  /**
   * Redis command xlen.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xlen(String arg0, Handler> handler) {
    send(Command.XLEN, arg0).setHandler(handler);
    return this;
  }

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

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

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

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

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

  /**
   * Redis command xsetid.
   * @return fluent self
   */
  @Fluent
  default RedisAPI xsetid(String arg0, String arg1, Handler> handler) {
    send(Command.XSETID, arg0, arg1).setHandler(handler);
    return this;
  }

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

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

  /**
   * Redis command zcard.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zcard(String arg0, Handler> handler) {
    send(Command.ZCARD, arg0).setHandler(handler);
    return this;
  }

  /**
   * Redis command zcount.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zcount(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZCOUNT, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command zincrby.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zincrby(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZINCRBY, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command zlexcount.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zlexcount(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZLEXCOUNT, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

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

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

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

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

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

  /**
   * Redis command zrank.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrank(String arg0, String arg1, Handler> handler) {
    send(Command.ZRANK, arg0, arg1).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command zremrangebylex.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zremrangebylex(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZREMRANGEBYLEX, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command zremrangebyrank.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zremrangebyrank(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZREMRANGEBYRANK, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

  /**
   * Redis command zremrangebyscore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zremrangebyscore(String arg0, String arg1, String arg2, Handler> handler) {
    send(Command.ZREMRANGEBYSCORE, arg0, arg1, arg2).setHandler(handler);
    return this;
  }

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

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

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

  /**
   * Redis command zrevrank.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zrevrank(String arg0, String arg1, Handler> handler) {
    send(Command.ZREVRANK, arg0, arg1).setHandler(handler);
    return this;
  }

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

  /**
   * Redis command zscore.
   * @return fluent self
   */
  @Fluent
  default RedisAPI zscore(String arg0, String arg1, Handler> handler) {
    send(Command.ZSCORE, arg0, arg1).setHandler(handler);
    return this;
  }

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

  /**
   * 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);
}