io.quarkus.redis.runtime.client.ReactiveRedisClientImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of quarkus-redis-client Show documentation
Connect to Redis in either imperative or reactive style
There is a newer version: 3.17.5
package io.quarkus.redis.runtime.client;

import java.util.List;

import io.quarkus.redis.client.reactive.ReactiveRedisClient;
import io.smallrye.mutiny.Uni;
import io.vertx.mutiny.redis.client.Command;
import io.vertx.mutiny.redis.client.Redis;
import io.vertx.mutiny.redis.client.RedisAPI;
import io.vertx.mutiny.redis.client.Request;
import io.vertx.mutiny.redis.client.Response;

class ReactiveRedisClientImpl implements ReactiveRedisClient {
    private final RedisAPI redisAPI;
    private final Redis redis;

    public ReactiveRedisClientImpl(Redis redis, RedisAPI redisAPI) {
        this.redis = redis;
        this.redisAPI = redisAPI;
    }

    @Override
    public void close() {
        redisAPI.close();
    }

    @Override
    public Uni append(String arg0, String arg1) {
        return redisAPI.append(arg0, arg1);
    }

    @Override
    public Response appendAndAwait(String arg0, String arg1) {
        return redisAPI.appendAndAwait(arg0, arg1);
    }

    @Override
    public Uni asking() {
        return redisAPI.asking();
    }

    @Override
    public Response askingAndAwait() {
        return redisAPI.askingAndAwait();
    }

    @Override
    public Uni auth(List args) {
        return redisAPI.auth(args);
    }

    @Override
    public Response authAndAwait(List args) {
        return redisAPI.authAndAwait(args);
    }

    @Override
    public Uni bgrewriteaof() {
        return redisAPI.bgrewriteaof();
    }

    @Override
    public Response bgrewriteaofAndAwait() {
        return redisAPI.bgrewriteaofAndAwait();
    }

    @Override
    public Uni bgsave(List args) {
        return redisAPI.bgsave(args);
    }

    @Override
    public Response bgsaveAndAwait(List args) {
        return redisAPI.bgsaveAndAwait(args);
    }

    @Override
    public Uni bitcount(List args) {
        return redisAPI.bitcount(args);
    }

    @Override
    public Response bitcountAndAwait(List args) {
        return redisAPI.bitcountAndAwait(args);
    }

    @Override
    public Uni bitfield(List args) {
        return redisAPI.bitfield(args);
    }

    @Override
    public Response bitfieldAndAwait(List args) {
        return redisAPI.bitfieldAndAwait(args);
    }

    @Override
    public Uni bitop(List args) {
        return redisAPI.bitop(args);
    }

    @Override
    public Response bitopAndAwait(List args) {
        return redisAPI.bitopAndAwait(args);
    }

    @Override
    public Uni bitpos(List args) {
        return redisAPI.bitpos(args);
    }

    @Override
    public Response bitposAndAwait(List args) {
        return redisAPI.bitposAndAwait(args);
    }

    @Override
    public Uni blpop(List args) {
        return redisAPI.blpop(args);
    }

    @Override
    public Response blpopAndAwait(List args) {
        return redisAPI.blpopAndAwait(args);
    }

    @Override
    public Uni brpop(List args) {
        return redisAPI.brpop(args);
    }

    @Override
    public Response brpopAndAwait(List args) {
        return redisAPI.brpopAndAwait(args);
    }

    @Override
    public Uni brpoplpush(String arg0, String arg1, String arg2) {
        return redisAPI.brpoplpush(arg0, arg1, arg2);
    }

    @Override
    public Response brpoplpushAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.brpoplpushAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni bzpopmax(List args) {
        return redisAPI.bzpopmax(args);
    }

    @Override
    public Response bzpopmaxAndAwait(List args) {
        return redisAPI.bzpopmaxAndAwait(args);
    }

    @Override
    public Uni bzpopmin(List args) {
        return redisAPI.bzpopmin(args);
    }

    @Override
    public Response bzpopminAndAwait(List args) {
        return redisAPI.bzpopminAndAwait(args);
    }

    @Override
    public Uni client(List args) {
        return redisAPI.client(args);
    }

    @Override
    public Response clientAndAwait(List args) {
        return redisAPI.clientAndAwait(args);
    }

    @Override
    public Uni cluster(List args) {
        return redisAPI.cluster(args);
    }

    @Override
    public Response clusterAndAwait(List args) {
        return redisAPI.clusterAndAwait(args);
    }

    @Override
    public Uni command(List args) {
        return redisAPI.command(args);
    }

    @Override
    public Response commandAndAwait(List args) {
        return redisAPI.commandAndAwait(args);
    }

    @Override
    public Uni config(List args) {
        return redisAPI.config(args);
    }

    @Override
    public Response configAndAwait(List args) {
        return redisAPI.configAndAwait(args);
    }

    @Override
    public Uni dbsize() {
        return redisAPI.dbsize();
    }

    @Override
    public Response dbsizeAndAwait() {
        return redisAPI.dbsizeAndAwait();
    }

    @Override
    public Uni debug(List args) {
        return redisAPI.debug(args);
    }

    @Override
    public Response debugAndAwait(List args) {
        return redisAPI.debugAndAwait(args);
    }

    @Override
    public Uni decr(String arg0) {
        return redisAPI.decr(arg0);
    }

    @Override
    public Response decrAndAwait(String arg0) {
        return redisAPI.decrAndAwait(arg0);
    }

    @Override
    public Uni decrby(String arg0, String arg1) {
        return redisAPI.decrby(arg0, arg1);
    }

    @Override
    public Response decrbyAndAwait(String arg0, String arg1) {
        return redisAPI.decrbyAndAwait(arg0, arg1);
    }

    @Override
    public Uni del(List args) {
        return redisAPI.del(args);
    }

    @Override
    public Response delAndAwait(List args) {
        return redisAPI.delAndAwait(args);
    }

    @Override
    public Uni discard() {
        return redisAPI.discard();
    }

    @Override
    public Response discardAndAwait() {
        return redisAPI.discardAndAwait();
    }

    @Override
    public Uni dump(String arg0) {
        return redisAPI.dump(arg0);
    }

    @Override
    public Response dumpAndAwait(String arg0) {
        return redisAPI.dumpAndAwait(arg0);
    }

    @Override
    public Uni echo(String arg0) {
        return redisAPI.echo(arg0);
    }

    @Override
    public Response echoAndAwait(String arg0) {
        return redisAPI.echoAndAwait(arg0);
    }

    @Override
    public Uni eval(List args) {
        return redisAPI.eval(args);
    }

    @Override
    public Response evalAndAwait(List args) {
        return redisAPI.evalAndAwait(args);
    }

    @Override
    public Uni evalsha(List args) {
        return redisAPI.evalsha(args);
    }

    @Override
    public Response evalshaAndAwait(List args) {
        return redisAPI.evalshaAndAwait(args);
    }

    @Override
    public Uni exec() {
        return redisAPI.exec();
    }

    @Override
    public Response execAndAwait() {
        return redisAPI.execAndAwait();
    }

    @Override
    public Uni exists(List args) {
        return redisAPI.exists(args);
    }

    @Override
    public Response existsAndAwait(List args) {
        return redisAPI.existsAndAwait(args);
    }

    @Override
    public Uni expire(String arg0, String arg1) {
        return redisAPI.expire(List.of(arg0, arg1));
    }

    @Override
    public Response expireAndAwait(String arg0, String arg1) {
        return redisAPI.expireAndAwait(List.of(arg0, arg1));
    }

    @Override
    public Uni expireat(String arg0, String arg1) {
        return redisAPI.expireat(List.of(arg0, arg1));
    }

    @Override
    public Response expireatAndAwait(String arg0, String arg1) {
        return redisAPI.expireatAndAwait(List.of(arg0, arg1));
    }

    @Override
    public Uni flushall(List args) {
        return redisAPI.flushall(args);
    }

    @Override
    public Response flushallAndAwait(List args) {
        return redisAPI.flushallAndAwait(args);
    }

    @Override
    public Uni flushdb(List args) {
        return redisAPI.flushdb(args);
    }

    @Override
    public Response flushdbAndAwait(List args) {
        return redisAPI.flushdbAndAwait(args);
    }

    @Override
    public Uni geoadd(List args) {
        return redisAPI.geoadd(args);
    }

    @Override
    public Response geoaddAndAwait(List args) {
        return redisAPI.geoaddAndAwait(args);
    }

    @Override
    public Uni geodist(List args) {
        return redisAPI.geodist(args);
    }

    @Override
    public Response geodistAndAwait(List args) {
        return redisAPI.geodistAndAwait(args);
    }

    @Override
    public Uni geohash(List args) {
        return redisAPI.geohash(args);
    }

    @Override
    public Response geohashAndAwait(List args) {
        return redisAPI.geohashAndAwait(args);
    }

    @Override
    public Uni geopos(List args) {
        return redisAPI.geopos(args);
    }

    @Override
    public Response geoposAndAwait(List args) {
        return redisAPI.geoposAndAwait(args);
    }

    @Override
    public Uni georadius(List args) {
        return redisAPI.georadius(args);
    }

    @Override
    public Response georadiusAndAwait(List args) {
        return redisAPI.georadiusAndAwait(args);
    }

    @Override
    public Uni georadiusRo(List args) {
        return redisAPI.georadiusRo(args);
    }

    @Override
    public Response georadiusRoAndAwait(List args) {
        return redisAPI.georadiusRoAndAwait(args);
    }

    @Override
    public Uni georadiusbymember(List args) {
        return redisAPI.georadiusbymember(args);
    }

    @Override
    public Response georadiusbymemberAndAwait(List args) {
        return redisAPI.georadiusbymemberAndAwait(args);
    }

    @Override
    public Uni georadiusbymemberRo(List args) {
        return redisAPI.georadiusbymemberRo(args);
    }

    @Override
    public Response georadiusbymemberRoAndAwait(List args) {
        return redisAPI.georadiusbymemberRoAndAwait(args);
    }

    @Override
    public Uni get(String arg0) {
        return redisAPI.get(arg0);
    }

    @Override
    public Response getAndAwait(String arg0) {
        return redisAPI.getAndAwait(arg0);
    }

    @Override
    public Uni getbit(String arg0, String arg1) {
        return redisAPI.getbit(arg0, arg1);
    }

    @Override
    public Response getbitAndAwait(String arg0, String arg1) {
        return redisAPI.getbitAndAwait(arg0, arg1);
    }

    @Override
    public Uni getrange(String arg0, String arg1, String arg2) {
        return redisAPI.getrange(arg0, arg1, arg2);
    }

    @Override
    public Response getrangeAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.getrangeAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni getset(String arg0, String arg1) {
        return redisAPI.getset(arg0, arg1);
    }

    @Override
    public Response getsetAndAwait(String arg0, String arg1) {
        return redisAPI.getsetAndAwait(arg0, arg1);
    }

    @Override
    public Uni hdel(List args) {
        return redisAPI.hdel(args);
    }

    @Override
    public Response hdelAndAwait(List args) {
        return redisAPI.hdelAndAwait(args);
    }

    @Override
    public Uni hexists(String arg0, String arg1) {
        return redisAPI.hexists(arg0, arg1);
    }

    @Override
    public Response hexistsAndAwait(String arg0, String arg1) {
        return redisAPI.hexistsAndAwait(arg0, arg1);
    }

    @Override
    public Uni hget(String arg0, String arg1) {
        return redisAPI.hget(arg0, arg1);
    }

    @Override
    public Response hgetAndAwait(String arg0, String arg1) {
        return redisAPI.hgetAndAwait(arg0, arg1);
    }

    @Override
    public Uni hgetall(String arg0) {
        return redisAPI.hgetall(arg0);
    }

    @Override
    public Response hgetallAndAwait(String arg0) {
        return redisAPI.hgetallAndAwait(arg0);
    }

    @Override
    public Uni hincrby(String arg0, String arg1, String arg2) {
        return redisAPI.hincrby(arg0, arg1, arg2);
    }

    @Override
    public Response hincrbyAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.hincrbyAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni hincrbyfloat(String arg0, String arg1, String arg2) {
        return redisAPI.hincrbyfloat(arg0, arg1, arg2);
    }

    @Override
    public Response hincrbyfloatAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.hincrbyfloatAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni hkeys(String arg0) {
        return redisAPI.hkeys(arg0);
    }

    @Override
    public Response hkeysAndAwait(String arg0) {
        return redisAPI.hkeysAndAwait(arg0);
    }

    @Override
    public Uni hlen(String arg0) {
        return redisAPI.hlen(arg0);
    }

    @Override
    public Response hlenAndAwait(String arg0) {
        return redisAPI.hlenAndAwait(arg0);
    }

    @Override
    public Uni hmget(List args) {
        return redisAPI.hmget(args);
    }

    @Override
    public Response hmgetAndAwait(List args) {
        return redisAPI.hmgetAndAwait(args);
    }

    @Override
    public Uni hmset(List args) {
        return redisAPI.hmset(args);
    }

    @Override
    public Response hmsetAndAwait(List args) {
        return redisAPI.hmsetAndAwait(args);
    }

    @Override
    public Uni host(List args) {
        return redis.send(Request.cmd(Command.create("host"), args.toArray(new String[0])));
    }

    @Override
    public Response hostAndAwait(List args) {
        return host(args).await().indefinitely();
    }

    @Override
    public Uni hscan(List args) {
        return redisAPI.hscan(args);
    }

    @Override
    public Response hscanAndAwait(List args) {
        return redisAPI.hscanAndAwait(args);
    }

    @Override
    public Uni hset(List args) {
        return redisAPI.hset(args);
    }

    @Override
    public Response hsetAndAwait(List args) {
        return redisAPI.hsetAndAwait(args);
    }

    @Override
    public Uni hsetnx(String arg0, String arg1, String arg2) {
        return redisAPI.hsetnx(arg0, arg1, arg2);
    }

    @Override
    public Response hsetnxAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.hsetnxAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni hstrlen(String arg0, String arg1) {
        return redisAPI.hstrlen(arg0, arg1);
    }

    @Override
    public Response hstrlenAndAwait(String arg0, String arg1) {
        return redisAPI.hstrlenAndAwait(arg0, arg1);
    }

    @Override
    public Uni hvals(String arg0) {
        return redisAPI.hvals(arg0);
    }

    @Override
    public Response hvalsAndAwait(String arg0) {
        return redisAPI.hvalsAndAwait(arg0);
    }

    @Override
    public Uni incr(String arg0) {
        return redisAPI.incr(arg0);
    }

    @Override
    public Response incrAndAwait(String arg0) {
        return redisAPI.incrAndAwait(arg0);
    }

    @Override
    public Uni incrby(String arg0, String arg1) {
        return redisAPI.incrby(arg0, arg1);
    }

    @Override
    public Response incrbyAndAwait(String arg0, String arg1) {
        return redisAPI.incrbyAndAwait(arg0, arg1);
    }

    @Override
    public Uni incrbyfloat(String arg0, String arg1) {
        return redisAPI.incrbyfloat(arg0, arg1);
    }

    @Override
    public Response incrbyfloatAndAwait(String arg0, String arg1) {
        return redisAPI.incrbyfloatAndAwait(arg0, arg1);
    }

    @Override
    public Uni info(List args) {
        return redisAPI.info(args);
    }

    @Override
    public Response infoAndAwait(List args) {
        return redisAPI.infoAndAwait(args);
    }

    @Override
    public Uni keys(String arg0) {
        return redisAPI.keys(arg0);
    }

    @Override
    public Response keysAndAwait(String arg0) {
        return redisAPI.keysAndAwait(arg0);
    }

    @Override
    public Uni lastsave() {
        return redisAPI.lastsave();
    }

    @Override
    public Response lastsaveAndAwait() {
        return redisAPI.lastsaveAndAwait();
    }

    @Override
    public Uni latency(List args) {
        return redisAPI.latency(args);
    }

    @Override
    public Response latencyAndAwait(List args) {
        return redisAPI.latencyAndAwait(args);
    }

    @Override
    public Uni lindex(String arg0, String arg1) {
        return redisAPI.lindex(arg0, arg1);
    }

    @Override
    public Response lindexAndAwait(String arg0, String arg1) {
        return redisAPI.lindexAndAwait(arg0, arg1);
    }

    @Override
    public Uni linsert(String arg0, String arg1, String arg2, String arg3) {
        return redisAPI.linsert(arg0, arg1, arg2, arg3);
    }

    @Override
    public Response linsertAndAwait(String arg0, String arg1, String arg2, String arg3) {
        return redisAPI.linsertAndAwait(arg0, arg1, arg2, arg3);
    }

    @Override
    public Uni llen(String arg0) {
        return redisAPI.llen(arg0);
    }

    @Override
    public Response llenAndAwait(String arg0) {
        return redisAPI.llenAndAwait(arg0);
    }

    @Override
    public Uni lolwut(List args) {
        return redisAPI.lolwut(args);
    }

    @Override
    public Response lolwutAndAwait(List args) {
        return redisAPI.lolwutAndAwait(args);
    }

    @Override
    public Uni lpop(String arg0) {
        return redisAPI.lpop(List.of(arg0));
    }

    @Override
    public Uni lpop(List arg0) {
        return redisAPI.lpop(arg0);
    }

    @Override
    public Response lpopAndAwait(String arg0) {
        return redisAPI.lpopAndAwait(List.of(arg0));
    }

    @Override
    public Response lpopAndAwait(List arg0) {
        return redisAPI.lpopAndAwait(arg0);
    }

    @Override
    public Uni lpush(List args) {
        return redisAPI.lpush(args);
    }

    @Override
    public Response lpushAndAwait(List args) {
        return redisAPI.lpushAndAwait(args);
    }

    @Override
    public Uni lpushx(List args) {
        return redisAPI.lpushx(args);
    }

    @Override
    public Response lpushxAndAwait(List args) {
        return redisAPI.lpushxAndAwait(args);
    }

    @Override
    public Uni lrange(String arg0, String arg1, String arg2) {
        return redisAPI.lrange(arg0, arg1, arg2);
    }

    @Override
    public Response lrangeAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.lrangeAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni lrem(String arg0, String arg1, String arg2) {
        return redisAPI.lrem(arg0, arg1, arg2);
    }

    @Override
    public Response lremAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.lremAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni lset(String arg0, String arg1, String arg2) {
        return redisAPI.lset(arg0, arg1, arg2);
    }

    @Override
    public Response lsetAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.lsetAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni ltrim(String arg0, String arg1, String arg2) {
        return redisAPI.ltrim(arg0, arg1, arg2);
    }

    @Override
    public Response ltrimAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.ltrimAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni memory(List args) {
        return redisAPI.memory(args);
    }

    @Override
    public Response memoryAndAwait(List args) {
        return redisAPI.memoryAndAwait(args);
    }

    @Override
    public Uni mget(List args) {
        return redisAPI.mget(args);
    }

    @Override
    public Response mgetAndAwait(List args) {
        return redisAPI.mgetAndAwait(args);
    }

    @Override
    public Uni migrate(List args) {
        return redisAPI.migrate(args);
    }

    @Override
    public Response migrateAndAwait(List args) {
        return redisAPI.migrateAndAwait(args);
    }

    @Override
    public Uni module(List args) {
        return redisAPI.module(args);
    }

    @Override
    public Response moduleAndAwait(List args) {
        return redisAPI.moduleAndAwait(args);
    }

    @Override
    public Uni monitor() {
        return redisAPI.monitor();
    }

    @Override
    public Response monitorAndAwait() {
        return redisAPI.monitorAndAwait();
    }

    @Override
    public Uni move(String arg0, String arg1) {
        return redisAPI.move(arg0, arg1);
    }

    @Override
    public Response moveAndAwait(String arg0, String arg1) {
        return redisAPI.moveAndAwait(arg0, arg1);
    }

    @Override
    public Uni mset(List args) {
        return redisAPI.mset(args);
    }

    @Override
    public Response msetAndAwait(List args) {
        return redisAPI.msetAndAwait(args);
    }

    @Override
    public Uni msetnx(List args) {
        return redisAPI.msetnx(args);
    }

    @Override
    public Response msetnxAndAwait(List args) {
        return redisAPI.msetnxAndAwait(args);
    }

    @Override
    public Uni multi() {
        return redisAPI.multi();
    }

    @Override
    public Response multiAndAwait() {
        return redisAPI.multiAndAwait();
    }

    @Override
    public Uni object(List args) {
        return redisAPI.object(args);
    }

    @Override
    public Response objectAndAwait(List args) {
        return redisAPI.objectAndAwait(args);
    }

    @Override
    public Uni persist(String arg0) {
        return redisAPI.persist(arg0);
    }

    @Override
    public Response persistAndAwait(String arg0) {
        return redisAPI.persistAndAwait(arg0);
    }

    @Override
    public Uni pexpire(String arg0, String arg1) {
        return redisAPI.pexpire(List.of(arg0, arg1));
    }

    @Override
    public Response pexpireAndAwait(String arg0, String arg1) {
        return redisAPI.pexpireAndAwait(List.of(arg0, arg1));
    }

    @Override
    public Uni pexpireat(String arg0, String arg1) {
        return redisAPI.pexpireat(List.of(arg0, arg1));
    }

    @Override
    public Response pexpireatAndAwait(String arg0, String arg1) {
        return redisAPI.pexpireatAndAwait(List.of(arg0, arg1));
    }

    @Override
    public Uni pfadd(List args) {
        return redisAPI.pfadd(args);
    }

    @Override
    public Response pfaddAndAwait(List args) {
        return redisAPI.pfaddAndAwait(args);
    }

    @Override
    public Uni pfcount(List args) {
        return redisAPI.pfcount(args);
    }

    @Override
    public Response pfcountAndAwait(List args) {
        return redisAPI.pfcountAndAwait(args);
    }

    @Override
    public Uni pfdebug(List args) {
        return redisAPI.pfdebug(args.get(0), args.get(1));
    }

    @Override
    public Response pfdebugAndAwait(List args) {
        return redisAPI.pfdebugAndAwait(args.get(0), args.get(1));
    }

    @Override
    public Uni pfdebug(String command, String key) {
        return redisAPI.pfdebug(command, key);
    }

    @Override
    public Response pfdebugAndAwait(String command, String key) {
        return redisAPI.pfdebugAndAwait(command, key);
    }

    @Override
    public Uni pfmerge(List args) {
        return redisAPI.pfmerge(args);
    }

    @Override
    public Response pfmergeAndAwait(List args) {
        return redisAPI.pfmergeAndAwait(args);
    }

    @Override
    public Uni pfselftest() {
        return redisAPI.pfselftest();
    }

    @Override
    public Response pfselftestAndAwait() {
        return redisAPI.pfselftestAndAwait();
    }

    @Override
    public Uni ping(List args) {
        return redisAPI.ping(args);
    }

    @Override
    public Response pingAndAwait(List args) {
        return redisAPI.pingAndAwait(args);
    }

    @Override
    public Uni post(List args) {
        return redis.send(Request.cmd(Command.create("post"), args.toArray(new String[0])));
    }

    @Override
    public Response postAndAwait(List args) {
        return post(args).await().indefinitely();
    }

    @Override
    public Uni psetex(String arg0, String arg1, String arg2) {
        return redisAPI.psetex(arg0, arg1, arg2);
    }

    @Override
    public Response psetexAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.psetexAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni psubscribe(List args) {
        return redisAPI.psubscribe(args);
    }

    @Override
    public Response psubscribeAndAwait(List args) {
        return redisAPI.psubscribeAndAwait(args);
    }

    @Override
    public Uni psync(String arg0, String arg1) {
        return redisAPI.psync(List.of(arg0, arg1));
    }

    @Override
    public Uni psync(List args) {
        return redisAPI.psync(args);
    }

    @Override
    public Response psyncAndAwait(List args) {
        return redisAPI.psyncAndAwait(args);
    }

    @Override
    public Response psyncAndAwait(String arg0, String arg1) {
        return redisAPI.psyncAndAwait(List.of(arg0, arg1));
    }

    @Override
    public Uni pttl(String arg0) {
        return redisAPI.pttl(arg0);
    }

    @Override
    public Response pttlAndAwait(String arg0) {
        return redisAPI.pttlAndAwait(arg0);
    }

    @Override
    public Uni publish(String arg0, String arg1) {
        return redisAPI.publish(arg0, arg1);
    }

    @Override
    public Response publishAndAwait(String arg0, String arg1) {
        return redisAPI.publishAndAwait(arg0, arg1);
    }

    @Override
    public Uni pubsub(List args) {
        return redisAPI.pubsub(args);
    }

    @Override
    public Response pubsubAndAwait(List args) {
        return redisAPI.pubsubAndAwait(args);
    }

    @Override
    public Uni punsubscribe(List args) {
        return redisAPI.punsubscribe(args);
    }

    @Override
    public Response punsubscribeAndAwait(List args) {
        return redisAPI.punsubscribeAndAwait(args);
    }

    @Override
    public Uni randomkey() {
        return redisAPI.randomkey();
    }

    @Override
    public Response randomkeyAndAwait() {
        return redisAPI.randomkeyAndAwait();
    }

    @Override
    public Uni readonly() {
        return redisAPI.readonly();
    }

    @Override
    public Response readonlyAndAwait() {
        return redisAPI.readonlyAndAwait();
    }

    @Override
    public Uni readwrite() {
        return redisAPI.readwrite();
    }

    @Override
    public Response readwriteAndAwait() {
        return redisAPI.readwriteAndAwait();
    }

    @Override
    public Uni rename(String arg0, String arg1) {
        return redisAPI.rename(arg0, arg1);
    }

    @Override
    public Response renameAndAwait(String arg0, String arg1) {
        return redisAPI.renameAndAwait(arg0, arg1);
    }

    @Override
    public Uni renamenx(String arg0, String arg1) {
        return redisAPI.renamenx(arg0, arg1);
    }

    @Override
    public Response renamenxAndAwait(String arg0, String arg1) {
        return redisAPI.renamenxAndAwait(arg0, arg1);
    }

    @Override
    public Uni replconf(List args) {
        return redisAPI.replconf(args);
    }

    @Override
    public Response replconfAndAwait(List args) {
        return redisAPI.replconfAndAwait(args);
    }

    @Override
    public Uni replicaof(String arg0, String arg1) {
        return redisAPI.replicaof(arg0, arg1);
    }

    @Override
    public Response replicaofAndAwait(String arg0, String arg1) {
        return redisAPI.replicaofAndAwait(arg0, arg1);
    }

    @Override
    public Uni restore(List args) {
        return redisAPI.restore(args);
    }

    @Override
    public Response restoreAndAwait(List args) {
        return redisAPI.restoreAndAwait(args);
    }

    @Override
    public Uni restoreAsking(List args) {
        return redisAPI.restoreAsking(args);
    }

    @Override
    public Response restoreAskingAndAwait(List args) {
        return redisAPI.restoreAskingAndAwait(args);
    }

    @Override
    public Uni role() {
        return redisAPI.role();
    }

    @Override
    public Response roleAndAwait() {
        return redisAPI.roleAndAwait();
    }

    @Override
    public Uni rpop(String arg0) {
        return redisAPI.rpop(List.of(arg0));
    }

    @Override
    public Uni rpop(List args) {
        return redisAPI.rpop(args);
    }

    @Override
    public Response rpopAndAwait(List args) {
        return redisAPI.rpopAndAwait(args);
    }

    @Override
    public Response rpopAndAwait(String arg0) {
        return redisAPI.rpopAndAwait(List.of(arg0));
    }

    @Override
    public Uni rpoplpush(String arg0, String arg1) {
        return redisAPI.rpoplpush(arg0, arg1);
    }

    @Override
    public Response rpoplpushAndAwait(String arg0, String arg1) {
        return redisAPI.rpoplpushAndAwait(arg0, arg1);
    }

    @Override
    public Uni rpush(List args) {
        return redisAPI.rpush(args);
    }

    @Override
    public Response rpushAndAwait(List args) {
        return redisAPI.rpushAndAwait(args);
    }

    @Override
    public Uni rpushx(List args) {
        return redisAPI.rpushx(args);
    }

    @Override
    public Response rpushxAndAwait(List args) {
        return redisAPI.rpushxAndAwait(args);
    }

    @Override
    public Uni sadd(List args) {
        return redisAPI.sadd(args);
    }

    @Override
    public Response saddAndAwait(List args) {
        return redisAPI.saddAndAwait(args);
    }

    @Override
    public Uni save() {
        return redisAPI.save();
    }

    @Override
    public Response saveAndAwait() {
        return redisAPI.saveAndAwait();
    }

    @Override
    public Uni scan(List args) {
        return redisAPI.scan(args);
    }

    @Override
    public Response scanAndAwait(List args) {
        return redisAPI.scanAndAwait(args);
    }

    @Override
    public Uni scard(String arg0) {
        return redisAPI.scard(arg0);
    }

    @Override
    public Response scardAndAwait(String arg0) {
        return redisAPI.scardAndAwait(arg0);
    }

    @Override
    public Uni script(List args) {
        return redisAPI.script(args);
    }

    @Override
    public Response scriptAndAwait(List args) {
        return redisAPI.scriptAndAwait(args);
    }

    @Override
    public Uni sdiff(List args) {
        return redisAPI.sdiff(args);
    }

    @Override
    public Response sdiffAndAwait(List args) {
        return redisAPI.sdiffAndAwait(args);
    }

    @Override
    public Uni sdiffstore(List args) {
        return redisAPI.sdiffstore(args);
    }

    @Override
    public Response sdiffstoreAndAwait(List args) {
        return redisAPI.sdiffstoreAndAwait(args);
    }

    @Override
    public Uni select(String arg0) {
        return redisAPI.select(arg0);
    }

    @Override
    public Response selectAndAwait(String arg0) {
        return redisAPI.selectAndAwait(arg0);
    }

    @Override
    public Uni set(List args) {
        return redisAPI.set(args);
    }

    @Override
    public Response setAndAwait(List args) {
        return redisAPI.setAndAwait(args);
    }

    @Override
    public Uni setbit(String arg0, String arg1, String arg2) {
        return redisAPI.setbit(arg0, arg1, arg2);
    }

    @Override
    public Response setbitAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.setbitAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni setex(String arg0, String arg1, String arg2) {
        return redisAPI.setex(arg0, arg1, arg2);
    }

    @Override
    public Response setexAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.setexAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni setnx(String arg0, String arg1) {
        return redisAPI.setnx(arg0, arg1);
    }

    @Override
    public Response setnxAndAwait(String arg0, String arg1) {
        return redisAPI.setnxAndAwait(arg0, arg1);
    }

    @Override
    public Uni setrange(String arg0, String arg1, String arg2) {
        return redisAPI.setrange(arg0, arg1, arg2);
    }

    @Override
    public Response setrangeAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.setrangeAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni shutdown(List args) {
        return redisAPI.shutdown(args);
    }

    @Override
    public Response shutdownAndAwait(List args) {
        return redisAPI.shutdownAndAwait(args);
    }

    @Override
    public Uni sinter(List args) {
        return redisAPI.sinter(args);
    }

    @Override
    public Response sinterAndAwait(List args) {
        return redisAPI.sinterAndAwait(args);
    }

    @Override
    public Uni sinterstore(List args) {
        return redisAPI.sinterstore(args);
    }

    @Override
    public Response sinterstoreAndAwait(List args) {
        return redisAPI.sinterstoreAndAwait(args);
    }

    @Override
    public Uni sismember(String arg0, String arg1) {
        return redisAPI.sismember(arg0, arg1);
    }

    @Override
    public Response sismemberAndAwait(String arg0, String arg1) {
        return redisAPI.sismemberAndAwait(arg0, arg1);
    }

    @Override
    public Uni slaveof(String arg0, String arg1) {
        return redisAPI.slaveof(arg0, arg1);
    }

    @Override
    public Response slaveofAndAwait(String arg0, String arg1) {
        return redisAPI.slaveofAndAwait(arg0, arg1);
    }

    @Override
    public Uni slowlog(List args) {
        return redisAPI.slowlog(args);
    }

    @Override
    public Response slowlogAndAwait(List args) {
        return redisAPI.slowlogAndAwait(args);
    }

    @Override
    public Uni smembers(String arg0) {
        return redisAPI.smembers(arg0);
    }

    @Override
    public Response smembersAndAwait(String arg0) {
        return redisAPI.smembersAndAwait(arg0);
    }

    @Override
    public Uni smove(String arg0, String arg1, String arg2) {
        return redisAPI.smove(arg0, arg1, arg2);
    }

    @Override
    public Response smoveAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.smoveAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni sort(List args) {
        return redisAPI.sort(args);
    }

    @Override
    public Response sortAndAwait(List args) {
        return redisAPI.sortAndAwait(args);
    }

    @Override
    public Uni spop(List args) {
        return redisAPI.spop(args);
    }

    @Override
    public Response spopAndAwait(List args) {
        return redisAPI.spopAndAwait(args);
    }

    @Override
    public Uni srandmember(List args) {
        return redisAPI.srandmember(args);
    }

    @Override
    public Response srandmemberAndAwait(List args) {
        return redisAPI.srandmemberAndAwait(args);
    }

    @Override
    public Uni srem(List args) {
        return redisAPI.srem(args);
    }

    @Override
    public Response sremAndAwait(List args) {
        return redisAPI.sremAndAwait(args);
    }

    @Override
    public Uni sscan(List args) {
        return redisAPI.sscan(args);
    }

    @Override
    public Response sscanAndAwait(List args) {
        return redisAPI.sscanAndAwait(args);
    }

    @Override
    public Uni strlen(String arg0) {
        return redisAPI.strlen(arg0);
    }

    @Override
    public Response strlenAndAwait(String arg0) {
        return redisAPI.strlenAndAwait(arg0);
    }

    @Override
    public Uni subscribe(List args) {
        return redisAPI.subscribe(args);
    }

    @Override
    public Response subscribeAndAwait(List args) {
        return redisAPI.subscribeAndAwait(args);
    }

    @Override
    public Uni substr(String arg0, String arg1, String arg2) {
        return redisAPI.substr(arg0, arg1, arg2);
    }

    @Override
    public Response substrAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.substrAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni sunion(List args) {
        return redisAPI.sunion(args);
    }

    @Override
    public Response sunionAndAwait(List args) {
        return redisAPI.sunionAndAwait(args);
    }

    @Override
    public Uni sunionstore(List args) {
        return redisAPI.sunionstore(args);
    }

    @Override
    public Response sunionstoreAndAwait(List args) {
        return redisAPI.sunionstoreAndAwait(args);
    }

    @Override
    public Uni swapdb(String arg0, String arg1) {
        return redisAPI.swapdb(arg0, arg1);
    }

    @Override
    public Response swapdbAndAwait(String arg0, String arg1) {
        return redisAPI.swapdbAndAwait(arg0, arg1);
    }

    @Override
    public Uni sync() {
        return redisAPI.sync();
    }

    @Override
    public Response syncAndAwait() {
        return redisAPI.syncAndAwait();
    }

    @Override
    public Uni time() {
        return redisAPI.time();
    }

    @Override
    public Response timeAndAwait() {
        return redisAPI.timeAndAwait();
    }

    @Override
    public Uni touch(List args) {
        return redisAPI.touch(args);
    }

    @Override
    public Response touchAndAwait(List args) {
        return redisAPI.touchAndAwait(args);
    }

    @Override
    public Uni ttl(String arg0) {
        return redisAPI.ttl(arg0);
    }

    @Override
    public Response ttlAndAwait(String arg0) {
        return redisAPI.ttlAndAwait(arg0);
    }

    @Override
    public Uni type(String arg0) {
        return redisAPI.type(arg0);
    }

    @Override
    public Response typeAndAwait(String arg0) {
        return redisAPI.typeAndAwait(arg0);
    }

    @Override
    public Uni unlink(List args) {
        return redisAPI.unlink(args);
    }

    @Override
    public Response unlinkAndAwait(List args) {
        return redisAPI.unlinkAndAwait(args);
    }

    @Override
    public Uni unsubscribe(List args) {
        return redisAPI.unsubscribe(args);
    }

    @Override
    public Response unsubscribeAndAwait(List args) {
        return redisAPI.unsubscribeAndAwait(args);
    }

    @Override
    public Uni unwatch() {
        return redisAPI.unwatch();
    }

    @Override
    public Response unwatchAndAwait() {
        return redisAPI.unwatchAndAwait();
    }

    @Override
    public Uni wait(String arg0, String arg1) {
        return redisAPI.wait(arg0, arg1);
    }

    @Override
    public Response waitAndAwait(String arg0, String arg1) {
        return redisAPI.waitAndAwait(arg0, arg1);
    }

    @Override
    public Uni watch(List args) {
        return redisAPI.watch(args);
    }

    @Override
    public Response watchAndAwait(List args) {
        return redisAPI.watchAndAwait(args);
    }

    @Override
    public Uni xack(List args) {
        return redisAPI.xack(args);
    }

    @Override
    public Response xackAndAwait(List args) {
        return redisAPI.xackAndAwait(args);
    }

    @Override
    public Uni xadd(List args) {
        return redisAPI.xadd(args);
    }

    @Override
    public Response xaddAndAwait(List args) {
        return redisAPI.xaddAndAwait(args);
    }

    @Override
    public Uni xclaim(List args) {
        return redisAPI.xclaim(args);
    }

    @Override
    public Response xclaimAndAwait(List args) {
        return redisAPI.xclaimAndAwait(args);
    }

    @Override
    public Uni xdel(List args) {
        return redisAPI.xdel(args);
    }

    @Override
    public Response xdelAndAwait(List args) {
        return redisAPI.xdelAndAwait(args);
    }

    @Override
    public Uni xgroup(List args) {
        return redisAPI.xgroup(args);
    }

    @Override
    public Response xgroupAndAwait(List args) {
        return redisAPI.xgroupAndAwait(args);
    }

    @Override
    public Uni xinfo(List args) {
        return redisAPI.xinfo(args);
    }

    @Override
    public Response xinfoAndAwait(List args) {
        return redisAPI.xinfoAndAwait(args);
    }

    @Override
    public Uni xlen(String arg0) {
        return redisAPI.xlen(arg0);
    }

    @Override
    public Response xlenAndAwait(String arg0) {
        return redisAPI.xlenAndAwait(arg0);
    }

    @Override
    public Uni xpending(List args) {
        return redisAPI.xpending(args);
    }

    @Override
    public Response xpendingAndAwait(List args) {
        return redisAPI.xpendingAndAwait(args);
    }

    @Override
    public Uni xrange(List args) {
        return redisAPI.xrange(args);
    }

    @Override
    public Response xrangeAndAwait(List args) {
        return redisAPI.xrangeAndAwait(args);
    }

    @Override
    public Uni xread(List args) {
        return redisAPI.xread(args);
    }

    @Override
    public Response xreadAndAwait(List args) {
        return redisAPI.xreadAndAwait(args);
    }

    @Override
    public Uni xreadgroup(List args) {
        return redisAPI.xreadgroup(args);
    }

    @Override
    public Response xreadgroupAndAwait(List args) {
        return redisAPI.xreadgroupAndAwait(args);
    }

    @Override
    public Uni xrevrange(List args) {
        return redisAPI.xrevrange(args);
    }

    @Override
    public Response xrevrangeAndAwait(List args) {
        return redisAPI.xrevrangeAndAwait(args);
    }

    @Override
    public Uni xsetid(String arg0, String arg1) {
        return redisAPI.xsetid(List.of(arg0, arg1));
    }

    @Override
    public Response xsetidAndAwait(String arg0, String arg1) {
        return redisAPI.xsetidAndAwait(List.of(arg0, arg1));
    }

    @Override
    public Uni xtrim(List args) {
        return redisAPI.xtrim(args);
    }

    @Override
    public Response xtrimAndAwait(List args) {
        return redisAPI.xtrimAndAwait(args);
    }

    @Override
    public Uni zadd(List args) {
        return redisAPI.zadd(args);
    }

    @Override
    public Response zaddAndAwait(List args) {
        return redisAPI.zaddAndAwait(args);
    }

    @Override
    public Uni zcard(String arg0) {
        return redisAPI.zcard(arg0);
    }

    @Override
    public Response zcardAndAwait(String arg0) {
        return redisAPI.zcardAndAwait(arg0);
    }

    @Override
    public Uni zcount(String arg0, String arg1, String arg2) {
        return redisAPI.zcount(arg0, arg1, arg2);
    }

    @Override
    public Response zcountAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.zcountAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni zincrby(String arg0, String arg1, String arg2) {
        return redisAPI.zincrby(arg0, arg1, arg2);
    }

    @Override
    public Response zincrbyAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.zincrbyAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni zinterstore(List args) {
        return redisAPI.zinterstore(args);
    }

    @Override
    public Response zinterstoreAndAwait(List args) {
        return redisAPI.zinterstoreAndAwait(args);
    }

    @Override
    public Uni zlexcount(String arg0, String arg1, String arg2) {
        return redisAPI.zlexcount(arg0, arg1, arg2);
    }

    @Override
    public Response zlexcountAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.zlexcountAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni zpopmax(List args) {
        return redisAPI.zpopmax(args);
    }

    @Override
    public Response zpopmaxAndAwait(List args) {
        return redisAPI.zpopmaxAndAwait(args);
    }

    @Override
    public Uni zpopmin(List args) {
        return redisAPI.zpopmin(args);
    }

    @Override
    public Response zpopminAndAwait(List args) {
        return redisAPI.zpopminAndAwait(args);
    }

    @Override
    public Uni zrange(List args) {
        return redisAPI.zrange(args);
    }

    @Override
    public Response zrangeAndAwait(List args) {
        return redisAPI.zrangeAndAwait(args);
    }

    @Override
    public Uni zrangebylex(List args) {
        return redisAPI.zrangebylex(args);
    }

    @Override
    public Response zrangebylexAndAwait(List args) {
        return redisAPI.zrangebylexAndAwait(args);
    }

    @Override
    public Uni zrangebyscore(List args) {
        return redisAPI.zrangebyscore(args);
    }

    @Override
    public Response zrangebyscoreAndAwait(List args) {
        return redisAPI.zrangebyscoreAndAwait(args);
    }

    @Override
    public Uni zrank(String arg0, String arg1) {
        return redisAPI.zrank(arg0, arg1);
    }

    @Override
    public Response zrankAndAwait(String arg0, String arg1) {
        return redisAPI.zrankAndAwait(arg0, arg1);
    }

    @Override
    public Uni zrem(List args) {
        return redisAPI.zrem(args);
    }

    @Override
    public Response zremAndAwait(List args) {
        return redisAPI.zremAndAwait(args);
    }

    @Override
    public Uni zremrangebylex(String arg0, String arg1, String arg2) {
        return redisAPI.zremrangebylex(arg0, arg1, arg2);
    }

    @Override
    public Response zremrangebylexAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.zremrangebylexAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni zremrangebyrank(String arg0, String arg1, String arg2) {
        return redisAPI.zremrangebyrank(arg0, arg1, arg2);
    }

    @Override
    public Response zremrangebyrankAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.zremrangebyrankAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni zremrangebyscore(String arg0, String arg1, String arg2) {
        return redisAPI.zremrangebyscore(arg0, arg1, arg2);
    }

    @Override
    public Response zremrangebyscoreAndAwait(String arg0, String arg1, String arg2) {
        return redisAPI.zremrangebyscoreAndAwait(arg0, arg1, arg2);
    }

    @Override
    public Uni zrevrange(List args) {
        return redisAPI.zrevrange(args);
    }

    @Override
    public Response zrevrangeAndAwait(List args) {
        return redisAPI.zrevrangeAndAwait(args);
    }

    @Override
    public Uni zrevrangebylex(List args) {
        return redisAPI.zrevrangebylex(args);
    }

    @Override
    public Response zrevrangebylexAndAwait(List args) {
        return redisAPI.zrevrangebylexAndAwait(args);
    }

    @Override
    public Uni zrevrangebyscore(List args) {
        return redisAPI.zrevrangebyscore(args);
    }

    @Override
    public Response zrevrangebyscoreAndAwait(List args) {
        return redisAPI.zrevrangebyscoreAndAwait(args);
    }

    @Override
    public Uni zrevrank(String arg0, String arg1) {
        return redisAPI.zrevrank(arg0, arg1);
    }

    @Override
    public Response zrevrankAndAwait(String arg0, String arg1) {
        return redisAPI.zrevrankAndAwait(arg0, arg1);
    }

    @Override
    public Uni zscan(List args) {
        return redisAPI.zscan(args);
    }

    @Override
    public Response zscanAndAwait(List args) {
        return redisAPI.zscanAndAwait(args);
    }

    @Override
    public Uni zscore(String arg0, String arg1) {
        return redisAPI.zscore(arg0, arg1);
    }

    @Override
    public Response zscoreAndAwait(String arg0, String arg1) {
        return redisAPI.zscoreAndAwait(arg0, arg1);
    }

    @Override
    public Uni zunion(List args) {
        return redisAPI.zunion(args);
    }

    @Override
    public Response zunionAndAwait(List args) {
        return redisAPI.zunionAndAwait(args);
    }

    @Override
    public Uni zunionstore(List args) {
        return redisAPI.zunionstore(args);
    }

    @Override
    public Response zunionstoreAndAwait(List args) {
        return redisAPI.zunionstoreAndAwait(args);
    }
}