From 986bb09861712313ad5ef8859f13a8d293c7627f Mon Sep 17 00:00:00 2001
From: Mark Paluch <mpaluch@paluch.biz>
Date: Tue, 26 Sep 2017 10:26:01 +0200
Subject: [PATCH] Polishing #604

Remove public keywords in RedisCommandBuilder. Replace explicit type arguments with diamond syntax. Order by method name in AbstractRedisAsyncCommands, RedisCommandBuilder, and AbstractRedisReactiveCommands.
---
 .../redis/AbstractRedisAsyncCommands.java     | 1352 +++----
 .../redis/AbstractRedisReactiveCommands.java  | 1423 ++++----
 .../redis/RedisCommandBuilder.java            | 3094 ++++++++---------
 3 files changed, 2934 insertions(+), 2935 deletions(-)

diff --git a/src/main/java/com/lambdaworks/redis/AbstractRedisAsyncCommands.java b/src/main/java/com/lambdaworks/redis/AbstractRedisAsyncCommands.java
index f58615ba1b..0c822ede22 100644
--- a/src/main/java/com/lambdaworks/redis/AbstractRedisAsyncCommands.java
+++ b/src/main/java/com/lambdaworks/redis/AbstractRedisAsyncCommands.java
@@ -39,21 +39,22 @@
  * @param <V> Value type.
  * @author Will Glozer
  */
-public abstract class AbstractRedisAsyncCommands<K, V>
-        implements RedisHashesAsyncConnection<K, V>, RedisKeysAsyncConnection<K, V>, RedisStringsAsyncConnection<K, V>,
-        RedisListsAsyncConnection<K, V>, RedisSetsAsyncConnection<K, V>, RedisSortedSetsAsyncConnection<K, V>,
-        RedisScriptingAsyncConnection<K, V>, RedisServerAsyncConnection<K, V>, RedisHLLAsyncConnection<K, V>,
-        BaseRedisAsyncConnection<K, V>, RedisClusterAsyncConnection<K, V>, RedisGeoAsyncConnection<K, V>,
+public abstract class AbstractRedisAsyncCommands<K, V> implements RedisHashesAsyncConnection<K, V>,
+        RedisKeysAsyncConnection<K, V>, RedisStringsAsyncConnection<K, V>, RedisListsAsyncConnection<K, V>,
+        RedisSetsAsyncConnection<K, V>, RedisSortedSetsAsyncConnection<K, V>, RedisScriptingAsyncConnection<K, V>,
+        RedisServerAsyncConnection<K, V>, RedisHLLAsyncConnection<K, V>, BaseRedisAsyncConnection<K, V>,
+        RedisClusterAsyncConnection<K, V>, RedisGeoAsyncConnection<K, V>,
+
+        RedisHashAsyncCommands<K, V>, RedisKeyAsyncCommands<K, V>, RedisStringAsyncCommands<K, V>,
+        RedisListAsyncCommands<K, V>, RedisSetAsyncCommands<K, V>, RedisSortedSetAsyncCommands<K, V>,
+        RedisScriptingAsyncCommands<K, V>, RedisServerAsyncCommands<K, V>, RedisHLLAsyncCommands<K, V>,
+        BaseRedisAsyncCommands<K, V>, RedisTransactionalAsyncCommands<K, V>, RedisGeoAsyncCommands<K, V>,
+        RedisClusterAsyncCommands<K, V> {
 
-        RedisHashAsyncCommands<K, V>, RedisKeyAsyncCommands<K, V>, RedisStringAsyncCommands<K, V>, RedisListAsyncCommands<K, V>,
-        RedisSetAsyncCommands<K, V>, RedisSortedSetAsyncCommands<K, V>, RedisScriptingAsyncCommands<K, V>,
-        RedisServerAsyncCommands<K, V>, RedisHLLAsyncCommands<K, V>, BaseRedisAsyncCommands<K, V>,
-        RedisTransactionalAsyncCommands<K, V>, RedisGeoAsyncCommands<K, V>, RedisClusterAsyncCommands<K, V> {
-
-    protected MultiOutput<K, V> multi;
-    protected RedisCommandBuilder<K, V> commandBuilder;
-    protected RedisCodec<K, V> codec;
     protected StatefulConnection<K, V> connection;
+    protected RedisCodec<K, V> codec;
+    protected RedisCommandBuilder<K, V> commandBuilder;
+    protected MultiOutput<K, V> multi;
 
     /**
      * Initialize a new instance.
@@ -72,6 +73,11 @@ public RedisFuture<Long> append(K key, V value) {
         return dispatch(commandBuilder.append(key, value));
     }
 
+    @Override
+    public RedisFuture<String> asking() {
+        return dispatch(commandBuilder.asking());
+    }
+
     @Override
     public String auth(String password) {
 
@@ -109,16 +115,6 @@ public RedisFuture<List<Long>> bitfield(K key, BitFieldArgs bitFieldArgs) {
         return dispatch(commandBuilder.bitfield(key, bitFieldArgs));
     }
 
-    @Override
-    public RedisFuture<Long> bitpos(K key, boolean state) {
-        return dispatch(commandBuilder.bitpos(key, state));
-    }
-
-    @Override
-    public RedisFuture<Long> bitpos(K key, boolean state, long start, long end) {
-        return dispatch(commandBuilder.bitpos(key, state, start, end));
-    }
-
     @Override
     public RedisFuture<Long> bitopAnd(K destination, K... keys) {
         return dispatch(commandBuilder.bitopAnd(destination, keys));
@@ -139,6 +135,16 @@ public RedisFuture<Long> bitopXor(K destination, K... keys) {
         return dispatch(commandBuilder.bitopXor(destination, keys));
     }
 
+    @Override
+    public RedisFuture<Long> bitpos(K key, boolean state) {
+        return dispatch(commandBuilder.bitpos(key, state));
+    }
+
+    @Override
+    public RedisFuture<Long> bitpos(K key, boolean state, long start, long end) {
+        return dispatch(commandBuilder.bitpos(key, state, start, end));
+    }
+
     @Override
     public RedisFuture<KeyValue<K, V>> blpop(long timeout, K... keys) {
         return dispatch(commandBuilder.blpop(timeout, keys));
@@ -159,11 +165,6 @@ public RedisFuture<K> clientGetname() {
         return dispatch(commandBuilder.clientGetname());
     }
 
-    @Override
-    public RedisFuture<String> clientSetname(K name) {
-        return dispatch(commandBuilder.clientSetname(name));
-    }
-
     @Override
     public RedisFuture<String> clientKill(String addr) {
         return dispatch(commandBuilder.clientKill(addr));
@@ -174,14 +175,144 @@ public RedisFuture<Long> clientKill(KillArgs killArgs) {
         return dispatch(commandBuilder.clientKill(killArgs));
     }
 
+    @Override
+    public RedisFuture<String> clientList() {
+        return dispatch(commandBuilder.clientList());
+    }
+
     @Override
     public RedisFuture<String> clientPause(long timeout) {
         return dispatch(commandBuilder.clientPause(timeout));
     }
 
     @Override
-    public RedisFuture<String> clientList() {
-        return dispatch(commandBuilder.clientList());
+    public RedisFuture<String> clientSetname(K name) {
+        return dispatch(commandBuilder.clientSetname(name));
+    }
+
+    @Override
+    public void close() {
+        connection.close();
+    }
+
+    @Override
+    public RedisFuture<String> clusterAddSlots(int... slots) {
+        return dispatch(commandBuilder.clusterAddslots(slots));
+    }
+
+    @Override
+    public RedisFuture<String> clusterBumpepoch() {
+        return dispatch(commandBuilder.clusterBumpepoch());
+    }
+
+    @Override
+    public RedisFuture<Long> clusterCountFailureReports(String nodeId) {
+        return dispatch(commandBuilder.clusterCountFailureReports(nodeId));
+    }
+
+    @Override
+    public RedisFuture<Long> clusterCountKeysInSlot(int slot) {
+        return dispatch(commandBuilder.clusterCountKeysInSlot(slot));
+    }
+
+    @Override
+    public RedisFuture<String> clusterDelSlots(int... slots) {
+        return dispatch(commandBuilder.clusterDelslots(slots));
+    }
+
+    @Override
+    public RedisFuture<String> clusterFailover(boolean force) {
+        return dispatch(commandBuilder.clusterFailover(force));
+    }
+
+    @Override
+    public RedisFuture<String> clusterFlushslots() {
+        return dispatch(commandBuilder.clusterFlushslots());
+    }
+
+    @Override
+    public RedisFuture<String> clusterForget(String nodeId) {
+        return dispatch(commandBuilder.clusterForget(nodeId));
+    }
+
+    @Override
+    public RedisFuture<List<K>> clusterGetKeysInSlot(int slot, int count) {
+        return dispatch(commandBuilder.clusterGetKeysInSlot(slot, count));
+    }
+
+    @Override
+    public RedisFuture<String> clusterInfo() {
+        return dispatch(commandBuilder.clusterInfo());
+    }
+
+    @Override
+    public RedisFuture<Long> clusterKeyslot(K key) {
+        return dispatch(commandBuilder.clusterKeyslot(key));
+    }
+
+    @Override
+    public RedisFuture<String> clusterMeet(String ip, int port) {
+        return dispatch(commandBuilder.clusterMeet(ip, port));
+    }
+
+    @Override
+    public RedisFuture<String> clusterMyId() {
+        return dispatch(commandBuilder.clusterMyId());
+    }
+
+    @Override
+    public RedisFuture<String> clusterNodes() {
+        return dispatch(commandBuilder.clusterNodes());
+    }
+
+    @Override
+    public RedisFuture<String> clusterReplicate(String nodeId) {
+        return dispatch(commandBuilder.clusterReplicate(nodeId));
+    }
+
+    @Override
+    public RedisFuture<String> clusterReset(boolean hard) {
+        return dispatch(commandBuilder.clusterReset(hard));
+    }
+
+    @Override
+    public RedisFuture<String> clusterSaveconfig() {
+        return dispatch(commandBuilder.clusterSaveconfig());
+    }
+
+    @Override
+    public RedisFuture<String> clusterSetConfigEpoch(long configEpoch) {
+        return dispatch(commandBuilder.clusterSetConfigEpoch(configEpoch));
+    }
+
+    @Override
+    public RedisFuture<String> clusterSetSlotImporting(int slot, String nodeId) {
+        return dispatch(commandBuilder.clusterSetSlotImporting(slot, nodeId));
+    }
+
+    @Override
+    public RedisFuture<String> clusterSetSlotMigrating(int slot, String nodeId) {
+        return dispatch(commandBuilder.clusterSetSlotMigrating(slot, nodeId));
+    }
+
+    @Override
+    public RedisFuture<String> clusterSetSlotNode(int slot, String nodeId) {
+        return dispatch(commandBuilder.clusterSetSlotNode(slot, nodeId));
+    }
+
+    @Override
+    public RedisFuture<String> clusterSetSlotStable(int slot) {
+        return dispatch(commandBuilder.clusterSetSlotStable(slot));
+    }
+
+    @Override
+    public RedisFuture<List<String>> clusterSlaves(String nodeId) {
+        return dispatch(commandBuilder.clusterSlaves(nodeId));
+    }
+
+    @Override
+    public RedisFuture<List<Object>> clusterSlots() {
+        return dispatch(commandBuilder.clusterSlots());
     }
 
     @Override
@@ -189,6 +320,11 @@ public RedisFuture<List<Object>> command() {
         return dispatch(commandBuilder.command());
     }
 
+    @Override
+    public RedisFuture<Long> commandCount() {
+        return dispatch(commandBuilder.commandCount());
+    }
+
     @Override
     public RedisFuture<List<Object>> commandInfo(String... commands) {
         return dispatch(commandBuilder.commandInfo(commands));
@@ -204,11 +340,6 @@ public RedisFuture<List<Object>> commandInfo(CommandType... commands) {
         return commandInfo(stringCommands);
     }
 
-    @Override
-    public RedisFuture<Long> commandCount() {
-        return dispatch(commandBuilder.commandCount());
-    }
-
     @Override
     public RedisFuture<List<String>> configGet(String parameter) {
         return dispatch(commandBuilder.configGet(parameter));
@@ -220,13 +351,13 @@ public RedisFuture<String> configResetstat() {
     }
 
     @Override
-    public RedisFuture<String> configSet(String parameter, String value) {
-        return dispatch(commandBuilder.configSet(parameter, value));
+    public RedisFuture<String> configRewrite() {
+        return dispatch(commandBuilder.configRewrite());
     }
 
     @Override
-    public RedisFuture<String> configRewrite() {
-        return dispatch(commandBuilder.configRewrite());
+    public RedisFuture<String> configSet(String parameter, String value) {
+        return dispatch(commandBuilder.configSet(parameter, value));
     }
 
     @Override
@@ -294,12 +425,8 @@ public RedisFuture<Long> del(Iterable<K> keys) {
     }
 
     @Override
-    public RedisFuture<Long> unlink(K... keys) {
-        return dispatch(commandBuilder.unlink(keys));
-    }
-
-    public RedisFuture<Long> unlink(Iterable<K> keys) {
-        return dispatch(commandBuilder.unlink(keys));
+    public String digest(V script) {
+        return LettuceStrings.digest(codec.encodeValue(script));
     }
 
     @Override
@@ -307,6 +434,42 @@ public RedisFuture<String> discard() {
         return dispatch(commandBuilder.discard());
     }
 
+    @Override
+    public <T> RedisFuture<T> dispatch(ProtocolKeyword type, CommandOutput<K, V, T> output) {
+
+        LettuceAssert.notNull(type, "Command type must not be null");
+        LettuceAssert.notNull(output, "CommandOutput type must not be null");
+
+        return dispatch(new AsyncCommand<>(new Command<>(type, output)));
+    }
+
+    @Override
+    public <T> RedisFuture<T> dispatch(ProtocolKeyword type, CommandOutput<K, V, T> output, CommandArgs<K, V> args) {
+
+        LettuceAssert.notNull(type, "Command type must not be null");
+        LettuceAssert.notNull(output, "CommandOutput type must not be null");
+        LettuceAssert.notNull(args, "CommandArgs type must not be null");
+
+        return dispatch(new AsyncCommand<>(new Command<>(type, output, args)));
+    }
+
+    protected <T> RedisFuture<T> dispatch(CommandType type, CommandOutput<K, V, T> output) {
+        return dispatch(type, output, null);
+    }
+
+    protected <T> RedisFuture<T> dispatch(CommandType type, CommandOutput<K, V, T> output, CommandArgs<K, V> args) {
+        return dispatch(new AsyncCommand<>(new Command<>(type, output, args)));
+    }
+
+    public <T> AsyncCommand<K, V, T> dispatch(RedisCommand<K, V, T> cmd) {
+        AsyncCommand<K, V, T> asyncCommand = new AsyncCommand<>(cmd);
+        RedisCommand<K, V, T> dispatched = connection.dispatch(asyncCommand);
+        if (dispatched instanceof AsyncCommand) {
+            return (AsyncCommand<K, V, T>) dispatched;
+        }
+        return asyncCommand;
+    }
+
     @Override
     public RedisFuture<byte[]> dump(K key) {
         return dispatch(commandBuilder.dump(key));
@@ -341,6 +504,11 @@ public <T> RedisFuture<T> evalsha(String digest, ScriptOutputType type, K[] keys
         return (RedisFuture<T>) dispatch(commandBuilder.evalsha(digest, type, keys, values));
     }
 
+    @Override
+    public RedisFuture<List<Object>> exec() {
+        return dispatch(EXEC, null);
+    }
+
     @Override
     public RedisFuture<Boolean> exists(K key) {
         return dispatch(commandBuilder.exists(key));
@@ -371,8 +539,8 @@ public RedisFuture<Boolean> expireat(K key, long timestamp) {
     }
 
     @Override
-    public RedisFuture<List<Object>> exec() {
-        return dispatch(EXEC, null);
+    public void flushCommands() {
+        connection.flushCommands();
     }
 
     @Override
@@ -396,23 +564,104 @@ public RedisFuture<String> flushdbAsync() {
     }
 
     @Override
-    public RedisFuture<V> get(K key) {
-        return dispatch(commandBuilder.get(key));
+    public RedisFuture<Long> geoadd(K key, double longitude, double latitude, V member) {
+        return dispatch(commandBuilder.geoadd(key, longitude, latitude, member));
     }
 
     @Override
-    public RedisFuture<Long> getbit(K key, long offset) {
-        return dispatch(commandBuilder.getbit(key, offset));
+    public RedisFuture<Long> geoadd(K key, Object... lngLatMember) {
+        return dispatch(commandBuilder.geoadd(key, lngLatMember));
     }
 
     @Override
-    public RedisFuture<V> getrange(K key, long start, long end) {
-        return dispatch(commandBuilder.getrange(key, start, end));
+    public RedisFuture<Double> geodist(K key, V from, V to, GeoArgs.Unit unit) {
+        return dispatch(commandBuilder.geodist(key, from, to, unit));
     }
 
     @Override
-    public RedisFuture<V> getset(K key, V value) {
-        return dispatch(commandBuilder.getset(key, value));
+    public RedisFuture<List<String>> geohash(K key, V... members) {
+        return dispatch(commandBuilder.geohash(key, members));
+    }
+
+    @Override
+    public RedisFuture<List<GeoCoordinates>> geopos(K key, V... members) {
+        return dispatch(commandBuilder.geopos(key, members));
+    }
+
+    @Override
+    public RedisFuture<Set<V>> georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit) {
+        return dispatch(commandBuilder.georadius(GEORADIUS, key, longitude, latitude, distance, unit.name()));
+    }
+
+    @Override
+    public RedisFuture<List<GeoWithin<V>>> georadius(K key, double longitude, double latitude, double distance,
+            GeoArgs.Unit unit, GeoArgs geoArgs) {
+        return dispatch(commandBuilder.georadius(GEORADIUS, key, longitude, latitude, distance, unit.name(), geoArgs));
+    }
+
+    @Override
+    public RedisFuture<Long> georadius(K key, double longitude, double latitude, double distance, Unit unit,
+            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
+        return dispatch(commandBuilder.georadius(key, longitude, latitude, distance, unit.name(), geoRadiusStoreArgs));
+    }
+
+    protected RedisFuture<Set<V>> georadius_ro(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit) {
+        return dispatch(commandBuilder.georadius(GEORADIUS_RO, key, longitude, latitude, distance, unit.name()));
+    }
+
+    protected RedisFuture<List<GeoWithin<V>>> georadius_ro(K key, double longitude, double latitude, double distance,
+            GeoArgs.Unit unit, GeoArgs geoArgs) {
+        return dispatch(commandBuilder.georadius(GEORADIUS_RO, key, longitude, latitude, distance, unit.name(), geoArgs));
+    }
+
+    @Override
+    public RedisFuture<Set<V>> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit) {
+        return dispatch(commandBuilder.georadiusbymember(GEORADIUSBYMEMBER, key, member, distance, unit.name()));
+    }
+
+    @Override
+    public RedisFuture<List<GeoWithin<V>>> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit,
+            GeoArgs geoArgs) {
+        return dispatch(commandBuilder.georadiusbymember(GEORADIUSBYMEMBER, key, member, distance, unit.name(), geoArgs));
+    }
+
+    @Override
+    public RedisFuture<Long> georadiusbymember(K key, V member, double distance, Unit unit,
+            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
+        return dispatch(commandBuilder.georadiusbymember(key, member, distance, unit.name(), geoRadiusStoreArgs));
+    }
+
+    protected RedisFuture<Set<V>> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit) {
+        return dispatch(commandBuilder.georadiusbymember(GEORADIUSBYMEMBER_RO, key, member, distance, unit.name()));
+    }
+
+    protected RedisFuture<List<GeoWithin<V>>> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit,
+            GeoArgs geoArgs) {
+        return dispatch(commandBuilder.georadiusbymember(GEORADIUSBYMEMBER_RO, key, member, distance, unit.name(), geoArgs));
+    }
+
+    @Override
+    public RedisFuture<V> get(K key) {
+        return dispatch(commandBuilder.get(key));
+    }
+
+    public StatefulConnection<K, V> getConnection() {
+        return connection;
+    }
+
+    @Override
+    public RedisFuture<Long> getbit(K key, long offset) {
+        return dispatch(commandBuilder.getbit(key, offset));
+    }
+
+    @Override
+    public RedisFuture<V> getrange(K key, long start, long end) {
+        return dispatch(commandBuilder.getrange(key, start, end));
+    }
+
+    @Override
+    public RedisFuture<V> getset(K key, V value) {
+        return dispatch(commandBuilder.getset(key, value));
     }
 
     @Override
@@ -431,23 +680,23 @@ public RedisFuture<V> hget(K key, K field) {
     }
 
     @Override
-    public RedisFuture<Long> hincrby(K key, K field, long amount) {
-        return dispatch(commandBuilder.hincrby(key, field, amount));
+    public RedisFuture<Map<K, V>> hgetall(K key) {
+        return dispatch(commandBuilder.hgetall(key));
     }
 
     @Override
-    public RedisFuture<Double> hincrbyfloat(K key, K field, double amount) {
-        return dispatch(commandBuilder.hincrbyfloat(key, field, amount));
+    public RedisFuture<Long> hgetall(KeyValueStreamingChannel<K, V> channel, K key) {
+        return dispatch(commandBuilder.hgetall(channel, key));
     }
 
     @Override
-    public RedisFuture<Map<K, V>> hgetall(K key) {
-        return dispatch(commandBuilder.hgetall(key));
+    public RedisFuture<Long> hincrby(K key, K field, long amount) {
+        return dispatch(commandBuilder.hincrby(key, field, amount));
     }
 
     @Override
-    public RedisFuture<Long> hgetall(KeyValueStreamingChannel<K, V> channel, K key) {
-        return dispatch(commandBuilder.hgetall(channel, key));
+    public RedisFuture<Double> hincrbyfloat(K key, K field, double amount) {
+        return dispatch(commandBuilder.hincrbyfloat(key, field, amount));
     }
 
     @Override
@@ -465,11 +714,6 @@ public RedisFuture<Long> hlen(K key) {
         return dispatch(commandBuilder.hlen(key));
     }
 
-    @Override
-    public RedisFuture<Long> hstrlen(K key, K field) {
-        return dispatch(commandBuilder.hstrlen(key, field));
-    }
-
     @Override
     public RedisFuture<List<V>> hmget(K key, K... fields) {
         return dispatch(commandBuilder.hmget(key, fields));
@@ -485,6 +729,47 @@ public RedisFuture<String> hmset(K key, Map<K, V> map) {
         return dispatch(commandBuilder.hmset(key, map));
     }
 
+    @Override
+    public RedisFuture<MapScanCursor<K, V>> hscan(K key) {
+        return dispatch(commandBuilder.hscan(key));
+    }
+
+    @Override
+    public RedisFuture<MapScanCursor<K, V>> hscan(K key, ScanArgs scanArgs) {
+        return dispatch(commandBuilder.hscan(key, scanArgs));
+    }
+
+    @Override
+    public RedisFuture<MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
+        return dispatch(commandBuilder.hscan(key, scanCursor, scanArgs));
+    }
+
+    @Override
+    public RedisFuture<MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor) {
+        return dispatch(commandBuilder.hscan(key, scanCursor));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key) {
+        return dispatch(commandBuilder.hscanStreaming(channel, key));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanArgs scanArgs) {
+        return dispatch(commandBuilder.hscanStreaming(channel, key, scanArgs));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor,
+            ScanArgs scanArgs) {
+        return dispatch(commandBuilder.hscanStreaming(channel, key, scanCursor, scanArgs));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor) {
+        return dispatch(commandBuilder.hscanStreaming(channel, key, scanCursor));
+    }
+
     @Override
     public RedisFuture<Boolean> hset(K key, K field, V value) {
         return dispatch(commandBuilder.hset(key, field, value));
@@ -495,6 +780,11 @@ public RedisFuture<Boolean> hsetnx(K key, K field, V value) {
         return dispatch(commandBuilder.hsetnx(key, field, value));
     }
 
+    @Override
+    public RedisFuture<Long> hstrlen(K key, K field) {
+        return dispatch(commandBuilder.hstrlen(key, field));
+    }
+
     @Override
     public RedisFuture<List<V>> hvals(K key) {
         return dispatch(commandBuilder.hvals(key));
@@ -530,6 +820,11 @@ public RedisFuture<String> info(String section) {
         return dispatch(commandBuilder.info(section));
     }
 
+    @Override
+    public boolean isOpen() {
+        return connection.isOpen();
+    }
+
     @Override
     public RedisFuture<List<K>> keys(K pattern) {
         return dispatch(commandBuilder.keys(pattern));
@@ -605,16 +900,6 @@ public RedisFuture<String> ltrim(K key, long start, long stop) {
         return dispatch(commandBuilder.ltrim(key, start, stop));
     }
 
-    @Override
-    public RedisFuture<String> migrate(String host, int port, K key, int db, long timeout) {
-        return dispatch(commandBuilder.migrate(host, port, key, db, timeout));
-    }
-
-    @Override
-    public RedisFuture<String> migrate(String host, int port, int db, long timeout, MigrateArgs<K> migrateArgs) {
-        return dispatch(commandBuilder.migrate(host, port, db, timeout, migrateArgs));
-    }
-
     @Override
     public RedisFuture<List<V>> mget(K... keys) {
         return dispatch(commandBuilder.mget(keys));
@@ -634,13 +919,18 @@ public RedisFuture<Long> mget(ValueStreamingChannel<V> channel, Iterable<K> keys
     }
 
     @Override
-    public RedisFuture<Boolean> move(K key, int db) {
-        return dispatch(commandBuilder.move(key, db));
+    public RedisFuture<String> migrate(String host, int port, K key, int db, long timeout) {
+        return dispatch(commandBuilder.migrate(host, port, key, db, timeout));
     }
 
     @Override
-    public RedisFuture<String> multi() {
-        return dispatch(commandBuilder.multi());
+    public RedisFuture<String> migrate(String host, int port, int db, long timeout, MigrateArgs<K> migrateArgs) {
+        return dispatch(commandBuilder.migrate(host, port, db, timeout, migrateArgs));
+    }
+
+    @Override
+    public RedisFuture<Boolean> move(K key, int db) {
+        return dispatch(commandBuilder.move(key, db));
     }
 
     @Override
@@ -653,6 +943,11 @@ public RedisFuture<Boolean> msetnx(Map<K, V> map) {
         return dispatch(commandBuilder.msetnx(map));
     }
 
+    @Override
+    public RedisFuture<String> multi() {
+        return dispatch(commandBuilder.multi());
+    }
+
     @Override
     public RedisFuture<String> objectEncoding(K key) {
         return dispatch(commandBuilder.objectEncoding(key));
@@ -689,20 +984,43 @@ public RedisFuture<Boolean> pexpireat(K key, long timestamp) {
     }
 
     @Override
-    public RedisFuture<String> ping() {
-        return dispatch(commandBuilder.ping());
+    public RedisFuture<Long> pfadd(K key, V value, V... moreValues) {
+        return dispatch(commandBuilder.pfadd(key, value, moreValues));
     }
 
     @Override
-    public RedisFuture<String> readOnly() {
-        AsyncCommand<K, V, String> cmd = dispatch(commandBuilder.readOnly());
-        return cmd;
+    public RedisFuture<Long> pfadd(K key, V... values) {
+        return dispatch(commandBuilder.pfadd(key, values));
     }
 
     @Override
-    public RedisFuture<String> readWrite() {
-        AsyncCommand<K, V, String> cmd = dispatch(commandBuilder.readWrite());
-        return cmd;
+    public RedisFuture<Long> pfcount(K key, K... moreKeys) {
+        return dispatch(commandBuilder.pfcount(key, moreKeys));
+    }
+
+    @Override
+    public RedisFuture<Long> pfcount(K... keys) {
+        return dispatch(commandBuilder.pfcount(keys));
+    }
+
+    @Override
+    public RedisFuture<String> pfmerge(K destkey, K sourcekey, K... moreSourceKeys) {
+        return dispatch(commandBuilder.pfmerge(destkey, sourcekey, moreSourceKeys));
+    }
+
+    @Override
+    public RedisFuture<String> pfmerge(K destkey, K... sourcekeys) {
+        return dispatch(commandBuilder.pfmerge(destkey, sourcekeys));
+    }
+
+    @Override
+    public RedisFuture<String> ping() {
+        return dispatch(commandBuilder.ping());
+    }
+
+    @Override
+    public RedisFuture<String> psetex(K key, long milliseconds, V value) {
+        return dispatch(commandBuilder.psetex(key, milliseconds, value));
     }
 
     @Override
@@ -726,13 +1044,13 @@ public RedisFuture<List<K>> pubsubChannels(K channel) {
     }
 
     @Override
-    public RedisFuture<Map<K, Long>> pubsubNumsub(K... channels) {
-        return dispatch(commandBuilder.pubsubNumsub(channels));
+    public RedisFuture<Long> pubsubNumpat() {
+        return dispatch(commandBuilder.pubsubNumpat());
     }
 
     @Override
-    public RedisFuture<Long> pubsubNumpat() {
-        return dispatch(commandBuilder.pubsubNumpat());
+    public RedisFuture<Map<K, Long>> pubsubNumsub(K... channels) {
+        return dispatch(commandBuilder.pubsubNumsub(channels));
     }
 
     @Override
@@ -741,13 +1059,20 @@ public RedisFuture<String> quit() {
     }
 
     @Override
-    public RedisFuture<List<Object>> role() {
-        return dispatch(commandBuilder.role());
+    public RedisFuture<V> randomkey() {
+        return dispatch(commandBuilder.randomkey());
     }
 
     @Override
-    public RedisFuture<V> randomkey() {
-        return dispatch(commandBuilder.randomkey());
+    public RedisFuture<String> readOnly() {
+        AsyncCommand<K, V, String> cmd = dispatch(commandBuilder.readOnly());
+        return cmd;
+    }
+
+    @Override
+    public RedisFuture<String> readWrite() {
+        AsyncCommand<K, V, String> cmd = dispatch(commandBuilder.readWrite());
+        return cmd;
     }
 
     @Override
@@ -760,11 +1085,21 @@ public RedisFuture<Boolean> renamenx(K key, K newKey) {
         return dispatch(commandBuilder.renamenx(key, newKey));
     }
 
+    @Override
+    public void reset() {
+        getConnection().reset();
+    }
+
     @Override
     public RedisFuture<String> restore(K key, long ttl, byte[] value) {
         return dispatch(commandBuilder.restore(key, ttl, value));
     }
 
+    @Override
+    public RedisFuture<List<Object>> role() {
+        return dispatch(commandBuilder.role());
+    }
+
     @Override
     public RedisFuture<V> rpop(K key) {
         return dispatch(commandBuilder.rpop(key));
@@ -801,7 +1136,47 @@ public RedisFuture<String> save() {
     }
 
     @Override
-    public RedisFuture<Long> scard(K key) {
+    public RedisFuture<KeyScanCursor<K>> scan() {
+        return dispatch(commandBuilder.scan());
+    }
+
+    @Override
+    public RedisFuture<KeyScanCursor<K>> scan(ScanArgs scanArgs) {
+        return dispatch(commandBuilder.scan(scanArgs));
+    }
+
+    @Override
+    public RedisFuture<KeyScanCursor<K>> scan(ScanCursor scanCursor, ScanArgs scanArgs) {
+        return dispatch(commandBuilder.scan(scanCursor, scanArgs));
+    }
+
+    @Override
+    public RedisFuture<KeyScanCursor<K>> scan(ScanCursor scanCursor) {
+        return dispatch(commandBuilder.scan(scanCursor));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel) {
+        return dispatch(commandBuilder.scanStreaming(channel));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs) {
+        return dispatch(commandBuilder.scanStreaming(channel, scanArgs));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs) {
+        return dispatch(commandBuilder.scanStreaming(channel, scanCursor, scanArgs));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor) {
+        return dispatch(commandBuilder.scanStreaming(channel, scanCursor));
+    }
+
+    @Override
+    public RedisFuture<Long> scard(K key) {
         return dispatch(commandBuilder.scard(key));
     }
 
@@ -850,10 +1225,6 @@ protected AsyncCommand<K, V, String> selectAsync(int db) {
         return dispatch(commandBuilder.select(db));
     }
 
-    public RedisFuture<String> swapdb(int db1, int db2) {
-        return dispatch(commandBuilder.swapdb(db1, db2));
-    }
-
     @Override
     public RedisFuture<String> set(K key, V value) {
         return dispatch(commandBuilder.set(key, value));
@@ -864,6 +1235,15 @@ public RedisFuture<String> set(K key, V value, SetArgs setArgs) {
         return dispatch(commandBuilder.set(key, value, setArgs));
     }
 
+    @Override
+    public void setAutoFlushCommands(boolean autoFlush) {
+        connection.setAutoFlushCommands(autoFlush);
+    }
+
+    public void setTimeout(long timeout, TimeUnit unit) {
+        connection.setTimeout(timeout, unit);
+    }
+
     @Override
     public RedisFuture<Long> setbit(K key, long offset, int value) {
         return dispatch(commandBuilder.setbit(key, offset, value));
@@ -874,11 +1254,6 @@ public RedisFuture<String> setex(K key, long seconds, V value) {
         return dispatch(commandBuilder.setex(key, seconds, value));
     }
 
-    @Override
-    public RedisFuture<String> psetex(K key, long milliseconds, V value) {
-        return dispatch(commandBuilder.psetex(key, milliseconds, value));
-    }
-
     @Override
     public RedisFuture<Boolean> setnx(K key, V value) {
         return dispatch(commandBuilder.setnx(key, value));
@@ -919,11 +1294,6 @@ public RedisFuture<Boolean> sismember(K key, V member) {
         return dispatch(commandBuilder.sismember(key, member));
     }
 
-    @Override
-    public RedisFuture<Boolean> smove(K source, K destination, V member) {
-        return dispatch(commandBuilder.smove(source, destination, member));
-    }
-
     @Override
     public RedisFuture<String> slaveof(String host, int port) {
         return dispatch(commandBuilder.slaveof(host, port));
@@ -964,6 +1334,11 @@ public RedisFuture<Long> smembers(ValueStreamingChannel<V> channel, K key) {
         return dispatch(commandBuilder.smembers(channel, key));
     }
 
+    @Override
+    public RedisFuture<Boolean> smove(K source, K destination, V member) {
+        return dispatch(commandBuilder.smove(source, destination, member));
+    }
+
     @Override
     public RedisFuture<List<V>> sort(K key) {
         return dispatch(commandBuilder.sort(key));
@@ -1019,6 +1394,51 @@ public RedisFuture<Long> srem(K key, V... members) {
         return dispatch(commandBuilder.srem(key, members));
     }
 
+    @Override
+    public RedisFuture<ValueScanCursor<V>> sscan(K key) {
+        return dispatch(commandBuilder.sscan(key));
+    }
+
+    @Override
+    public RedisFuture<ValueScanCursor<V>> sscan(K key, ScanArgs scanArgs) {
+        return dispatch(commandBuilder.sscan(key, scanArgs));
+    }
+
+    @Override
+    public RedisFuture<ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
+        return dispatch(commandBuilder.sscan(key, scanCursor, scanArgs));
+    }
+
+    @Override
+    public RedisFuture<ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor) {
+        return dispatch(commandBuilder.sscan(key, scanCursor));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key) {
+        return dispatch(commandBuilder.sscanStreaming(channel, key));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanArgs scanArgs) {
+        return dispatch(commandBuilder.sscanStreaming(channel, key, scanArgs));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs) {
+        return dispatch(commandBuilder.sscanStreaming(channel, key, scanCursor, scanArgs));
+    }
+
+    @Override
+    public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor) {
+        return dispatch(commandBuilder.sscanStreaming(channel, key, scanCursor));
+    }
+
+    @Override
+    public RedisFuture<Long> strlen(K key) {
+        return dispatch(commandBuilder.strlen(key));
+    }
+
     @Override
     public RedisFuture<Set<V>> sunion(K... keys) {
         return dispatch(commandBuilder.sunion(keys));
@@ -1034,14 +1454,18 @@ public RedisFuture<Long> sunionstore(K destination, K... keys) {
         return dispatch(commandBuilder.sunionstore(destination, keys));
     }
 
+    public RedisFuture<String> swapdb(int db1, int db2) {
+        return dispatch(commandBuilder.swapdb(db1, db2));
+    }
+
     @Override
     public RedisFuture<String> sync() {
         return dispatch(commandBuilder.sync());
     }
 
     @Override
-    public RedisFuture<Long> strlen(K key) {
-        return dispatch(commandBuilder.strlen(key));
+    public RedisFuture<List<V>> time() {
+        return dispatch(commandBuilder.time());
     }
 
     @Override
@@ -1064,8 +1488,12 @@ public RedisFuture<String> type(K key) {
     }
 
     @Override
-    public RedisFuture<String> watch(K... keys) {
-        return dispatch(commandBuilder.watch(keys));
+    public RedisFuture<Long> unlink(K... keys) {
+        return dispatch(commandBuilder.unlink(keys));
+    }
+
+    public RedisFuture<Long> unlink(Iterable<K> keys) {
+        return dispatch(commandBuilder.unlink(keys));
     }
 
     @Override
@@ -1073,6 +1501,16 @@ public RedisFuture<String> unwatch() {
         return dispatch(commandBuilder.unwatch());
     }
 
+    @Override
+    public RedisFuture<Long> waitForReplication(int replicas, long timeout) {
+        return dispatch(commandBuilder.wait(replicas, timeout));
+    }
+
+    @Override
+    public RedisFuture<String> watch(K... keys) {
+        return dispatch(commandBuilder.watch(keys));
+    }
+
     @Override
     public RedisFuture<Long> zadd(K key, double score, V member) {
         return dispatch(commandBuilder.zadd(key, null, score, member));
@@ -1149,83 +1587,83 @@ public RedisFuture<Long> zinterstore(K destination, ZStoreArgs storeArgs, K... k
     }
 
     @Override
-    public RedisFuture<List<V>> zrange(K key, long start, long stop) {
-        return dispatch(commandBuilder.zrange(key, start, stop));
+    public RedisFuture<Long> zlexcount(K key, String min, String max) {
+        return dispatch(commandBuilder.zlexcount(key, min, max));
     }
 
     @Override
-    public RedisFuture<List<ScoredValue<V>>> zrangeWithScores(K key, long start, long stop) {
-        return dispatch(commandBuilder.zrangeWithScores(key, start, stop));
+    public RedisFuture<Long> zlexcount(K key, Range<? extends V> range) {
+        return dispatch(commandBuilder.zlexcount(key, range));
     }
 
     @Override
-    public RedisFuture<List<V>> zrangebyscore(K key, double min, double max) {
-        return dispatch(commandBuilder.zrangebyscore(key, min, max));
+    public RedisFuture<List<V>> zrange(K key, long start, long stop) {
+        return dispatch(commandBuilder.zrange(key, start, stop));
     }
 
     @Override
-    public RedisFuture<List<V>> zrangebyscore(K key, String min, String max) {
-        return dispatch(commandBuilder.zrangebyscore(key, min, max));
+    public RedisFuture<Long> zrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
+        return dispatch(commandBuilder.zrange(channel, key, start, stop));
     }
 
     @Override
-    public RedisFuture<List<V>> zrangebyscore(K key, Range<? extends Number> range) {
-        return dispatch(commandBuilder.zrangebyscore(key, range, Limit.unlimited()));
+    public RedisFuture<List<ScoredValue<V>>> zrangeWithScores(K key, long start, long stop) {
+        return dispatch(commandBuilder.zrangeWithScores(key, start, stop));
     }
 
     @Override
-    public RedisFuture<List<V>> zrangebyscore(K key, double min, double max, long offset, long count) {
-        return dispatch(commandBuilder.zrangebyscore(key, min, max, offset, count));
+    public RedisFuture<Long> zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
+        return dispatch(commandBuilder.zrangeWithScores(channel, key, start, stop));
     }
 
     @Override
-    public RedisFuture<List<V>> zrangebyscore(K key, String min, String max, long offset, long count) {
-        return dispatch(commandBuilder.zrangebyscore(key, min, max, offset, count));
+    public RedisFuture<List<V>> zrangebylex(K key, String min, String max) {
+        return dispatch(commandBuilder.zrangebylex(key, min, max));
     }
 
     @Override
-    public RedisFuture<List<V>> zrangebyscore(K key, Range<? extends Number> range, Limit limit) {
-        return dispatch(commandBuilder.zrangebyscore(key, range, limit));
+    public RedisFuture<List<V>> zrangebylex(K key, Range<? extends V> range) {
+        return dispatch(commandBuilder.zrangebylex(key, range, Limit.unlimited()));
     }
 
     @Override
-    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, double min, double max) {
-        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max));
+    public RedisFuture<List<V>> zrangebylex(K key, String min, String max, long offset, long count) {
+        return dispatch(commandBuilder.zrangebylex(key, min, max, offset, count));
     }
 
     @Override
-    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, String min, String max) {
-        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max));
+    public RedisFuture<List<V>> zrangebylex(K key, Range<? extends V> range, Limit limit) {
+        return dispatch(commandBuilder.zrangebylex(key, range, limit));
     }
 
     @Override
-    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, Range<? extends Number> range) {
-        return dispatch(commandBuilder.zrangebyscoreWithScores(key, range, Limit.unlimited()));
+    public RedisFuture<List<V>> zrangebyscore(K key, double min, double max) {
+        return dispatch(commandBuilder.zrangebyscore(key, min, max));
     }
 
     @Override
-    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, double min, double max, long offset, long count) {
-        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
+    public RedisFuture<List<V>> zrangebyscore(K key, String min, String max) {
+        return dispatch(commandBuilder.zrangebyscore(key, min, max));
     }
 
     @Override
-    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, String min, String max, long offset, long count) {
-        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
+    public RedisFuture<List<V>> zrangebyscore(K key, Range<? extends Number> range) {
+        return dispatch(commandBuilder.zrangebyscore(key, range, Limit.unlimited()));
     }
 
     @Override
-    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
-        return dispatch(commandBuilder.zrangebyscoreWithScores(key, range, limit));
+    public RedisFuture<List<V>> zrangebyscore(K key, double min, double max, long offset, long count) {
+        return dispatch(commandBuilder.zrangebyscore(key, min, max, offset, count));
     }
 
     @Override
-    public RedisFuture<Long> zrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
-        return dispatch(commandBuilder.zrange(channel, key, start, stop));
+    public RedisFuture<List<V>> zrangebyscore(K key, String min, String max, long offset, long count) {
+        return dispatch(commandBuilder.zrangebyscore(key, min, max, offset, count));
     }
 
     @Override
-    public RedisFuture<Long> zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
-        return dispatch(commandBuilder.zrangeWithScores(channel, key, start, stop));
+    public RedisFuture<List<V>> zrangebyscore(K key, Range<? extends Number> range, Limit limit) {
+        return dispatch(commandBuilder.zrangebyscore(key, range, limit));
     }
 
     @Override
@@ -1260,6 +1698,36 @@ public RedisFuture<Long> zrangebyscore(ValueStreamingChannel<V> channel, K key,
         return dispatch(commandBuilder.zrangebyscore(channel, key, range, limit));
     }
 
+    @Override
+    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, double min, double max) {
+        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max));
+    }
+
+    @Override
+    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, String min, String max) {
+        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max));
+    }
+
+    @Override
+    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, Range<? extends Number> range) {
+        return dispatch(commandBuilder.zrangebyscoreWithScores(key, range, Limit.unlimited()));
+    }
+
+    @Override
+    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, double min, double max, long offset, long count) {
+        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
+    }
+
+    @Override
+    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, String min, String max, long offset, long count) {
+        return dispatch(commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
+    }
+
+    @Override
+    public RedisFuture<List<ScoredValue<V>>> zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
+        return dispatch(commandBuilder.zrangebyscoreWithScores(key, range, limit));
+    }
+
     @Override
     public RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max) {
         return dispatch(commandBuilder.zrangebyscoreWithScores(channel, key, min, max));
@@ -1271,7 +1739,8 @@ public RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V>
     }
 
     @Override
-    public RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range) {
+    public RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key,
+            Range<? extends Number> range) {
         return dispatch(commandBuilder.zrangebyscoreWithScores(channel, key, range, Limit.unlimited()));
     }
 
@@ -1288,8 +1757,8 @@ public RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V>
     }
 
     @Override
-    public RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range,
-           Limit limit) {
+    public RedisFuture<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key,
+            Range<? extends Number> range, Limit limit) {
         return dispatch(commandBuilder.zrangebyscoreWithScores(channel, key, range, limit));
     }
 
@@ -1303,6 +1772,16 @@ public RedisFuture<Long> zrem(K key, V... members) {
         return dispatch(commandBuilder.zrem(key, members));
     }
 
+    @Override
+    public RedisFuture<Long> zremrangebylex(K key, String min, String max) {
+        return dispatch(commandBuilder.zremrangebylex(key, min, max));
+    }
+
+    @Override
+    public RedisFuture<Long> zremrangebylex(K key, Range<? extends V> range) {
+        return dispatch(commandBuilder.zremrangebylex(key, range));
+    }
+
     @Override
     public RedisFuture<Long> zremrangebyrank(K key, long start, long stop) {
         return dispatch(commandBuilder.zremrangebyrank(key, start, stop));
@@ -1328,11 +1807,21 @@ public RedisFuture<List<V>> zrevrange(K key, long start, long stop) {
         return dispatch(commandBuilder.zrevrange(key, start, stop));
     }
 
+    @Override
+    public RedisFuture<Long> zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
+        return dispatch(commandBuilder.zrevrange(channel, key, start, stop));
+    }
+
     @Override
     public RedisFuture<List<ScoredValue<V>>> zrevrangeWithScores(K key, long start, long stop) {
         return dispatch(commandBuilder.zrevrangeWithScores(key, start, stop));
     }
 
+    @Override
+    public RedisFuture<Long> zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
+        return dispatch(commandBuilder.zrevrangeWithScores(channel, key, start, stop));
+    }
+
     @Override
     public RedisFuture<List<V>> zrevrangebylex(K key, Range<? extends V> range) {
         return dispatch(commandBuilder.zrevrangebylex(key, range, Limit.unlimited()));
@@ -1374,75 +1863,66 @@ public RedisFuture<List<V>> zrevrangebyscore(K key, Range<? extends Number> rang
     }
 
     @Override
-    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, double max, double min) {
-        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min));
-    }
-
-    @Override
-    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, String max, String min) {
-        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min));
-    }
-
-    @Override
-    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range) {
-        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, range, Limit.unlimited()));
+    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min) {
+        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min));
     }
 
     @Override
-    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count) {
-        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
+    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min) {
+        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min));
     }
 
     @Override
-    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count) {
-        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
+    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range) {
+        return dispatch(commandBuilder.zrevrangebyscore(channel, key, range, Limit.unlimited()));
     }
 
     @Override
-    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
-        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, range, limit));
+    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min, long offset,
+            long count) {
+        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min, offset, count));
     }
 
     @Override
-    public RedisFuture<Long> zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
-        return dispatch(commandBuilder.zrevrange(channel, key, start, stop));
+    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min, long offset,
+            long count) {
+        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min, offset, count));
     }
 
     @Override
-    public RedisFuture<Long> zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
-        return dispatch(commandBuilder.zrevrangeWithScores(channel, key, start, stop));
+    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range,
+            Limit limit) {
+        return dispatch(commandBuilder.zrevrangebyscore(channel, key, range, limit));
     }
 
     @Override
-    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min) {
-        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min));
+    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, double max, double min) {
+        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min));
     }
 
     @Override
-    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min) {
-        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min));
+    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, String max, String min) {
+        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min));
     }
 
     @Override
-    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range) {
-        return dispatch(commandBuilder.zrevrangebyscore(channel, key, range, Limit.unlimited()));
+    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range) {
+        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, range, Limit.unlimited()));
     }
 
     @Override
-    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min, long offset,
-            long count) {
-        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min, offset, count));
+    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count) {
+        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
     }
 
     @Override
-    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min, long offset,
-            long count) {
-        return dispatch(commandBuilder.zrevrangebyscore(channel, key, max, min, offset, count));
+    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count) {
+        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
     }
 
     @Override
-    public RedisFuture<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) {
-        return dispatch(commandBuilder.zrevrangebyscore(channel, key, range, limit));
+    public RedisFuture<List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
+        return dispatch(commandBuilder.zrevrangebyscoreWithScores(key, range, limit));
     }
 
     @Override
@@ -1456,7 +1936,8 @@ public RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<
     }
 
     @Override
-    public RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range) {
+    public RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key,
+            Range<? extends Number> range) {
         return dispatch(commandBuilder.zrevrangebyscoreWithScores(channel, key, range, Limit.unlimited()));
     }
 
@@ -1473,8 +1954,8 @@ public RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<
     }
 
     @Override
-    public RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range,
-            Limit limit) {
+    public RedisFuture<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key,
+            Range<? extends Number> range, Limit limit) {
         return dispatch(commandBuilder.zrevrangebyscoreWithScores(channel, key, range, limit));
     }
 
@@ -1483,142 +1964,6 @@ public RedisFuture<Long> zrevrank(K key, V member) {
         return dispatch(commandBuilder.zrevrank(key, member));
     }
 
-    @Override
-    public RedisFuture<Double> zscore(K key, V member) {
-        return dispatch(commandBuilder.zscore(key, member));
-    }
-
-    @Override
-    public RedisFuture<Long> zunionstore(K destination, K... keys) {
-        return dispatch(commandBuilder.zunionstore(destination, keys));
-    }
-
-    @Override
-    public RedisFuture<Long> zunionstore(K destination, ZStoreArgs storeArgs, K... keys) {
-        return dispatch(commandBuilder.zunionstore(destination, storeArgs, keys));
-    }
-
-    @Override
-    public RedisFuture<KeyScanCursor<K>> scan() {
-        return dispatch(commandBuilder.scan());
-    }
-
-    @Override
-    public RedisFuture<KeyScanCursor<K>> scan(ScanArgs scanArgs) {
-        return dispatch(commandBuilder.scan(scanArgs));
-    }
-
-    @Override
-    public RedisFuture<KeyScanCursor<K>> scan(ScanCursor scanCursor, ScanArgs scanArgs) {
-        return dispatch(commandBuilder.scan(scanCursor, scanArgs));
-    }
-
-    @Override
-    public RedisFuture<KeyScanCursor<K>> scan(ScanCursor scanCursor) {
-        return dispatch(commandBuilder.scan(scanCursor));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel) {
-        return dispatch(commandBuilder.scanStreaming(channel));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs) {
-        return dispatch(commandBuilder.scanStreaming(channel, scanArgs));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs) {
-        return dispatch(commandBuilder.scanStreaming(channel, scanCursor, scanArgs));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor) {
-        return dispatch(commandBuilder.scanStreaming(channel, scanCursor));
-    }
-
-    @Override
-    public RedisFuture<ValueScanCursor<V>> sscan(K key) {
-        return dispatch(commandBuilder.sscan(key));
-    }
-
-    @Override
-    public RedisFuture<ValueScanCursor<V>> sscan(K key, ScanArgs scanArgs) {
-        return dispatch(commandBuilder.sscan(key, scanArgs));
-    }
-
-    @Override
-    public RedisFuture<ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
-        return dispatch(commandBuilder.sscan(key, scanCursor, scanArgs));
-    }
-
-    @Override
-    public RedisFuture<ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor) {
-        return dispatch(commandBuilder.sscan(key, scanCursor));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key) {
-        return dispatch(commandBuilder.sscanStreaming(channel, key));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanArgs scanArgs) {
-        return dispatch(commandBuilder.sscanStreaming(channel, key, scanArgs));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs) {
-        return dispatch(commandBuilder.sscanStreaming(channel, key, scanCursor, scanArgs));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor) {
-        return dispatch(commandBuilder.sscanStreaming(channel, key, scanCursor));
-    }
-
-    @Override
-    public RedisFuture<MapScanCursor<K, V>> hscan(K key) {
-        return dispatch(commandBuilder.hscan(key));
-    }
-
-    @Override
-    public RedisFuture<MapScanCursor<K, V>> hscan(K key, ScanArgs scanArgs) {
-        return dispatch(commandBuilder.hscan(key, scanArgs));
-    }
-
-    @Override
-    public RedisFuture<MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
-        return dispatch(commandBuilder.hscan(key, scanCursor, scanArgs));
-    }
-
-    @Override
-    public RedisFuture<MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor) {
-        return dispatch(commandBuilder.hscan(key, scanCursor));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key) {
-        return dispatch(commandBuilder.hscanStreaming(channel, key));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanArgs scanArgs) {
-        return dispatch(commandBuilder.hscanStreaming(channel, key, scanArgs));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor,
-            ScanArgs scanArgs) {
-        return dispatch(commandBuilder.hscanStreaming(channel, key, scanCursor, scanArgs));
-    }
-
-    @Override
-    public RedisFuture<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor) {
-        return dispatch(commandBuilder.hscanStreaming(channel, key, scanCursor));
-    }
-
     @Override
     public RedisFuture<ScoredValueScanCursor<V>> zscan(K key) {
         return dispatch(commandBuilder.zscan(key));
@@ -1661,358 +2006,17 @@ public RedisFuture<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channe
     }
 
     @Override
-    public String digest(V script) {
-        return LettuceStrings.digest(codec.encodeValue(script));
-    }
-
-    @Override
-    public RedisFuture<List<V>> time() {
-        return dispatch(commandBuilder.time());
-    }
-
-    @Override
-    public RedisFuture<Long> waitForReplication(int replicas, long timeout) {
-        return dispatch(commandBuilder.wait(replicas, timeout));
-    }
-
-    @Override
-    public RedisFuture<Long> pfadd(K key, V value, V... moreValues) {
-        return dispatch(commandBuilder.pfadd(key, value, moreValues));
-    }
-
-    @Override
-    public RedisFuture<Long> pfadd(K key, V... values) {
-        return dispatch(commandBuilder.pfadd(key, values));
-    }
-
-    @Override
-    public RedisFuture<String> pfmerge(K destkey, K sourcekey, K... moreSourceKeys) {
-        return dispatch(commandBuilder.pfmerge(destkey, sourcekey, moreSourceKeys));
-    }
-
-    @Override
-    public RedisFuture<String> pfmerge(K destkey, K... sourcekeys) {
-        return dispatch(commandBuilder.pfmerge(destkey, sourcekeys));
-    }
-
-    @Override
-    public RedisFuture<Long> pfcount(K key, K... moreKeys) {
-        return dispatch(commandBuilder.pfcount(key, moreKeys));
-    }
-
-    @Override
-    public RedisFuture<Long> pfcount(K... keys) {
-        return dispatch(commandBuilder.pfcount(keys));
-    }
-
-    @Override
-    public RedisFuture<String> clusterBumpepoch() {
-        return dispatch(commandBuilder.clusterBumpepoch());
-    }
-
-    @Override
-    public RedisFuture<String> clusterMeet(String ip, int port) {
-        return dispatch(commandBuilder.clusterMeet(ip, port));
+    public RedisFuture<Double> zscore(K key, V member) {
+        return dispatch(commandBuilder.zscore(key, member));
     }
 
     @Override
-    public RedisFuture<String> clusterForget(String nodeId) {
-        return dispatch(commandBuilder.clusterForget(nodeId));
+    public RedisFuture<Long> zunionstore(K destination, K... keys) {
+        return dispatch(commandBuilder.zunionstore(destination, keys));
     }
 
     @Override
-    public RedisFuture<String> clusterAddSlots(int... slots) {
-        return dispatch(commandBuilder.clusterAddslots(slots));
-    }
-
-    @Override
-    public RedisFuture<String> clusterDelSlots(int... slots) {
-        return dispatch(commandBuilder.clusterDelslots(slots));
-    }
-
-    @Override
-    public RedisFuture<String> clusterInfo() {
-        return dispatch(commandBuilder.clusterInfo());
-    }
-
-    @Override
-    public RedisFuture<String> clusterMyId() {
-        return dispatch(commandBuilder.clusterMyId());
-    }
-
-    @Override
-    public RedisFuture<String> clusterNodes() {
-        return dispatch(commandBuilder.clusterNodes());
-    }
-
-    @Override
-    public RedisFuture<List<K>> clusterGetKeysInSlot(int slot, int count) {
-        return dispatch(commandBuilder.clusterGetKeysInSlot(slot, count));
-    }
-
-    @Override
-    public RedisFuture<Long> clusterCountKeysInSlot(int slot) {
-        return dispatch(commandBuilder.clusterCountKeysInSlot(slot));
-    }
-
-    @Override
-    public RedisFuture<Long> clusterCountFailureReports(String nodeId) {
-        return dispatch(commandBuilder.clusterCountFailureReports(nodeId));
-    }
-
-    @Override
-    public RedisFuture<Long> clusterKeyslot(K key) {
-        return dispatch(commandBuilder.clusterKeyslot(key));
-    }
-
-    @Override
-    public RedisFuture<String> clusterSaveconfig() {
-        return dispatch(commandBuilder.clusterSaveconfig());
-    }
-
-    @Override
-    public RedisFuture<String> clusterSetConfigEpoch(long configEpoch) {
-        return dispatch(commandBuilder.clusterSetConfigEpoch(configEpoch));
-    }
-
-    @Override
-    public RedisFuture<List<Object>> clusterSlots() {
-        return dispatch(commandBuilder.clusterSlots());
-    }
-
-    @Override
-    public RedisFuture<String> clusterSetSlotNode(int slot, String nodeId) {
-        return dispatch(commandBuilder.clusterSetSlotNode(slot, nodeId));
-    }
-
-    @Override
-    public RedisFuture<String> clusterSetSlotStable(int slot) {
-        return dispatch(commandBuilder.clusterSetSlotStable(slot));
-    }
-
-    @Override
-    public RedisFuture<String> clusterSetSlotMigrating(int slot, String nodeId) {
-        return dispatch(commandBuilder.clusterSetSlotMigrating(slot, nodeId));
-    }
-
-    @Override
-    public RedisFuture<String> clusterSetSlotImporting(int slot, String nodeId) {
-        return dispatch(commandBuilder.clusterSetSlotImporting(slot, nodeId));
-    }
-
-    @Override
-    public RedisFuture<String> clusterFailover(boolean force) {
-        return dispatch(commandBuilder.clusterFailover(force));
-    }
-
-    @Override
-    public RedisFuture<String> clusterReset(boolean hard) {
-        return dispatch(commandBuilder.clusterReset(hard));
-    }
-
-    @Override
-    public RedisFuture<String> asking() {
-        return dispatch(commandBuilder.asking());
-    }
-
-    @Override
-    public RedisFuture<String> clusterReplicate(String nodeId) {
-        return dispatch(commandBuilder.clusterReplicate(nodeId));
-    }
-
-    @Override
-    public RedisFuture<String> clusterFlushslots() {
-        return dispatch(commandBuilder.clusterFlushslots());
-    }
-
-    @Override
-    public RedisFuture<List<String>> clusterSlaves(String nodeId) {
-        return dispatch(commandBuilder.clusterSlaves(nodeId));
-    }
-
-    @Override
-    public RedisFuture<Long> zlexcount(K key, String min, String max) {
-        return dispatch(commandBuilder.zlexcount(key, min, max));
-    }
-
-    @Override
-    public RedisFuture<Long> zlexcount(K key, Range<? extends V> range) {
-        return dispatch(commandBuilder.zlexcount(key, range));
-    }
-
-    @Override
-    public RedisFuture<Long> zremrangebylex(K key, String min, String max) {
-        return dispatch(commandBuilder.zremrangebylex(key, min, max));
-    }
-
-    @Override
-    public RedisFuture<Long> zremrangebylex(K key, Range<? extends V> range) {
-        return dispatch(commandBuilder.zremrangebylex(key, range));
-    }
-
-    @Override
-    public RedisFuture<List<V>> zrangebylex(K key, String min, String max) {
-        return dispatch(commandBuilder.zrangebylex(key, min, max));
-    }
-
-    @Override
-    public RedisFuture<List<V>> zrangebylex(K key, Range<? extends V> range) {
-        return dispatch(commandBuilder.zrangebylex(key, range, Limit.unlimited()));
-    }
-
-    @Override
-    public RedisFuture<List<V>> zrangebylex(K key, String min, String max, long offset, long count) {
-        return dispatch(commandBuilder.zrangebylex(key, min, max, offset, count));
-    }
-
-    @Override
-    public RedisFuture<List<V>> zrangebylex(K key, Range<? extends V> range, Limit limit) {
-        return dispatch(commandBuilder.zrangebylex(key, range, limit));
-    }
-
-    @Override
-    public RedisFuture<Long> geoadd(K key, double longitude, double latitude, V member) {
-        return dispatch(commandBuilder.geoadd(key, longitude, latitude, member));
-    }
-
-    @Override
-    public RedisFuture<Long> geoadd(K key, Object... lngLatMember) {
-        return dispatch(commandBuilder.geoadd(key, lngLatMember));
-    }
-
-    @Override
-    public RedisFuture<List<String>> geohash(K key, V... members) {
-        return dispatch(commandBuilder.geohash(key, members));
-    }
-
-    @Override
-    public RedisFuture<Set<V>> georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit) {
-        return dispatch(commandBuilder.georadius(GEORADIUS, key, longitude, latitude, distance, unit.name()));
-    }
-
-    protected RedisFuture<Set<V>> georadius_ro(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit) {
-        return dispatch(commandBuilder.georadius(GEORADIUS_RO, key, longitude, latitude, distance, unit.name()));
-    }
-
-    @Override
-    public RedisFuture<List<GeoWithin<V>>> georadius(K key, double longitude, double latitude, double distance,
-            GeoArgs.Unit unit, GeoArgs geoArgs) {
-        return dispatch(commandBuilder.georadius(GEORADIUS, key, longitude, latitude, distance, unit.name(), geoArgs));
-    }
-
-    protected RedisFuture<List<GeoWithin<V>>> georadius_ro(K key, double longitude, double latitude, double distance,
-            GeoArgs.Unit unit, GeoArgs geoArgs) {
-        return dispatch(commandBuilder.georadius(GEORADIUS_RO, key, longitude, latitude, distance, unit.name(), geoArgs));
-    }
-
-    @Override
-    public RedisFuture<Long> georadius(K key, double longitude, double latitude, double distance, Unit unit,
-            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
-        return dispatch(commandBuilder.georadius(key, longitude, latitude, distance, unit.name(), geoRadiusStoreArgs));
-    }
-
-    @Override
-    public RedisFuture<Set<V>> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit) {
-        return dispatch(commandBuilder.georadiusbymember(GEORADIUSBYMEMBER, key, member, distance, unit.name()));
-    }
-
-    protected RedisFuture<Set<V>> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit) {
-        return dispatch(commandBuilder.georadiusbymember(GEORADIUSBYMEMBER_RO, key, member, distance, unit.name()));
-    }
-
-    @Override
-    public RedisFuture<List<GeoWithin<V>>> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit,
-            GeoArgs geoArgs) {
-        return dispatch(commandBuilder.georadiusbymember(GEORADIUSBYMEMBER, key, member, distance, unit.name(), geoArgs));
-    }
-
-    protected RedisFuture<List<GeoWithin<V>>> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit,
-            GeoArgs geoArgs) {
-        return dispatch(commandBuilder.georadiusbymember(GEORADIUSBYMEMBER_RO, key, member, distance, unit.name(), geoArgs));
-    }
-
-    @Override
-    public RedisFuture<Long> georadiusbymember(K key, V member, double distance, Unit unit,
-            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
-        return dispatch(commandBuilder.georadiusbymember(key, member, distance, unit.name(), geoRadiusStoreArgs));
-    }
-
-    @Override
-    public RedisFuture<List<GeoCoordinates>> geopos(K key, V... members) {
-        return dispatch(commandBuilder.geopos(key, members));
-    }
-
-    @Override
-    public RedisFuture<Double> geodist(K key, V from, V to, GeoArgs.Unit unit) {
-        return dispatch(commandBuilder.geodist(key, from, to, unit));
-    }
-
-    @Override
-    public <T> RedisFuture<T> dispatch(ProtocolKeyword type, CommandOutput<K, V, T> output) {
-
-        LettuceAssert.notNull(type, "Command type must not be null");
-        LettuceAssert.notNull(output, "CommandOutput type must not be null");
-
-        return dispatch(new AsyncCommand<>(new Command<>(type, output)));
-    }
-
-    @Override
-    public <T> RedisFuture<T> dispatch(ProtocolKeyword type, CommandOutput<K, V, T> output, CommandArgs<K, V> args) {
-
-        LettuceAssert.notNull(type, "Command type must not be null");
-        LettuceAssert.notNull(output, "CommandOutput type must not be null");
-        LettuceAssert.notNull(args, "CommandArgs type must not be null");
-
-        return dispatch(new AsyncCommand<>(new Command<>(type, output, args)));
-    }
-
-    protected <T> RedisFuture<T> dispatch(CommandType type, CommandOutput<K, V, T> output) {
-        return dispatch(type, output, null);
-    }
-
-    protected <T> RedisFuture<T> dispatch(CommandType type, CommandOutput<K, V, T> output, CommandArgs<K, V> args) {
-        return dispatch(new AsyncCommand<>(new Command<>(type, output, args)));
-    }
-
-    public <T> AsyncCommand<K, V, T> dispatch(RedisCommand<K, V, T> cmd) {
-        AsyncCommand<K, V, T> asyncCommand = new AsyncCommand<>(cmd);
-        RedisCommand<K, V, T> dispatched = connection.dispatch(asyncCommand);
-        if (dispatched instanceof AsyncCommand) {
-            return (AsyncCommand<K, V, T>) dispatched;
-        }
-        return asyncCommand;
-    }
-
-    public void setTimeout(long timeout, TimeUnit unit) {
-        connection.setTimeout(timeout, unit);
-    }
-
-    @Override
-    public void close() {
-        connection.close();
-    }
-
-    @Override
-    public boolean isOpen() {
-        return connection.isOpen();
-    }
-
-    @Override
-    public void reset() {
-        getConnection().reset();
-    }
-
-    public StatefulConnection<K, V> getConnection() {
-        return connection;
-    }
-
-    @Override
-    public void setAutoFlushCommands(boolean autoFlush) {
-        connection.setAutoFlushCommands(autoFlush);
-    }
-
-    @Override
-    public void flushCommands() {
-        connection.flushCommands();
+    public RedisFuture<Long> zunionstore(K destination, ZStoreArgs storeArgs, K... keys) {
+        return dispatch(commandBuilder.zunionstore(destination, storeArgs, keys));
     }
 }
diff --git a/src/main/java/com/lambdaworks/redis/AbstractRedisReactiveCommands.java b/src/main/java/com/lambdaworks/redis/AbstractRedisReactiveCommands.java
index b70180ee68..5044b34373 100644
--- a/src/main/java/com/lambdaworks/redis/AbstractRedisReactiveCommands.java
+++ b/src/main/java/com/lambdaworks/redis/AbstractRedisReactiveCommands.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2016 the original author or authors.
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -48,10 +48,10 @@ public abstract class AbstractRedisReactiveCommands<K, V> implements RedisHashRe
         RedisServerReactiveCommands<K, V>, RedisHLLReactiveCommands<K, V>, BaseRedisReactiveCommands<K, V>,
         RedisTransactionalReactiveCommands<K, V>, RedisGeoReactiveCommands<K, V>, RedisClusterReactiveCommands<K, V> {
 
-    protected MultiOutput<K, V> multi;
-    protected RedisCommandBuilder<K, V> commandBuilder;
-    protected RedisCodec<K, V> codec;
     protected StatefulConnection<K, V> connection;
+    protected RedisCodec<K, V> codec;
+    protected RedisCommandBuilder<K, V> commandBuilder;
+    protected MultiOutput<K, V> multi;
 
     /**
      * Initialize a new instance.
@@ -70,10 +70,14 @@ public Observable<Long> append(K key, V value) {
         return createObservable(() -> commandBuilder.append(key, value));
     }
 
+    @Override
+    public Observable<String> asking() {
+        return createObservable(commandBuilder::asking);
+    }
+
     @Override
     public Observable<String> auth(String password) {
         return createObservable(() -> commandBuilder.auth(password));
-
     }
 
     @Override
@@ -101,16 +105,6 @@ public Observable<Long> bitfield(K key, BitFieldArgs args) {
         return createDissolvingObservable(() -> commandBuilder.bitfield(key, args));
     }
 
-    @Override
-    public Observable<Long> bitpos(K key, boolean state) {
-        return createObservable(() -> commandBuilder.bitpos(key, state));
-    }
-
-    @Override
-    public Observable<Long> bitpos(K key, boolean state, long start, long end) {
-        return createObservable(() -> commandBuilder.bitpos(key, state, start, end));
-    }
-
     @Override
     public Observable<Long> bitopAnd(K destination, K... keys) {
         return createObservable(() -> commandBuilder.bitopAnd(destination, keys));
@@ -131,6 +125,16 @@ public Observable<Long> bitopXor(K destination, K... keys) {
         return createObservable(() -> commandBuilder.bitopXor(destination, keys));
     }
 
+    @Override
+    public Observable<Long> bitpos(K key, boolean state) {
+        return createObservable(() -> commandBuilder.bitpos(key, state));
+    }
+
+    @Override
+    public Observable<Long> bitpos(K key, boolean state, long start, long end) {
+        return createObservable(() -> commandBuilder.bitpos(key, state, start, end));
+    }
+
     @Override
     public Observable<KeyValue<K, V>> blpop(long timeout, K... keys) {
         return createObservable(() -> commandBuilder.blpop(timeout, keys));
@@ -151,11 +155,6 @@ public Observable<K> clientGetname() {
         return createObservable(commandBuilder::clientGetname);
     }
 
-    @Override
-    public Observable<String> clientSetname(K name) {
-        return createObservable(() -> commandBuilder.clientSetname(name));
-    }
-
     @Override
     public Observable<String> clientKill(String addr) {
         return createObservable(() -> commandBuilder.clientKill(addr));
@@ -166,14 +165,144 @@ public Observable<Long> clientKill(KillArgs killArgs) {
         return createObservable(() -> commandBuilder.clientKill(killArgs));
     }
 
+    @Override
+    public Observable<String> clientList() {
+        return createObservable(commandBuilder::clientList);
+    }
+
     @Override
     public Observable<String> clientPause(long timeout) {
         return createObservable(() -> commandBuilder.clientPause(timeout));
     }
 
     @Override
-    public Observable<String> clientList() {
-        return createObservable(commandBuilder::clientList);
+    public Observable<String> clientSetname(K name) {
+        return createObservable(() -> commandBuilder.clientSetname(name));
+    }
+
+    @Override
+    public void close() {
+        connection.close();
+    }
+
+    @Override
+    public Observable<String> clusterAddSlots(int... slots) {
+        return createObservable(() -> commandBuilder.clusterAddslots(slots));
+    }
+
+    @Override
+    public Observable<String> clusterBumpepoch() {
+        return createObservable(() -> commandBuilder.clusterBumpepoch());
+    }
+
+    @Override
+    public Observable<Long> clusterCountFailureReports(String nodeId) {
+        return createObservable(() -> commandBuilder.clusterCountFailureReports(nodeId));
+    }
+
+    @Override
+    public Observable<Long> clusterCountKeysInSlot(int slot) {
+        return createObservable(() -> commandBuilder.clusterCountKeysInSlot(slot));
+    }
+
+    @Override
+    public Observable<String> clusterDelSlots(int... slots) {
+        return createObservable(() -> commandBuilder.clusterDelslots(slots));
+    }
+
+    @Override
+    public Observable<String> clusterFailover(boolean force) {
+        return createObservable(() -> commandBuilder.clusterFailover(force));
+    }
+
+    @Override
+    public Observable<String> clusterFlushslots() {
+        return createObservable(commandBuilder::clusterFlushslots);
+    }
+
+    @Override
+    public Observable<String> clusterForget(String nodeId) {
+        return createObservable(() -> commandBuilder.clusterForget(nodeId));
+    }
+
+    @Override
+    public Observable<K> clusterGetKeysInSlot(int slot, int count) {
+        return createDissolvingObservable(() -> commandBuilder.clusterGetKeysInSlot(slot, count));
+    }
+
+    @Override
+    public Observable<String> clusterInfo() {
+        return createObservable(commandBuilder::clusterInfo);
+    }
+
+    @Override
+    public Observable<Long> clusterKeyslot(K key) {
+        return createObservable(() -> commandBuilder.clusterKeyslot(key));
+    }
+
+    @Override
+    public Observable<String> clusterMeet(String ip, int port) {
+        return createObservable(() -> commandBuilder.clusterMeet(ip, port));
+    }
+
+    @Override
+    public Observable<String> clusterMyId() {
+        return createObservable(commandBuilder::clusterMyId);
+    }
+
+    @Override
+    public Observable<String> clusterNodes() {
+        return createObservable(commandBuilder::clusterNodes);
+    }
+
+    @Override
+    public Observable<String> clusterReplicate(String nodeId) {
+        return createObservable(() -> commandBuilder.clusterReplicate(nodeId));
+    }
+
+    @Override
+    public Observable<String> clusterReset(boolean hard) {
+        return createObservable(() -> commandBuilder.clusterReset(hard));
+    }
+
+    @Override
+    public Observable<String> clusterSaveconfig() {
+        return createObservable(() -> commandBuilder.clusterSaveconfig());
+    }
+
+    @Override
+    public Observable<String> clusterSetConfigEpoch(long configEpoch) {
+        return createObservable(() -> commandBuilder.clusterSetConfigEpoch(configEpoch));
+    }
+
+    @Override
+    public Observable<String> clusterSetSlotImporting(int slot, String nodeId) {
+        return createObservable(() -> commandBuilder.clusterSetSlotImporting(slot, nodeId));
+    }
+
+    @Override
+    public Observable<String> clusterSetSlotMigrating(int slot, String nodeId) {
+        return createObservable(() -> commandBuilder.clusterSetSlotMigrating(slot, nodeId));
+    }
+
+    @Override
+    public Observable<String> clusterSetSlotNode(int slot, String nodeId) {
+        return createObservable(() -> commandBuilder.clusterSetSlotNode(slot, nodeId));
+    }
+
+    @Override
+    public Observable<String> clusterSetSlotStable(int slot) {
+        return createObservable(() -> commandBuilder.clusterSetSlotStable(slot));
+    }
+
+    @Override
+    public Observable<String> clusterSlaves(String nodeId) {
+        return createDissolvingObservable(() -> commandBuilder.clusterSlaves(nodeId));
+    }
+
+    @Override
+    public Observable<Object> clusterSlots() {
+        return createDissolvingObservable(commandBuilder::clusterSlots);
     }
 
     @Override
@@ -181,6 +310,11 @@ public Observable<Object> command() {
         return createDissolvingObservable(commandBuilder::command);
     }
 
+    @Override
+    public Observable<Long> commandCount() {
+        return createObservable(commandBuilder::commandCount);
+    }
+
     @Override
     public Observable<Object> commandInfo(String... commands) {
         return createDissolvingObservable(() -> commandBuilder.commandInfo(commands));
@@ -196,11 +330,6 @@ public Observable<Object> commandInfo(CommandType... commands) {
         return commandInfo(stringCommands);
     }
 
-    @Override
-    public Observable<Long> commandCount() {
-        return createObservable(commandBuilder::commandCount);
-    }
-
     @Override
     public Observable<String> configGet(String parameter) {
         return createDissolvingObservable(() -> commandBuilder.configGet(parameter));
@@ -211,14 +340,33 @@ public Observable<String> configResetstat() {
         return createObservable(commandBuilder::configResetstat);
     }
 
+    @Override
+    public Observable<String> configRewrite() {
+        return createObservable(commandBuilder::configRewrite);
+    }
+
     @Override
     public Observable<String> configSet(String parameter, String value) {
         return createObservable(() -> commandBuilder.configSet(parameter, value));
     }
 
-    @Override
-    public Observable<String> configRewrite() {
-        return createObservable(commandBuilder::configRewrite);
+    @SuppressWarnings("unchecked")
+    public <T, R> R createDissolvingObservable(Supplier<RedisCommand<K, V, T>> commandSupplier) {
+        return (R) Observable.create(new ReactiveCommandDispatcher<>(commandSupplier, connection, true));
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T, R> R createDissolvingObservable(CommandType type, CommandOutput<K, V, T> output, CommandArgs<K, V> args) {
+        return (R) Observable
+                .create(new ReactiveCommandDispatcher<>(() -> new Command<>(type, output, args), connection, true));
+    }
+
+    protected <T> Observable<T> createObservable(CommandType type, CommandOutput<K, V, T> output, CommandArgs<K, V> args) {
+        return createObservable(() -> new Command<>(type, output, args));
+    }
+
+    public <T> Observable<T> createObservable(Supplier<RedisCommand<K, V, T>> commandSupplier) {
+        return Observable.create(new ReactiveCommandDispatcher<>(commandSupplier, connection, false));
     }
 
     @Override
@@ -286,12 +434,8 @@ public Observable<Long> del(Iterable<K> keys) {
     }
 
     @Override
-    public Observable<Long> unlink(K... keys) {
-        return createObservable(() -> commandBuilder.unlink(keys));
-    }
-
-    public Observable<Long> unlink(Iterable<K> keys) {
-        return createObservable(() -> commandBuilder.unlink(keys));
+    public String digest(V script) {
+        return LettuceStrings.digest(codec.encodeValue(script));
     }
 
     @Override
@@ -299,6 +443,25 @@ public Observable<String> discard() {
         return createObservable(commandBuilder::discard);
     }
 
+    @Override
+    public <T> Observable<T> dispatch(ProtocolKeyword type, CommandOutput<K, V, ?> output) {
+
+        LettuceAssert.notNull(type, "Command type must not be null");
+        LettuceAssert.notNull(output, "CommandOutput type must not be null");
+
+        return createDissolvingObservable(() -> new Command<>(type, output));
+    }
+
+    @Override
+    public <T> Observable<T> dispatch(ProtocolKeyword type, CommandOutput<K, V, ?> output, CommandArgs<K, V> args) {
+
+        LettuceAssert.notNull(type, "Command type must not be null");
+        LettuceAssert.notNull(output, "CommandOutput type must not be null");
+        LettuceAssert.notNull(args, "CommandArgs type must not be null");
+
+        return createDissolvingObservable(() -> new Command<>(type, output, args));
+    }
+
     @Override
     public Observable<byte[]> dump(K key) {
         return createObservable(() -> commandBuilder.dump(key));
@@ -333,6 +496,11 @@ public <T> Observable<T> evalsha(String digest, ScriptOutputType type, K[] keys,
         return (Observable<T>) createObservable(() -> commandBuilder.evalsha(digest, type, keys, values));
     }
 
+    @Override
+    public Observable<Object> exec() {
+        return createDissolvingObservable(EXEC, null, null);
+    }
+
     public Observable<Boolean> exists(K key) {
         return createObservable(() -> commandBuilder.exists(key));
     }
@@ -361,11 +529,6 @@ public Observable<Boolean> expireat(K key, Date timestamp) {
         return expireat(key, timestamp.getTime() / 1000);
     }
 
-    @Override
-    public Observable<Object> exec() {
-        return createDissolvingObservable(EXEC, null, null);
-    }
-
     @Override
     public Observable<String> flushall() {
         return createObservable(commandBuilder::flushall);
@@ -387,23 +550,145 @@ public Observable<String> flushdbAsync() {
     }
 
     @Override
-    public Observable<V> get(K key) {
-        return createObservable(() -> commandBuilder.get(key));
+    public Observable<Long> geoadd(K key, double longitude, double latitude, V member) {
+        return createObservable(() -> commandBuilder.geoadd(key, longitude, latitude, member));
     }
 
     @Override
-    public Observable<Long> getbit(K key, long offset) {
-        return createObservable(() -> commandBuilder.getbit(key, offset));
+    public Observable<Long> geoadd(K key, Object... lngLatMember) {
+        return createDissolvingObservable(() -> commandBuilder.geoadd(key, lngLatMember));
     }
 
     @Override
-    public Observable<V> getrange(K key, long start, long end) {
-        return createObservable(() -> commandBuilder.getrange(key, start, end));
+    public Observable<Double> geodist(K key, V from, V to, GeoArgs.Unit unit) {
+        return createDissolvingObservable(() -> commandBuilder.geodist(key, from, to, unit));
     }
 
     @Override
-    public Observable<V> getset(K key, V value) {
-        return createObservable(() -> commandBuilder.getset(key, value));
+    public Observable<String> geohash(K key, V... members) {
+        return createDissolvingObservable(() -> commandBuilder.geohash(key, members));
+    }
+
+    @Override
+    public Observable<GeoCoordinates> geopos(K key, V... members) {
+        return createDissolvingObservable(() -> commandBuilder.geopos(key, members));
+    }
+
+    @Override
+    public Observable<V> georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit) {
+        return createDissolvingObservable(() -> commandBuilder.georadius(GEORADIUS, key, longitude, latitude, distance,
+                unit.name()));
+    }
+
+    @Override
+    public Observable<GeoWithin<V>> georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit,
+            GeoArgs geoArgs) {
+        return createDissolvingObservable(() -> commandBuilder.georadius(GEORADIUS, key, longitude, latitude, distance,
+                unit.name(), geoArgs));
+    }
+
+    @Override
+    public Observable<Long> georadius(K key, double longitude, double latitude, double distance, Unit unit,
+            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
+        return createDissolvingObservable(() -> commandBuilder.georadius(key, longitude, latitude, distance, unit.name(),
+                geoRadiusStoreArgs));
+    }
+
+    protected Observable<V> georadius_ro(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit) {
+        return createDissolvingObservable(() -> commandBuilder.georadius(GEORADIUS_RO, key, longitude, latitude, distance,
+                unit.name()));
+    }
+
+    protected Observable<GeoWithin<V>> georadius_ro(K key, double longitude, double latitude, double distance,
+            GeoArgs.Unit unit, GeoArgs geoArgs) {
+        return createDissolvingObservable(() -> commandBuilder.georadius(GEORADIUS_RO, key, longitude, latitude, distance,
+                unit.name(), geoArgs));
+    }
+
+    @Override
+    public Observable<V> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit) {
+        return createDissolvingObservable(() -> commandBuilder.georadiusbymember(GEORADIUSBYMEMBER, key, member, distance,
+                unit.name()));
+    }
+
+    @Override
+    public Observable<GeoWithin<V>> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs) {
+        return createDissolvingObservable(() -> commandBuilder.georadiusbymember(GEORADIUSBYMEMBER, key, member, distance,
+                unit.name(), geoArgs));
+    }
+
+    @Override
+    public Observable<Long> georadiusbymember(K key, V member, double distance, Unit unit,
+            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
+        return createDissolvingObservable(() -> commandBuilder.georadiusbymember(key, member, distance, unit.name(),
+                geoRadiusStoreArgs));
+    }
+
+    protected Observable<V> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit) {
+        return createDissolvingObservable(() -> commandBuilder.georadiusbymember(GEORADIUSBYMEMBER_RO, key, member, distance,
+                unit.name()));
+    }
+
+    protected Observable<GeoWithin<V>> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs) {
+        return createDissolvingObservable(() -> commandBuilder.georadiusbymember(GEORADIUSBYMEMBER_RO, key, member, distance,
+                unit.name(), geoArgs));
+    }
+
+    @Override
+    public Observable<V> get(K key) {
+        return createObservable(() -> commandBuilder.get(key));
+    }
+
+    public StatefulConnection<K, V> getConnection() {
+        return connection;
+    }
+
+    /**
+     * Emits just {@link Success#Success} or the {@link Throwable} after the inner observable is completed.
+     *
+     * @param observable inner observable
+     * @param <T> used for type inference
+     * @return Success observable
+     */
+    protected <T> Observable<Success> getSuccessObservable(final Observable<T> observable) {
+        return Observable.create(new Observable.OnSubscribe<Success>() {
+            @Override
+            public void call(Subscriber<? super Success> subscriber) {
+
+                observable.subscribe(new Subscriber<Object>() {
+                    @Override
+                    public void onCompleted() {
+                        subscriber.onNext(Success.Success);
+                        subscriber.onCompleted();
+                    }
+
+                    @Override
+                    public void onError(Throwable throwable) {
+                        subscriber.onError(throwable);
+                    }
+
+                    @Override
+                    public void onNext(Object k) {
+
+                    }
+                });
+            }
+        });
+    }
+
+    @Override
+    public Observable<Long> getbit(K key, long offset) {
+        return createObservable(() -> commandBuilder.getbit(key, offset));
+    }
+
+    @Override
+    public Observable<V> getrange(K key, long start, long end) {
+        return createObservable(() -> commandBuilder.getrange(key, start, end));
+    }
+
+    @Override
+    public Observable<V> getset(K key, V value) {
+        return createObservable(() -> commandBuilder.getset(key, value));
     }
 
     @Override
@@ -422,23 +707,23 @@ public Observable<V> hget(K key, K field) {
     }
 
     @Override
-    public Observable<Long> hincrby(K key, K field, long amount) {
-        return createObservable(() -> commandBuilder.hincrby(key, field, amount));
+    public Observable<Map<K, V>> hgetall(K key) {
+        return createObservable(() -> commandBuilder.hgetall(key));
     }
 
     @Override
-    public Observable<Double> hincrbyfloat(K key, K field, double amount) {
-        return createObservable(() -> commandBuilder.hincrbyfloat(key, field, amount));
+    public Observable<Long> hgetall(KeyValueStreamingChannel<K, V> channel, K key) {
+        return createObservable(() -> commandBuilder.hgetall(channel, key));
     }
 
     @Override
-    public Observable<Map<K, V>> hgetall(K key) {
-        return createObservable(() -> commandBuilder.hgetall(key));
+    public Observable<Long> hincrby(K key, K field, long amount) {
+        return createObservable(() -> commandBuilder.hincrby(key, field, amount));
     }
 
     @Override
-    public Observable<Long> hgetall(KeyValueStreamingChannel<K, V> channel, K key) {
-        return createObservable(() -> commandBuilder.hgetall(channel, key));
+    public Observable<Double> hincrbyfloat(K key, K field, double amount) {
+        return createObservable(() -> commandBuilder.hincrbyfloat(key, field, amount));
     }
 
     @Override
@@ -456,11 +741,6 @@ public Observable<Long> hlen(K key) {
         return createObservable(() -> commandBuilder.hlen(key));
     }
 
-    @Override
-    public Observable<Long> hstrlen(K key, K field) {
-        return createObservable(() -> commandBuilder.hstrlen(key, field));
-    }
-
     @Override
     public Observable<V> hmget(K key, K... fields) {
         return createDissolvingObservable(() -> commandBuilder.hmget(key, fields));
@@ -476,6 +756,47 @@ public Observable<String> hmset(K key, Map<K, V> map) {
         return createObservable(() -> commandBuilder.hmset(key, map));
     }
 
+    @Override
+    public Observable<MapScanCursor<K, V>> hscan(K key) {
+        return createObservable(() -> commandBuilder.hscan(key));
+    }
+
+    @Override
+    public Observable<MapScanCursor<K, V>> hscan(K key, ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.hscan(key, scanArgs));
+    }
+
+    @Override
+    public Observable<MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.hscan(key, scanCursor, scanArgs));
+    }
+
+    @Override
+    public Observable<MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor) {
+        return createObservable(() -> commandBuilder.hscan(key, scanCursor));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key) {
+        return createObservable(() -> commandBuilder.hscanStreaming(channel, key));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.hscanStreaming(channel, key, scanArgs));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor,
+            ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.hscanStreaming(channel, key, scanCursor, scanArgs));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor) {
+        return createObservable(() -> commandBuilder.hscanStreaming(channel, key, scanCursor));
+    }
+
     @Override
     public Observable<Boolean> hset(K key, K field, V value) {
         return createObservable(() -> commandBuilder.hset(key, field, value));
@@ -486,6 +807,11 @@ public Observable<Boolean> hsetnx(K key, K field, V value) {
         return createObservable(() -> commandBuilder.hsetnx(key, field, value));
     }
 
+    @Override
+    public Observable<Long> hstrlen(K key, K field) {
+        return createObservable(() -> commandBuilder.hstrlen(key, field));
+    }
+
     @Override
     public Observable<V> hvals(K key) {
         return createDissolvingObservable(() -> commandBuilder.hvals(key));
@@ -521,6 +847,11 @@ public Observable<String> info(String section) {
         return createObservable(() -> commandBuilder.info(section));
     }
 
+    @Override
+    public boolean isOpen() {
+        return connection.isOpen();
+    }
+
     @Override
     public Observable<K> keys(K pattern) {
         return createDissolvingObservable(() -> commandBuilder.keys(pattern));
@@ -596,16 +927,6 @@ public Observable<String> ltrim(K key, long start, long stop) {
         return createObservable(() -> commandBuilder.ltrim(key, start, stop));
     }
 
-    @Override
-    public Observable<String> migrate(String host, int port, K key, int db, long timeout) {
-        return createObservable(() -> commandBuilder.migrate(host, port, key, db, timeout));
-    }
-
-    @Override
-    public Observable<String> migrate(String host, int port, int db, long timeout, MigrateArgs<K> migrateArgs) {
-        return createObservable(() -> commandBuilder.migrate(host, port, db, timeout, migrateArgs));
-    }
-
     @Override
     public Observable<V> mget(K... keys) {
         return createDissolvingObservable(() -> commandBuilder.mget(keys));
@@ -625,13 +946,18 @@ public Observable<Long> mget(ValueStreamingChannel<V> channel, Iterable<K> keys)
     }
 
     @Override
-    public Observable<Boolean> move(K key, int db) {
-        return createObservable(() -> commandBuilder.move(key, db));
+    public Observable<String> migrate(String host, int port, K key, int db, long timeout) {
+        return createObservable(() -> commandBuilder.migrate(host, port, key, db, timeout));
     }
 
     @Override
-    public Observable<String> multi() {
-        return createObservable(commandBuilder::multi);
+    public Observable<String> migrate(String host, int port, int db, long timeout, MigrateArgs<K> migrateArgs) {
+        return createObservable(() -> commandBuilder.migrate(host, port, db, timeout, migrateArgs));
+    }
+
+    @Override
+    public Observable<Boolean> move(K key, int db) {
+        return createObservable(() -> commandBuilder.move(key, db));
     }
 
     @Override
@@ -644,6 +970,11 @@ public Observable<Boolean> msetnx(Map<K, V> map) {
         return createObservable(() -> commandBuilder.msetnx(map));
     }
 
+    @Override
+    public Observable<String> multi() {
+        return createObservable(commandBuilder::multi);
+    }
+
     @Override
     public Observable<String> objectEncoding(K key) {
         return createObservable(() -> commandBuilder.objectEncoding(key));
@@ -680,18 +1011,40 @@ public Observable<Boolean> pexpireat(K key, long timestamp) {
     }
 
     @Override
-    public Observable<String> ping() {
-        return createObservable(commandBuilder::ping);
+    public Observable<Long> pfadd(K key, V... values) {
+        return createObservable(() -> commandBuilder.pfadd(key, values));
+    }
+
+    public Observable<Long> pfadd(K key, V value, V... values) {
+        return createObservable(() -> commandBuilder.pfadd(key, value, values));
     }
 
     @Override
-    public Observable<String> readOnly() {
-        return createObservable(commandBuilder::readOnly);
+    public Observable<Long> pfcount(K... keys) {
+        return createObservable(() -> commandBuilder.pfcount(keys));
+    }
+
+    public Observable<Long> pfcount(K key, K... keys) {
+        return createObservable(() -> commandBuilder.pfcount(key, keys));
     }
 
     @Override
-    public Observable<String> readWrite() {
-        return createObservable(commandBuilder::readWrite);
+    public Observable<String> pfmerge(K destkey, K... sourcekeys) {
+        return createObservable(() -> commandBuilder.pfmerge(destkey, sourcekeys));
+    }
+
+    public Observable<String> pfmerge(K destkey, K sourceKey, K... sourcekeys) {
+        return createObservable(() -> commandBuilder.pfmerge(destkey, sourceKey, sourcekeys));
+    }
+
+    @Override
+    public Observable<String> ping() {
+        return createObservable(commandBuilder::ping);
+    }
+
+    @Override
+    public Observable<String> psetex(K key, long milliseconds, V value) {
+        return createObservable(() -> commandBuilder.psetex(key, milliseconds, value));
     }
 
     @Override
@@ -715,13 +1068,13 @@ public Observable<K> pubsubChannels(K channel) {
     }
 
     @Override
-    public Observable<Map<K, Long>> pubsubNumsub(K... channels) {
-        return createObservable(() -> commandBuilder.pubsubNumsub(channels));
+    public Observable<Long> pubsubNumpat() {
+        return createObservable(commandBuilder::pubsubNumpat);
     }
 
     @Override
-    public Observable<Long> pubsubNumpat() {
-        return createObservable(commandBuilder::pubsubNumpat);
+    public Observable<Map<K, Long>> pubsubNumsub(K... channels) {
+        return createObservable(() -> commandBuilder.pubsubNumsub(channels));
     }
 
     @Override
@@ -730,13 +1083,18 @@ public Observable<String> quit() {
     }
 
     @Override
-    public Observable<Object> role() {
-        return createDissolvingObservable(commandBuilder::role);
+    public Observable<V> randomkey() {
+        return createObservable(commandBuilder::randomkey);
     }
 
     @Override
-    public Observable<V> randomkey() {
-        return createObservable(commandBuilder::randomkey);
+    public Observable<String> readOnly() {
+        return createObservable(commandBuilder::readOnly);
+    }
+
+    @Override
+    public Observable<String> readWrite() {
+        return createObservable(commandBuilder::readWrite);
     }
 
     @Override
@@ -749,11 +1107,21 @@ public Observable<Boolean> renamenx(K key, K newKey) {
         return createObservable(() -> commandBuilder.renamenx(key, newKey));
     }
 
+    @Override
+    public void reset() {
+        getConnection().reset();
+    }
+
     @Override
     public Observable<String> restore(K key, long ttl, byte[] value) {
         return createObservable(() -> commandBuilder.restore(key, ttl, value));
     }
 
+    @Override
+    public Observable<Object> role() {
+        return createDissolvingObservable(commandBuilder::role);
+    }
+
     @Override
     public Observable<V> rpop(K key) {
         return createObservable(() -> commandBuilder.rpop(key));
@@ -789,6 +1157,46 @@ public Observable<String> save() {
         return createObservable(commandBuilder::save);
     }
 
+    @Override
+    public Observable<KeyScanCursor<K>> scan() {
+        return createObservable(commandBuilder::scan);
+    }
+
+    @Override
+    public Observable<KeyScanCursor<K>> scan(ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.scan(scanArgs));
+    }
+
+    @Override
+    public Observable<KeyScanCursor<K>> scan(ScanCursor scanCursor, ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.scan(scanCursor, scanArgs));
+    }
+
+    @Override
+    public Observable<KeyScanCursor<K>> scan(ScanCursor scanCursor) {
+        return createObservable(() -> commandBuilder.scan(scanCursor));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> scan(KeyStreamingChannel<K> channel) {
+        return createObservable(() -> commandBuilder.scanStreaming(channel));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.scanStreaming(channel, scanArgs));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.scanStreaming(channel, scanCursor, scanArgs));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor) {
+        return createObservable(() -> commandBuilder.scanStreaming(channel, scanCursor));
+    }
+
     @Override
     public Observable<Long> scard(K key) {
         return createObservable(() -> commandBuilder.scard(key));
@@ -833,10 +1241,6 @@ public Observable<String> select(int db) {
         return createObservable(() -> commandBuilder.select(db));
     }
 
-    public Observable<String> swapdb(int db1, int db2) {
-        return createObservable(() -> commandBuilder.swapdb(db1, db2));
-    }
-
     @Override
     public Observable<String> set(K key, V value) {
         return createObservable(() -> commandBuilder.set(key, value));
@@ -847,6 +1251,11 @@ public Observable<String> set(K key, V value, SetArgs setArgs) {
         return createObservable(() -> commandBuilder.set(key, value, setArgs));
     }
 
+    @Override
+    public void setTimeout(long timeout, TimeUnit unit) {
+        connection.setTimeout(timeout, unit);
+    }
+
     @Override
     public Observable<Long> setbit(K key, long offset, int value) {
         return createObservable(() -> commandBuilder.setbit(key, offset, value));
@@ -857,11 +1266,6 @@ public Observable<String> setex(K key, long seconds, V value) {
         return createObservable(() -> commandBuilder.setex(key, seconds, value));
     }
 
-    @Override
-    public Observable<String> psetex(K key, long milliseconds, V value) {
-        return createObservable(() -> commandBuilder.psetex(key, milliseconds, value));
-    }
-
     @Override
     public Observable<Boolean> setnx(K key, V value) {
         return createObservable(() -> commandBuilder.setnx(key, value));
@@ -897,11 +1301,6 @@ public Observable<Boolean> sismember(K key, V member) {
         return createObservable(() -> commandBuilder.sismember(key, member));
     }
 
-    @Override
-    public Observable<Boolean> smove(K source, K destination, V member) {
-        return createObservable(() -> commandBuilder.smove(source, destination, member));
-    }
-
     @Override
     public Observable<String> slaveof(String host, int port) {
         return createObservable(() -> commandBuilder.slaveof(host, port));
@@ -942,6 +1341,11 @@ public Observable<Long> smembers(ValueStreamingChannel<V> channel, K key) {
         return createObservable(() -> commandBuilder.smembers(channel, key));
     }
 
+    @Override
+    public Observable<Boolean> smove(K source, K destination, V member) {
+        return createObservable(() -> commandBuilder.smove(source, destination, member));
+    }
+
     @Override
     public Observable<V> sort(K key) {
         return createDissolvingObservable(() -> commandBuilder.sort(key));
@@ -997,6 +1401,51 @@ public Observable<Long> srem(K key, V... members) {
         return createObservable(() -> commandBuilder.srem(key, members));
     }
 
+    @Override
+    public Observable<ValueScanCursor<V>> sscan(K key) {
+        return createObservable(() -> commandBuilder.sscan(key));
+    }
+
+    @Override
+    public Observable<ValueScanCursor<V>> sscan(K key, ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.sscan(key, scanArgs));
+    }
+
+    @Override
+    public Observable<ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.sscan(key, scanCursor, scanArgs));
+    }
+
+    @Override
+    public Observable<ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor) {
+        return createObservable(() -> commandBuilder.sscan(key, scanCursor));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key) {
+        return createObservable(() -> commandBuilder.sscanStreaming(channel, key));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.sscanStreaming(channel, key, scanArgs));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs) {
+        return createObservable(() -> commandBuilder.sscanStreaming(channel, key, scanCursor, scanArgs));
+    }
+
+    @Override
+    public Observable<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor) {
+        return createObservable(() -> commandBuilder.sscanStreaming(channel, key, scanCursor));
+    }
+
+    @Override
+    public Observable<Long> strlen(K key) {
+        return createObservable(() -> commandBuilder.strlen(key));
+    }
+
     @Override
     public Observable<V> sunion(K... keys) {
         return createDissolvingObservable(() -> commandBuilder.sunion(keys));
@@ -1012,14 +1461,18 @@ public Observable<Long> sunionstore(K destination, K... keys) {
         return createObservable(() -> commandBuilder.sunionstore(destination, keys));
     }
 
+    public Observable<String> swapdb(int db1, int db2) {
+        return createObservable(() -> commandBuilder.swapdb(db1, db2));
+    }
+
     @Override
     public Observable<String> sync() {
         return createObservable(commandBuilder::sync);
     }
 
     @Override
-    public Observable<Long> strlen(K key) {
-        return createObservable(() -> commandBuilder.strlen(key));
+    public Observable<V> time() {
+        return createDissolvingObservable(commandBuilder::time);
     }
 
     @Override
@@ -1042,8 +1495,12 @@ public Observable<String> type(K key) {
     }
 
     @Override
-    public Observable<String> watch(K... keys) {
-        return createObservable(() -> commandBuilder.watch(keys));
+    public Observable<Long> unlink(K... keys) {
+        return createObservable(() -> commandBuilder.unlink(keys));
+    }
+
+    public Observable<Long> unlink(Iterable<K> keys) {
+        return createObservable(() -> commandBuilder.unlink(keys));
     }
 
     @Override
@@ -1051,6 +1508,16 @@ public Observable<String> unwatch() {
         return createObservable(commandBuilder::unwatch);
     }
 
+    @Override
+    public Observable<Long> waitForReplication(int replicas, long timeout) {
+        return createObservable(() -> commandBuilder.wait(replicas, timeout));
+    }
+
+    @Override
+    public Observable<String> watch(K... keys) {
+        return createObservable(() -> commandBuilder.watch(keys));
+    }
+
     @Override
     public Observable<Long> zadd(K key, double score, V member) {
         return createObservable(() -> commandBuilder.zadd(key, null, score, member));
@@ -1127,83 +1594,83 @@ public Observable<Long> zinterstore(K destination, ZStoreArgs storeArgs, K... ke
     }
 
     @Override
-    public Observable<V> zrange(K key, long start, long stop) {
-        return createDissolvingObservable(() -> commandBuilder.zrange(key, start, stop));
+    public Observable<Long> zlexcount(K key, String min, String max) {
+        return createObservable(() -> commandBuilder.zlexcount(key, min, max));
     }
 
     @Override
-    public Observable<ScoredValue<V>> zrangeWithScores(K key, long start, long stop) {
-        return createDissolvingObservable(() -> commandBuilder.zrangeWithScores(key, start, stop));
+    public Observable<Long> zlexcount(K key, Range<? extends V> range) {
+        return createObservable(() -> commandBuilder.zlexcount(key, range));
     }
 
     @Override
-    public Observable<V> zrangebyscore(K key, double min, double max) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, min, max));
+    public Observable<V> zrange(K key, long start, long stop) {
+        return createDissolvingObservable(() -> commandBuilder.zrange(key, start, stop));
     }
 
     @Override
-    public Observable<V> zrangebyscore(K key, String min, String max) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, min, max));
+    public Observable<Long> zrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
+        return createObservable(() -> commandBuilder.zrange(channel, key, start, stop));
     }
 
     @Override
-    public Observable<V> zrangebyscore(K key, Range<? extends Number> range) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, range, Limit.unlimited()));
+    public Observable<ScoredValue<V>> zrangeWithScores(K key, long start, long stop) {
+        return createDissolvingObservable(() -> commandBuilder.zrangeWithScores(key, start, stop));
     }
 
     @Override
-    public Observable<V> zrangebyscore(K key, double min, double max, long offset, long count) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, min, max, offset, count));
+    public Observable<Long> zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
+        return createObservable(() -> commandBuilder.zrangeWithScores(channel, key, start, stop));
     }
 
     @Override
-    public Observable<V> zrangebyscore(K key, String min, String max, long offset, long count) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, min, max, offset, count));
+    public Observable<V> zrangebylex(K key, String min, String max) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebylex(key, min, max));
     }
 
     @Override
-    public Observable<V> zrangebyscore(K key, Range<? extends Number> range, Limit limit) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, range, limit));
+    public Observable<V> zrangebylex(K key, Range<? extends V> range) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebylex(key, range, Limit.unlimited()));
     }
 
     @Override
-    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, double min, double max) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, min, max));
+    public Observable<V> zrangebylex(K key, String min, String max, long offset, long count) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebylex(key, min, max, offset, count));
     }
 
     @Override
-    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, String min, String max) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, min, max));
+    public Observable<V> zrangebylex(K key, Range<? extends V> range, Limit limit) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebylex(key, range, limit));
     }
 
     @Override
-    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, Range<? extends Number> range) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, range, Limit.unlimited()));
+    public Observable<V> zrangebyscore(K key, double min, double max) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, min, max));
     }
 
     @Override
-    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, double min, double max, long offset, long count) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
+    public Observable<V> zrangebyscore(K key, String min, String max) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, min, max));
     }
 
     @Override
-    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, String min, String max, long offset, long count) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
+    public Observable<V> zrangebyscore(K key, Range<? extends Number> range) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, range, Limit.unlimited()));
     }
 
     @Override
-    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, range, limit));
+    public Observable<V> zrangebyscore(K key, double min, double max, long offset, long count) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, min, max, offset, count));
     }
 
     @Override
-    public Observable<Long> zrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
-        return createObservable(() -> commandBuilder.zrange(channel, key, start, stop));
+    public Observable<V> zrangebyscore(K key, String min, String max, long offset, long count) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, min, max, offset, count));
     }
 
     @Override
-    public Observable<Long> zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
-        return createObservable(() -> commandBuilder.zrangeWithScores(channel, key, start, stop));
+    public Observable<V> zrangebyscore(K key, Range<? extends Number> range, Limit limit) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscore(key, range, limit));
     }
 
     @Override
@@ -1239,48 +1706,88 @@ public Observable<Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, R
     }
 
     @Override
-    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max) {
-        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max));
+    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, double min, double max) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, min, max));
     }
 
     @Override
-    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max) {
-        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max));
+    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, String min, String max) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, min, max));
     }
 
     @Override
-    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range) {
-        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, range, Limit.unlimited()));
+    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, Range<? extends Number> range) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, range, Limit.unlimited()));
     }
 
     @Override
-    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max,
-            long offset, long count) {
-        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max, offset, count));
+    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, double min, double max, long offset, long count) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
     }
 
     @Override
-    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max,
-            long offset, long count) {
-        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max, offset, count));
+    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, String min, String max, long offset, long count) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, min, max, offset, count));
     }
 
     @Override
-    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range,
-            Limit limit) {
-        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, range, limit));
+    public Observable<ScoredValue<V>> zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
+        return createDissolvingObservable(() -> commandBuilder.zrangebyscoreWithScores(key, range, limit));
     }
 
     @Override
-    public Observable<Long> zrank(K key, V member) {
-        return createObservable(() -> commandBuilder.zrank(key, member));
-    }
+    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max) {
+        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max));
+    }
+
+    @Override
+    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max) {
+        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max));
+    }
+
+    @Override
+    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range) {
+        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, range, Limit.unlimited()));
+    }
+
+    @Override
+    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max,
+            long offset, long count) {
+        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max, offset, count));
+    }
+
+    @Override
+    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max,
+            long offset, long count) {
+        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, min, max, offset, count));
+    }
+
+    @Override
+    public Observable<Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key,
+            Range<? extends Number> range, Limit limit) {
+        return createObservable(() -> commandBuilder.zrangebyscoreWithScores(channel, key, range, limit));
+    }
+
+    @Override
+    public Observable<Long> zrank(K key, V member) {
+        return createObservable(() -> commandBuilder.zrank(key, member));
+    }
 
     @Override
     public Observable<Long> zrem(K key, V... members) {
         return createObservable(() -> commandBuilder.zrem(key, members));
     }
 
+    @Override
+    public Observable<Long> zremrangebylex(K key, String min, String max) {
+        return createObservable(() -> commandBuilder.zremrangebylex(key, min, max));
+    }
+
+    @Override
+    public Observable<Long> zremrangebylex(K key, Range<? extends V> range) {
+        return createObservable(() -> commandBuilder.zremrangebylex(key, range));
+    }
+
     @Override
     public Observable<Long> zremrangebyrank(K key, long start, long stop) {
         return createObservable(() -> commandBuilder.zremrangebyrank(key, start, stop));
@@ -1306,11 +1813,21 @@ public Observable<V> zrevrange(K key, long start, long stop) {
         return createDissolvingObservable(() -> commandBuilder.zrevrange(key, start, stop));
     }
 
+    @Override
+    public Observable<Long> zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
+        return createObservable(() -> commandBuilder.zrevrange(channel, key, start, stop));
+    }
+
     @Override
     public Observable<ScoredValue<V>> zrevrangeWithScores(K key, long start, long stop) {
         return createDissolvingObservable(() -> commandBuilder.zrevrangeWithScores(key, start, stop));
     }
 
+    @Override
+    public Observable<Long> zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
+        return createObservable(() -> commandBuilder.zrevrangeWithScores(channel, key, start, stop));
+    }
+
     @Override
     public Observable<V> zrevrangebylex(K key, Range<? extends V> range) {
         return createDissolvingObservable(() -> commandBuilder.zrevrangebylex(key, range, Limit.unlimited()));
@@ -1351,46 +1868,6 @@ public Observable<V> zrevrangebyscore(K key, Range<? extends Number> range, Limi
         return createDissolvingObservable(() -> commandBuilder.zrevrangebyscore(key, range, limit));
     }
 
-    @Override
-    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, double max, double min) {
-        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min));
-    }
-
-    @Override
-    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, String max, String min) {
-        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min));
-    }
-
-    @Override
-    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range) {
-        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, range, Limit.unlimited()));
-    }
-
-    @Override
-    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count) {
-        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
-    }
-
-    @Override
-    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count) {
-        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
-    }
-
-    @Override
-    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
-        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, range, limit));
-    }
-
-    @Override
-    public Observable<Long> zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
-        return createObservable(() -> commandBuilder.zrevrange(channel, key, start, stop));
-    }
-
-    @Override
-    public Observable<Long> zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
-        return createObservable(() -> commandBuilder.zrevrangeWithScores(channel, key, start, stop));
-    }
-
     @Override
     public Observable<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min) {
         return createObservable(() -> commandBuilder.zrevrangebyscore(channel, key, max, min));
@@ -1424,177 +1901,72 @@ public Observable<Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key
     }
 
     @Override
-    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min) {
-        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min));
-    }
-
-    @Override
-    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min) {
-        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min));
-    }
-
-    @Override
-    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range) {
-        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, range, Limit.unlimited()));
-    }
-
-    @Override
-    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min,
-            long offset, long count) {
-        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min, offset, count));
-    }
-
-    @Override
-    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min,
-            long offset, long count) {
-        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min, offset, count));
-    }
-
-    @Override
-    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, Range<? extends Number> range,
-            Limit limit) {
-        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, range, limit));
-    }
-
-    @Override
-    public Observable<Long> zrevrank(K key, V member) {
-        return createObservable(() -> commandBuilder.zrevrank(key, member));
-    }
-
-    @Override
-    public Observable<Double> zscore(K key, V member) {
-        return createObservable(() -> commandBuilder.zscore(key, member));
-    }
-
-    @Override
-    public Observable<Long> zunionstore(K destination, K... keys) {
-        return createObservable(() -> commandBuilder.zunionstore(destination, keys));
-    }
-
-    @Override
-    public Observable<Long> zunionstore(K destination, ZStoreArgs storeArgs, K... keys) {
-        return createObservable(() -> commandBuilder.zunionstore(destination, storeArgs, keys));
-    }
-
-    @Override
-    public Observable<KeyScanCursor<K>> scan() {
-        return createObservable(commandBuilder::scan);
-    }
-
-    @Override
-    public Observable<KeyScanCursor<K>> scan(ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.scan(scanArgs));
-    }
-
-    @Override
-    public Observable<KeyScanCursor<K>> scan(ScanCursor scanCursor, ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.scan(scanCursor, scanArgs));
-    }
-
-    @Override
-    public Observable<KeyScanCursor<K>> scan(ScanCursor scanCursor) {
-        return createObservable(() -> commandBuilder.scan(scanCursor));
-    }
-
-    @Override
-    public Observable<StreamScanCursor> scan(KeyStreamingChannel<K> channel) {
-        return createObservable(() -> commandBuilder.scanStreaming(channel));
-    }
-
-    @Override
-    public Observable<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.scanStreaming(channel, scanArgs));
-    }
-
-    @Override
-    public Observable<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.scanStreaming(channel, scanCursor, scanArgs));
-    }
-
-    @Override
-    public Observable<StreamScanCursor> scan(KeyStreamingChannel<K> channel, ScanCursor scanCursor) {
-        return createObservable(() -> commandBuilder.scanStreaming(channel, scanCursor));
-    }
-
-    @Override
-    public Observable<ValueScanCursor<V>> sscan(K key) {
-        return createObservable(() -> commandBuilder.sscan(key));
-    }
-
-    @Override
-    public Observable<ValueScanCursor<V>> sscan(K key, ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.sscan(key, scanArgs));
-    }
-
-    @Override
-    public Observable<ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.sscan(key, scanCursor, scanArgs));
-    }
-
-    @Override
-    public Observable<ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor) {
-        return createObservable(() -> commandBuilder.sscan(key, scanCursor));
+    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, double max, double min) {
+        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min));
     }
 
     @Override
-    public Observable<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key) {
-        return createObservable(() -> commandBuilder.sscanStreaming(channel, key));
+    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, String max, String min) {
+        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min));
     }
 
     @Override
-    public Observable<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.sscanStreaming(channel, key, scanArgs));
+    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range) {
+        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, range, Limit.unlimited()));
     }
 
     @Override
-    public Observable<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor, ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.sscanStreaming(channel, key, scanCursor, scanArgs));
+    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count) {
+        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
     }
 
     @Override
-    public Observable<StreamScanCursor> sscan(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor) {
-        return createObservable(() -> commandBuilder.sscanStreaming(channel, key, scanCursor));
+    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count) {
+        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, max, min, offset, count));
     }
 
     @Override
-    public Observable<MapScanCursor<K, V>> hscan(K key) {
-        return createObservable(() -> commandBuilder.hscan(key));
+    public Observable<ScoredValue<V>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
+        return createDissolvingObservable(() -> commandBuilder.zrevrangebyscoreWithScores(key, range, limit));
     }
 
     @Override
-    public Observable<MapScanCursor<K, V>> hscan(K key, ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.hscan(key, scanArgs));
+    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min) {
+        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min));
     }
 
     @Override
-    public Observable<MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.hscan(key, scanCursor, scanArgs));
+    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min) {
+        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min));
     }
 
     @Override
-    public Observable<MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor) {
-        return createObservable(() -> commandBuilder.hscan(key, scanCursor));
+    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key,
+            Range<? extends Number> range) {
+        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, range, Limit.unlimited()));
     }
 
     @Override
-    public Observable<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key) {
-        return createObservable(() -> commandBuilder.hscanStreaming(channel, key));
+    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min,
+            long offset, long count) {
+        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min, offset, count));
     }
 
     @Override
-    public Observable<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.hscanStreaming(channel, key, scanArgs));
+    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min,
+            long offset, long count) {
+        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, max, min, offset, count));
     }
 
     @Override
-    public Observable<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor,
-            ScanArgs scanArgs) {
-        return createObservable(() -> commandBuilder.hscanStreaming(channel, key, scanCursor, scanArgs));
+    public Observable<Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key,
+            Range<? extends Number> range, Limit limit) {
+        return createObservable(() -> commandBuilder.zrevrangebyscoreWithScores(channel, key, range, limit));
     }
 
     @Override
-    public Observable<StreamScanCursor> hscan(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor) {
-        return createObservable(() -> commandBuilder.hscanStreaming(channel, key, scanCursor));
+    public Observable<Long> zrevrank(K key, V member) {
+        return createObservable(() -> commandBuilder.zrevrank(key, member));
     }
 
     @Override
@@ -1639,390 +2011,17 @@ public Observable<StreamScanCursor> zscan(ScoredValueStreamingChannel<V> channel
     }
 
     @Override
-    public String digest(V script) {
-        return LettuceStrings.digest(codec.encodeValue(script));
+    public Observable<Double> zscore(K key, V member) {
+        return createObservable(() -> commandBuilder.zscore(key, member));
     }
 
     @Override
-    public Observable<V> time() {
-        return createDissolvingObservable(commandBuilder::time);
-    }
-
-    @Override
-    public Observable<Long> waitForReplication(int replicas, long timeout) {
-        return createObservable(() -> commandBuilder.wait(replicas, timeout));
-    }
-
-    @Override
-    public Observable<Long> pfadd(K key, V... values) {
-        return createObservable(() -> commandBuilder.pfadd(key, values));
-    }
-
-    public Observable<Long> pfadd(K key, V value, V... values) {
-        return createObservable(() -> commandBuilder.pfadd(key, value, values));
-    }
-
-    @Override
-    public Observable<String> pfmerge(K destkey, K... sourcekeys) {
-        return createObservable(() -> commandBuilder.pfmerge(destkey, sourcekeys));
-    }
-
-    public Observable<String> pfmerge(K destkey, K sourceKey, K... sourcekeys) {
-        return createObservable(() -> commandBuilder.pfmerge(destkey, sourceKey, sourcekeys));
-    }
-
-    @Override
-    public Observable<Long> pfcount(K... keys) {
-        return createObservable(() -> commandBuilder.pfcount(keys));
-    }
-
-    public Observable<Long> pfcount(K key, K... keys) {
-        return createObservable(() -> commandBuilder.pfcount(key, keys));
-    }
-
-    @Override
-    public Observable<String> clusterBumpepoch() {
-        return createObservable(() -> commandBuilder.clusterBumpepoch());
-    }
-
-    @Override
-    public Observable<String> clusterMeet(String ip, int port) {
-        return createObservable(() -> commandBuilder.clusterMeet(ip, port));
-    }
-
-    @Override
-    public Observable<String> clusterForget(String nodeId) {
-        return createObservable(() -> commandBuilder.clusterForget(nodeId));
-    }
-
-    @Override
-    public Observable<String> clusterAddSlots(int... slots) {
-        return createObservable(() -> commandBuilder.clusterAddslots(slots));
-    }
-
-    @Override
-    public Observable<String> clusterDelSlots(int... slots) {
-        return createObservable(() -> commandBuilder.clusterDelslots(slots));
-    }
-
-    @Override
-    public Observable<String> clusterInfo() {
-        return createObservable(commandBuilder::clusterInfo);
-    }
-
-    @Override
-    public Observable<String> clusterMyId() {
-        return createObservable(commandBuilder::clusterMyId);
-    }
-
-    @Override
-    public Observable<String> clusterNodes() {
-        return createObservable(commandBuilder::clusterNodes);
-    }
-
-    @Override
-    public Observable<K> clusterGetKeysInSlot(int slot, int count) {
-        return createDissolvingObservable(() -> commandBuilder.clusterGetKeysInSlot(slot, count));
-    }
-
-    @Override
-    public Observable<Long> clusterCountKeysInSlot(int slot) {
-        return createObservable(() -> commandBuilder.clusterCountKeysInSlot(slot));
-    }
-
-    @Override
-    public Observable<Long> clusterCountFailureReports(String nodeId) {
-        return createObservable(() -> commandBuilder.clusterCountFailureReports(nodeId));
-    }
-
-    @Override
-    public Observable<Long> clusterKeyslot(K key) {
-        return createObservable(() -> commandBuilder.clusterKeyslot(key));
-    }
-
-    @Override
-    public Observable<String> clusterSaveconfig() {
-        return createObservable(() -> commandBuilder.clusterSaveconfig());
-    }
-
-    @Override
-    public Observable<String> clusterSetConfigEpoch(long configEpoch) {
-        return createObservable(() -> commandBuilder.clusterSetConfigEpoch(configEpoch));
-    }
-
-    @Override
-    public Observable<Object> clusterSlots() {
-        return createDissolvingObservable(commandBuilder::clusterSlots);
-    }
-
-    @Override
-    public Observable<String> clusterSetSlotNode(int slot, String nodeId) {
-        return createObservable(() -> commandBuilder.clusterSetSlotNode(slot, nodeId));
-    }
-
-    @Override
-    public Observable<String> clusterSetSlotStable(int slot) {
-        return createObservable(() -> commandBuilder.clusterSetSlotStable(slot));
-    }
-
-    @Override
-    public Observable<String> clusterSetSlotMigrating(int slot, String nodeId) {
-        return createObservable(() -> commandBuilder.clusterSetSlotMigrating(slot, nodeId));
-    }
-
-    @Override
-    public Observable<String> clusterSetSlotImporting(int slot, String nodeId) {
-        return createObservable(() -> commandBuilder.clusterSetSlotImporting(slot, nodeId));
-    }
-
-    @Override
-    public Observable<String> clusterFailover(boolean force) {
-        return createObservable(() -> commandBuilder.clusterFailover(force));
-    }
-
-    @Override
-    public Observable<String> clusterReset(boolean hard) {
-        return createObservable(() -> commandBuilder.clusterReset(hard));
-    }
-
-    @Override
-    public Observable<String> asking() {
-        return createObservable(commandBuilder::asking);
-    }
-
-    @Override
-    public Observable<String> clusterReplicate(String nodeId) {
-        return createObservable(() -> commandBuilder.clusterReplicate(nodeId));
-    }
-
-    @Override
-    public Observable<String> clusterFlushslots() {
-        return createObservable(commandBuilder::clusterFlushslots);
-    }
-
-    @Override
-    public Observable<String> clusterSlaves(String nodeId) {
-        return createDissolvingObservable(() -> commandBuilder.clusterSlaves(nodeId));
-    }
-
-    @Override
-    public Observable<Long> zlexcount(K key, String min, String max) {
-        return createObservable(() -> commandBuilder.zlexcount(key, min, max));
-    }
-
-    @Override
-    public Observable<Long> zlexcount(K key, Range<? extends V> range) {
-        return createObservable(() -> commandBuilder.zlexcount(key, range));
-    }
-
-    @Override
-    public Observable<Long> zremrangebylex(K key, String min, String max) {
-        return createObservable(() -> commandBuilder.zremrangebylex(key, min, max));
-    }
-
-    @Override
-    public Observable<Long> zremrangebylex(K key, Range<? extends V> range) {
-        return createObservable(() -> commandBuilder.zremrangebylex(key, range));
-    }
-
-    @Override
-    public Observable<V> zrangebylex(K key, String min, String max) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebylex(key, min, max));
-    }
-
-    @Override
-    public Observable<V> zrangebylex(K key, Range<? extends V> range) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebylex(key, range, Limit.unlimited()));
-    }
-
-    @Override
-    public Observable<V> zrangebylex(K key, String min, String max, long offset, long count) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebylex(key, min, max, offset, count));
-    }
-
-    @Override
-    public Observable<V> zrangebylex(K key, Range<? extends V> range, Limit limit) {
-        return createDissolvingObservable(() -> commandBuilder.zrangebylex(key, range, limit));
-    }
-
-    @Override
-    public Observable<Long> geoadd(K key, double longitude, double latitude, V member) {
-        return createObservable(() -> commandBuilder.geoadd(key, longitude, latitude, member));
-    }
-
-    @Override
-    public Observable<Long> geoadd(K key, Object... lngLatMember) {
-        return createDissolvingObservable(() -> commandBuilder.geoadd(key, lngLatMember));
-    }
-
-    @Override
-    public Observable<String> geohash(K key, V... members) {
-        return createDissolvingObservable(() -> commandBuilder.geohash(key, members));
-    }
-
-    @Override
-    public Observable<V> georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit) {
-        return createDissolvingObservable(() -> commandBuilder.georadius(GEORADIUS, key, longitude, latitude, distance,
-                unit.name()));
-    }
-
-    protected Observable<V> georadius_ro(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit) {
-        return createDissolvingObservable(() -> commandBuilder.georadius(GEORADIUS_RO, key, longitude, latitude, distance,
-                unit.name()));
-    }
-
-    @Override
-    public Observable<GeoWithin<V>> georadius(K key, double longitude, double latitude, double distance, GeoArgs.Unit unit,
-            GeoArgs geoArgs) {
-        return createDissolvingObservable(() -> commandBuilder.georadius(GEORADIUS, key, longitude, latitude, distance,
-                unit.name(), geoArgs));
-    }
-
-    protected Observable<GeoWithin<V>> georadius_ro(K key, double longitude, double latitude, double distance,
-            GeoArgs.Unit unit, GeoArgs geoArgs) {
-        return createDissolvingObservable(() -> commandBuilder.georadius(GEORADIUS_RO, key, longitude, latitude, distance,
-                unit.name(),
-                geoArgs));
-    }
-
-    @Override
-    public Observable<Long> georadius(K key, double longitude, double latitude, double distance, Unit unit,
-            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
-        return createDissolvingObservable(
-                () -> commandBuilder.georadius(key, longitude, latitude, distance, unit.name(), geoRadiusStoreArgs));
-    }
-
-    @Override
-    public Observable<V> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit) {
-        return createDissolvingObservable(() -> commandBuilder.georadiusbymember(GEORADIUSBYMEMBER, key, member, distance,
-                unit.name()));
-    }
-
-    protected Observable<V> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit) {
-        return createDissolvingObservable(() -> commandBuilder.georadiusbymember(GEORADIUSBYMEMBER_RO, key, member, distance,
-                unit.name()));
-    }
-
-    @Override
-    public Observable<GeoWithin<V>> georadiusbymember(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs) {
-        return createDissolvingObservable(() -> commandBuilder.georadiusbymember(GEORADIUSBYMEMBER, key, member, distance,
-                unit.name(), geoArgs));
-    }
-
-    protected Observable<GeoWithin<V>> georadiusbymember_ro(K key, V member, double distance, GeoArgs.Unit unit, GeoArgs geoArgs) {
-        return createDissolvingObservable(() -> commandBuilder.georadiusbymember(GEORADIUSBYMEMBER_RO, key, member, distance,
-                unit.name(), geoArgs));
-    }
-
-    @Override
-    public Observable<Long> georadiusbymember(K key, V member, double distance, Unit unit,
-            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
-        return createDissolvingObservable(
-                () -> commandBuilder.georadiusbymember(key, member, distance, unit.name(), geoRadiusStoreArgs));
-    }
-
-    @Override
-    public Observable<GeoCoordinates> geopos(K key, V... members) {
-        return createDissolvingObservable(() -> commandBuilder.geopos(key, members));
-    }
-
-    @Override
-    public Observable<Double> geodist(K key, V from, V to, GeoArgs.Unit unit) {
-        return createDissolvingObservable(() -> commandBuilder.geodist(key, from, to, unit));
-    }
-
-    @Override
-    public <T> Observable<T> dispatch(ProtocolKeyword type, CommandOutput<K, V, ?> output) {
-
-        LettuceAssert.notNull(type, "Command type must not be null");
-        LettuceAssert.notNull(output, "CommandOutput type must not be null");
-
-        return createDissolvingObservable(() -> new Command<>(type, output));
-    }
-
-    @Override
-    public <T> Observable<T> dispatch(ProtocolKeyword type, CommandOutput<K, V, ?> output, CommandArgs<K, V> args) {
-
-        LettuceAssert.notNull(type, "Command type must not be null");
-        LettuceAssert.notNull(output, "CommandOutput type must not be null");
-        LettuceAssert.notNull(args, "CommandArgs type must not be null");
-
-        return createDissolvingObservable(() -> new Command<>(type, output, args));
-    }
-
-    protected <T> Observable<T> createObservable(CommandType type, CommandOutput<K, V, T> output, CommandArgs<K, V> args) {
-        return createObservable(() -> new Command<>(type, output, args));
-    }
-
-    public <T> Observable<T> createObservable(Supplier<RedisCommand<K, V, T>> commandSupplier) {
-        return Observable.create(new ReactiveCommandDispatcher<>(commandSupplier, connection, false));
-    }
-
-    @SuppressWarnings("unchecked")
-    public <T, R> R createDissolvingObservable(Supplier<RedisCommand<K, V, T>> commandSupplier) {
-        return (R) Observable.create(new ReactiveCommandDispatcher<>(commandSupplier, connection, true));
-    }
-
-    @SuppressWarnings("unchecked")
-    public <T, R> R createDissolvingObservable(CommandType type, CommandOutput<K, V, T> output, CommandArgs<K, V> args) {
-        return (R) Observable
-                .create(new ReactiveCommandDispatcher<>(() -> new Command<>(type, output, args),
-                connection, true));
-    }
-
-    /**
-     * Emits just {@link Success#Success} or the {@link Throwable} after the inner observable is completed.
-     *
-     * @param observable inner observable
-     * @param <T> used for type inference
-     * @return Success observable
-     */
-    protected <T> Observable<Success> getSuccessObservable(final Observable<T> observable) {
-        return Observable.create(new Observable.OnSubscribe<Success>() {
-            @Override
-            public void call(Subscriber<? super Success> subscriber) {
-
-                observable.subscribe(new Subscriber<Object>() {
-                    @Override
-                    public void onCompleted() {
-                        subscriber.onNext(Success.Success);
-                        subscriber.onCompleted();
-                    }
-
-                    @Override
-                    public void onError(Throwable throwable) {
-                        subscriber.onError(throwable);
-                    }
-
-                    @Override
-                    public void onNext(Object k) {
-
-                    }
-                });
-            }
-        });
-    }
-
-    public void setTimeout(long timeout, TimeUnit unit) {
-        connection.setTimeout(timeout, unit);
-    }
-
-    @Override
-    public void close() {
-        connection.close();
-    }
-
-    @Override
-    public boolean isOpen() {
-        return connection.isOpen();
+    public Observable<Long> zunionstore(K destination, K... keys) {
+        return createObservable(() -> commandBuilder.zunionstore(destination, keys));
     }
 
     @Override
-    public void reset() {
-        getConnection().reset();
-    }
-
-    public StatefulConnection<K, V> getConnection() {
-        return connection;
+    public Observable<Long> zunionstore(K destination, ZStoreArgs storeArgs, K... keys) {
+        return createObservable(() -> commandBuilder.zunionstore(destination, storeArgs, keys));
     }
 }
diff --git a/src/main/java/com/lambdaworks/redis/RedisCommandBuilder.java b/src/main/java/com/lambdaworks/redis/RedisCommandBuilder.java
index 76ff7480c7..b5f6a299f8 100644
--- a/src/main/java/com/lambdaworks/redis/RedisCommandBuilder.java
+++ b/src/main/java/com/lambdaworks/redis/RedisCommandBuilder.java
@@ -36,197 +36,372 @@
  * @param <V>
  * @author Mark Paluch
  */
-@SuppressWarnings({ "unchecked", "Convert2Diamond", "WeakerAccess", "varargs" })
+@SuppressWarnings({ "unchecked", "varargs" })
 class RedisCommandBuilder<K, V> extends BaseRedisCommandBuilder<K, V> {
 
-    static final String MUST_NOT_CONTAIN_NULL_ELEMENTS = "must not contain null elements";
-    static final String MUST_NOT_BE_EMPTY = "must not be empty";
-    static final String MUST_NOT_BE_NULL = "must not be null";
+    private static final String MUST_NOT_CONTAIN_NULL_ELEMENTS = "must not contain null elements";
+    private static final String MUST_NOT_BE_EMPTY = "must not be empty";
+    private static final String MUST_NOT_BE_NULL = "must not be null";
 
     private static final byte[] MINUS_BYTES = { '-' };
     private static final byte[] PLUS_BYTES = { '+' };
 
     private final RedisCodec<String, String> STRING_CODEC = new Utf8StringCodec();
 
-    public RedisCommandBuilder(RedisCodec<K, V> codec) {
+    RedisCommandBuilder(RedisCodec<K, V> codec) {
         super(codec);
     }
 
-    public Command<K, V, Long> append(K key, V value) {
+    Command<K, V, Long> append(K key, V value) {
         notNullKey(key);
 
-        return createCommand(APPEND, new IntegerOutput<K, V>(codec), key, value);
+        return createCommand(APPEND, new IntegerOutput<>(codec), key, value);
     }
 
-    public Command<K, V, String> auth(String password) {
+    Command<K, V, String> asking() {
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        return createCommand(ASKING, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> auth(String password) {
         LettuceAssert.notNull(password, "Password " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(password, "Password " + MUST_NOT_BE_EMPTY);
 
         return auth(password.toCharArray());
     }
 
-    public Command<K, V, String> auth(char[] password) {
+    Command<K, V, String> auth(char[] password) {
         LettuceAssert.notNull(password, "Password " + MUST_NOT_BE_NULL);
         LettuceAssert.isTrue(password.length > 0, "Password " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(password);
-        return createCommand(AUTH, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(password);
+        return createCommand(AUTH, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> bgrewriteaof() {
-        return createCommand(BGREWRITEAOF, new StatusOutput<K, V>(codec));
+    Command<K, V, String> bgrewriteaof() {
+        return createCommand(BGREWRITEAOF, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, String> bgsave() {
-        return createCommand(BGSAVE, new StatusOutput<K, V>(codec));
+    Command<K, V, String> bgsave() {
+        return createCommand(BGSAVE, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, Long> bitcount(K key) {
+    Command<K, V, Long> bitcount(K key) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key);
-        return createCommand(BITCOUNT, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key);
+        return createCommand(BITCOUNT, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> bitcount(K key, long start, long end) {
+    Command<K, V, Long> bitcount(K key, long start, long end) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.addKey(key).add(start).add(end);
-        return createCommand(BITCOUNT, new IntegerOutput<K, V>(codec), args);
+        return createCommand(BITCOUNT, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, List<Long>> bitfield(K key, BitFieldArgs bitFieldArgs) {
+    Command<K, V, List<Long>> bitfield(K key, BitFieldArgs bitFieldArgs) {
         notNullKey(key);
         LettuceAssert.notNull(bitFieldArgs, "BitFieldArgs must not be null");
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.addKey(key);
 
         bitFieldArgs.build(args);
 
-        return createCommand(BITFIELD, (CommandOutput) new ArrayOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> bitpos(K key, boolean state) {
-        notNullKey(key);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(state ? 1 : 0);
-        return createCommand(BITPOS, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> bitpos(K key, boolean state, long start, long end) {
-        notNullKey(key);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(state ? 1 : 0).add(start).add(end);
-        return createCommand(BITPOS, new IntegerOutput<K, V>(codec), args);
+        return createCommand(BITFIELD, (CommandOutput) new ArrayOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> bitopAnd(K destination, K... keys) {
+    Command<K, V, Long> bitopAnd(K destination, K... keys) {
         LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.add(AND).addKey(destination).addKeys(keys);
-        return createCommand(BITOP, new IntegerOutput<K, V>(codec), args);
+        return createCommand(BITOP, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> bitopNot(K destination, K source) {
+    Command<K, V, Long> bitopNot(K destination, K source) {
         LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(source, "Source " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.add(NOT).addKey(destination).addKey(source);
-        return createCommand(BITOP, new IntegerOutput<K, V>(codec), args);
+        return createCommand(BITOP, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> bitopOr(K destination, K... keys) {
+    Command<K, V, Long> bitopOr(K destination, K... keys) {
         LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.add(OR).addKey(destination).addKeys(keys);
-        return createCommand(BITOP, new IntegerOutput<K, V>(codec), args);
+        return createCommand(BITOP, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> bitopXor(K destination, K... keys) {
+    Command<K, V, Long> bitopXor(K destination, K... keys) {
         LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.add(XOR).addKey(destination).addKeys(keys);
-        return createCommand(BITOP, new IntegerOutput<K, V>(codec), args);
+        return createCommand(BITOP, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> bitpos(K key, boolean state) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(state ? 1 : 0);
+        return createCommand(BITPOS, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> bitpos(K key, boolean state, long start, long end) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(state ? 1 : 0).add(start).add(end);
+        return createCommand(BITPOS, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, KeyValue<K, V>> blpop(long timeout, K... keys) {
+    Command<K, V, KeyValue<K, V>> blpop(long timeout, K... keys) {
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys).add(timeout);
-        return createCommand(BLPOP, new KeyValueOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys).add(timeout);
+        return createCommand(BLPOP, new KeyValueOutput<>(codec), args);
     }
 
-    public Command<K, V, KeyValue<K, V>> brpop(long timeout, K... keys) {
+    Command<K, V, KeyValue<K, V>> brpop(long timeout, K... keys) {
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys).add(timeout);
-        return createCommand(BRPOP, new KeyValueOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys).add(timeout);
+        return createCommand(BRPOP, new KeyValueOutput<>(codec), args);
     }
 
-    public Command<K, V, V> brpoplpush(long timeout, K source, K destination) {
+    Command<K, V, V> brpoplpush(long timeout, K source, K destination) {
         LettuceAssert.notNull(source, "Source " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.addKey(source).addKey(destination).add(timeout);
-        return createCommand(BRPOPLPUSH, new ValueOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, K> clientGetname() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(GETNAME);
-        return createCommand(CLIENT, new KeyOutput<K, V>(codec), args);
+        return createCommand(BRPOPLPUSH, new ValueOutput<>(codec), args);
     }
 
-    public Command<K, V, String> clientSetname(K name) {
-        LettuceAssert.notNull(name, "Name " + MUST_NOT_BE_NULL);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(SETNAME).addKey(name);
-        return createCommand(CLIENT, new StatusOutput<K, V>(codec), args);
+    Command<K, V, K> clientGetname() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(GETNAME);
+        return createCommand(CLIENT, new KeyOutput<>(codec), args);
     }
 
-    public Command<K, V, String> clientKill(String addr) {
+    Command<K, V, String> clientKill(String addr) {
         LettuceAssert.notNull(addr, "Addr " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(addr, "Addr " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(KILL).add(addr);
-        return createCommand(CLIENT, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(KILL).add(addr);
+        return createCommand(CLIENT, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> clientKill(KillArgs killArgs) {
+    Command<K, V, Long> clientKill(KillArgs killArgs) {
         LettuceAssert.notNull(killArgs, "KillArgs " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(KILL);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(KILL);
         killArgs.build(args);
-        return createCommand(CLIENT, new IntegerOutput<K, V>(codec), args);
+        return createCommand(CLIENT, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clientList() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(LIST);
+        return createCommand(CLIENT, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clientPause(long timeout) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(PAUSE).add(timeout);
+        return createCommand(CLIENT, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clientSetname(K name) {
+        LettuceAssert.notNull(name, "Name " + MUST_NOT_BE_NULL);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(SETNAME).addKey(name);
+        return createCommand(CLIENT, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterAddslots(int[] slots) {
+        notEmptySlots(slots);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(ADDSLOTS);
+
+        for (int slot : slots) {
+            args.add(slot);
+        }
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterBumpepoch() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(BUMPEPOCH);
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> clusterCountFailureReports(String nodeId) {
+        assertNodeId(nodeId);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add("COUNT-FAILURE-REPORTS").add(nodeId);
+        return createCommand(CLUSTER, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> clusterCountKeysInSlot(int slot) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(COUNTKEYSINSLOT).add(slot);
+        return createCommand(CLUSTER, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterDelslots(int[] slots) {
+        notEmptySlots(slots);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(DELSLOTS);
+
+        for (int slot : slots) {
+            args.add(slot);
+        }
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterFailover(boolean force) {
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(FAILOVER);
+        if (force) {
+            args.add(FORCE);
+        }
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterFlushslots() {
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(FLUSHSLOTS);
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterForget(String nodeId) {
+        assertNodeId(nodeId);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(FORGET).add(nodeId);
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, List<K>> clusterGetKeysInSlot(int slot, int count) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(GETKEYSINSLOT).add(slot).add(count);
+        return createCommand(CLUSTER, new KeyListOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterInfo() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(INFO);
+
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> clusterKeyslot(K key) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(KEYSLOT).addKey(key);
+        return createCommand(CLUSTER, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterMeet(String ip, int port) {
+        LettuceAssert.notNull(ip, "IP " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(ip, "IP " + MUST_NOT_BE_EMPTY);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(MEET).add(ip).add(port);
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterMyId() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(MYID);
+
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterNodes() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(NODES);
+
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterReplicate(String nodeId) {
+        assertNodeId(nodeId);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(REPLICATE).add(nodeId);
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterReset(boolean hard) {
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(RESET);
+        if (hard) {
+            args.add(HARD);
+        } else {
+            args.add(SOFT);
+        }
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterSaveconfig() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(SAVECONFIG);
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterSetConfigEpoch(long configEpoch) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add("SET-CONFIG-EPOCH").add(configEpoch);
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterSetSlotImporting(int slot, String nodeId) {
+        assertNodeId(nodeId);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(SETSLOT).add(slot).add(IMPORTING).add(nodeId);
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterSetSlotMigrating(int slot, String nodeId) {
+        assertNodeId(nodeId);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(SETSLOT).add(slot).add(MIGRATING).add(nodeId);
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterSetSlotNode(int slot, String nodeId) {
+        assertNodeId(nodeId);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(SETSLOT).add(slot).add(NODE).add(nodeId);
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> clusterSetSlotStable(int slot) {
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(SETSLOT).add(slot).add(STABLE);
+        return createCommand(CLUSTER, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> clientPause(long timeout) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(PAUSE).add(timeout);
-        return createCommand(CLIENT, new StatusOutput<K, V>(codec), args);
+    Command<K, V, List<String>> clusterSlaves(String nodeId) {
+        assertNodeId(nodeId);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(SLAVES).add(nodeId);
+        return createCommand(CLUSTER, new StringListOutput<>(codec), args);
     }
 
-    public Command<K, V, String> clientList() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(LIST);
-        return createCommand(CLIENT, new StatusOutput<K, V>(codec), args);
+    Command<K, V, List<Object>> clusterSlots() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(SLOTS);
+        return createCommand(CLUSTER, new ArrayOutput<>(codec), args);
     }
 
-    public Command<K, V, List<Object>> command() {
+    Command<K, V, List<Object>> command() {
         CommandArgs<K, V> args = new CommandArgs<K, V>((RedisCodec) STRING_CODEC);
         return createCommand(COMMAND, new ArrayOutput<K, V>((RedisCodec) STRING_CODEC), args);
     }
 
-    public Command<K, V, List<Object>> commandInfo(String... commands) {
+    Command<K, V, Long> commandCount() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(COUNT);
+        return createCommand(COMMAND, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, List<Object>> commandInfo(String... commands) {
         LettuceAssert.notNull(commands, "Commands " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(commands, "Commands " + MUST_NOT_BE_EMPTY);
         LettuceAssert.noNullElements(commands, "Commands " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
@@ -241,553 +416,771 @@ public Command<K, V, List<Object>> commandInfo(String... commands) {
         return createCommand(COMMAND, new ArrayOutput<K, V>((RedisCodec) STRING_CODEC), args);
     }
 
-    public Command<K, V, Long> commandCount() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(COUNT);
-        return createCommand(COMMAND, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> configRewrite() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(REWRITE);
-        return createCommand(CONFIG, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, List<String>> configGet(String parameter) {
+    Command<K, V, List<String>> configGet(String parameter) {
         LettuceAssert.notNull(parameter, "Parameter " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(parameter, "Parameter " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(GET).add(parameter);
-        return createCommand(CONFIG, new StringListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(GET).add(parameter);
+        return createCommand(CONFIG, new StringListOutput<>(codec), args);
+    }
+
+    Command<K, V, String> configResetstat() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(RESETSTAT);
+        return createCommand(CONFIG, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> configResetstat() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(RESETSTAT);
-        return createCommand(CONFIG, new StatusOutput<K, V>(codec), args);
+    Command<K, V, String> configRewrite() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(REWRITE);
+        return createCommand(CONFIG, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> configSet(String parameter, String value) {
+    Command<K, V, String> configSet(String parameter, String value) {
         LettuceAssert.notNull(parameter, "Parameter " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(parameter, "Parameter " + MUST_NOT_BE_EMPTY);
         LettuceAssert.notNull(value, "Value " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(SET).add(parameter).add(value);
-        return createCommand(CONFIG, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(SET).add(parameter).add(value);
+        return createCommand(CONFIG, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> dbsize() {
-        return createCommand(DBSIZE, new IntegerOutput<K, V>(codec));
+    Command<K, V, Long> dbsize() {
+        return createCommand(DBSIZE, new IntegerOutput<>(codec));
     }
 
-    public Command<K, V, String> debugCrashAndRecover(Long delay) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add("CRASH-AND-RECOVER");
+    Command<K, V, String> debugCrashAndRecover(Long delay) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add("CRASH-AND-RECOVER");
         if (delay != null) {
             args.add(delay);
         }
-        return createCommand(DEBUG, new StatusOutput<K, V>(codec), args);
+        return createCommand(DEBUG, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> debugObject(K key) {
-        notNullKey(key);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(OBJECT).addKey(key);
-        return createCommand(DEBUG, new StatusOutput<K, V>(codec), args);
+    Command<K, V, String> debugHtstats(int db) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(HTSTATS).add(db);
+        return createCommand(DEBUG, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, Void> debugOom() {
-        return createCommand(DEBUG, null, new CommandArgs<K, V>(codec).add("OOM"));
+    Command<K, V, String> debugObject(K key) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(OBJECT).addKey(key);
+        return createCommand(DEBUG, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> debugHtstats(int db) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(HTSTATS).add(db);
-        return createCommand(DEBUG, new StatusOutput<K, V>(codec), args);
+    Command<K, V, Void> debugOom() {
+        return createCommand(DEBUG, null, new CommandArgs<>(codec).add("OOM"));
     }
 
-    public Command<K, V, String> debugReload() {
-        return createCommand(DEBUG, new StatusOutput<K, V>(codec), new CommandArgs<K, V>(codec).add(RELOAD));
+    Command<K, V, String> debugReload() {
+        return createCommand(DEBUG, new StatusOutput<>(codec), new CommandArgs<>(codec).add(RELOAD));
     }
 
-    public Command<K, V, String> debugRestart(Long delay) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(RESTART);
+    Command<K, V, String> debugRestart(Long delay) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(RESTART);
         if (delay != null) {
             args.add(delay);
         }
-        return createCommand(DEBUG, new StatusOutput<K, V>(codec), args);
+        return createCommand(DEBUG, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> debugSdslen(K key) {
+    Command<K, V, String> debugSdslen(K key) {
         notNullKey(key);
 
-        return createCommand(DEBUG, new StatusOutput<K, V>(codec), new CommandArgs<K, V>(codec).add("SDSLEN").addKey(key));
+        return createCommand(DEBUG, new StatusOutput<>(codec), new CommandArgs<>(codec).add("SDSLEN").addKey(key));
     }
 
-    public Command<K, V, Void> debugSegfault() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(SEGFAULT);
+    Command<K, V, Void> debugSegfault() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(SEGFAULT);
         return createCommand(DEBUG, null, args);
     }
 
-    public Command<K, V, Long> decr(K key) {
+    Command<K, V, Long> decr(K key) {
         notNullKey(key);
 
-        return createCommand(DECR, new IntegerOutput<K, V>(codec), key);
+        return createCommand(DECR, new IntegerOutput<>(codec), key);
     }
 
-    public Command<K, V, Long> decrby(K key, long amount) {
+    Command<K, V, Long> decrby(K key, long amount) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(amount);
-        return createCommand(DECRBY, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> del(K... keys) {
-        notEmpty(keys);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(DEL, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> del(Iterable<K> keys) {
-        LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(DEL, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(amount);
+        return createCommand(DECRBY, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> unlink(K... keys) {
+    Command<K, V, Long> del(K... keys) {
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(UNLINK, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(DEL, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> unlink(Iterable<K> keys) {
+    Command<K, V, Long> del(Iterable<K> keys) {
         LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(UNLINK, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(DEL, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, String> discard() {
-        return createCommand(DISCARD, new StatusOutput<K, V>(codec));
+    Command<K, V, String> discard() {
+        return createCommand(DISCARD, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, byte[]> dump(K key) {
+    Command<K, V, byte[]> dump(K key) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key);
-        return createCommand(DUMP, new ByteArrayOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key);
+        return createCommand(DUMP, new ByteArrayOutput<>(codec), args);
     }
 
-    public Command<K, V, V> echo(V msg) {
+    Command<K, V, V> echo(V msg) {
         LettuceAssert.notNull(msg, "message " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addValue(msg);
-        return createCommand(ECHO, new ValueOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addValue(msg);
+        return createCommand(ECHO, new ValueOutput<>(codec), args);
     }
 
-    public <T> Command<K, V, T> eval(String script, ScriptOutputType type, K... keys) {
+    <T> Command<K, V, T> eval(String script, ScriptOutputType type, K... keys) {
         LettuceAssert.notNull(script, "Script " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(script, "Script " + MUST_NOT_BE_EMPTY);
         LettuceAssert.notNull(type, "ScriptOutputType " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.add(script).add(keys.length).addKeys(keys);
         CommandOutput<K, V, T> output = newScriptOutput(codec, type);
         return createCommand(EVAL, output, args);
     }
 
-    public <T> Command<K, V, T> eval(String script, ScriptOutputType type, K[] keys, V... values) {
+    <T> Command<K, V, T> eval(String script, ScriptOutputType type, K[] keys, V... values) {
         LettuceAssert.notNull(script, "Script " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(script, "Script " + MUST_NOT_BE_EMPTY);
         LettuceAssert.notNull(type, "ScriptOutputType " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(values, "Values " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.add(script).add(keys.length).addKeys(keys).addValues(values);
         CommandOutput<K, V, T> output = newScriptOutput(codec, type);
         return createCommand(EVAL, output, args);
     }
 
-    public <T> Command<K, V, T> evalsha(String digest, ScriptOutputType type, K... keys) {
+    <T> Command<K, V, T> evalsha(String digest, ScriptOutputType type, K... keys) {
         LettuceAssert.notNull(digest, "Digest " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(digest, "Digest " + MUST_NOT_BE_EMPTY);
         LettuceAssert.notNull(type, "ScriptOutputType " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.add(digest).add(keys.length).addKeys(keys);
         CommandOutput<K, V, T> output = newScriptOutput(codec, type);
         return createCommand(EVALSHA, output, args);
     }
 
-    public <T> Command<K, V, T> evalsha(String digest, ScriptOutputType type, K[] keys, V... values) {
+    <T> Command<K, V, T> evalsha(String digest, ScriptOutputType type, K[] keys, V... values) {
         LettuceAssert.notNull(digest, "Digest " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(digest, "Digest " + MUST_NOT_BE_EMPTY);
         LettuceAssert.notNull(type, "ScriptOutputType " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(values, "Values " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.add(digest).add(keys.length).addKeys(keys).addValues(values);
         CommandOutput<K, V, T> output = newScriptOutput(codec, type);
         return createCommand(EVALSHA, output, args);
     }
 
-    public Command<K, V, Boolean> exists(K key) {
+    Command<K, V, Boolean> exists(K key) {
         notNullKey(key);
 
-        return createCommand(EXISTS, new BooleanOutput<K, V>(codec), key);
+        return createCommand(EXISTS, new BooleanOutput<>(codec), key);
     }
 
-    public Command<K, V, Long> exists(K... keys) {
+    Command<K, V, Long> exists(K... keys) {
         notEmpty(keys);
 
-        return createCommand(EXISTS, new IntegerOutput<K, V>(codec), new CommandArgs<K, V>(codec).addKeys(keys));
+        return createCommand(EXISTS, new IntegerOutput<>(codec), new CommandArgs<>(codec).addKeys(keys));
     }
 
-    public Command<K, V, Long> exists(Iterable<K> keys) {
+    Command<K, V, Long> exists(Iterable<K> keys) {
         LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
 
-        return createCommand(EXISTS, new IntegerOutput<K, V>(codec), new CommandArgs<K, V>(codec).addKeys(keys));
+        return createCommand(EXISTS, new IntegerOutput<>(codec), new CommandArgs<>(codec).addKeys(keys));
     }
 
-    public Command<K, V, Boolean> expire(K key, long seconds) {
+    Command<K, V, Boolean> expire(K key, long seconds) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(seconds);
-        return createCommand(EXPIRE, new BooleanOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(seconds);
+        return createCommand(EXPIRE, new BooleanOutput<>(codec), args);
     }
 
-    public Command<K, V, Boolean> expireat(K key, long timestamp) {
+    Command<K, V, Boolean> expireat(K key, long timestamp) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(timestamp);
-        return createCommand(EXPIREAT, new BooleanOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(timestamp);
+        return createCommand(EXPIREAT, new BooleanOutput<>(codec), args);
     }
 
-    public Command<K, V, String> flushall() {
-        return createCommand(FLUSHALL, new StatusOutput<K, V>(codec));
+    Command<K, V, String> flushall() {
+        return createCommand(FLUSHALL, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, String> flushallAsync() {
-        return createCommand(FLUSHALL, new StatusOutput<K, V>(codec), new CommandArgs<K, V>(codec).add(ASYNC));
+    Command<K, V, String> flushallAsync() {
+        return createCommand(FLUSHALL, new StatusOutput<>(codec), new CommandArgs<>(codec).add(ASYNC));
     }
 
-    public Command<K, V, String> flushdb() {
-        return createCommand(FLUSHDB, new StatusOutput<K, V>(codec));
+    Command<K, V, String> flushdb() {
+        return createCommand(FLUSHDB, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, String> flushdbAsync() {
-        return createCommand(FLUSHDB, new StatusOutput<K, V>(codec), new CommandArgs<K, V>(codec).add(ASYNC));
+    Command<K, V, String> flushdbAsync() {
+        return createCommand(FLUSHDB, new StatusOutput<>(codec), new CommandArgs<>(codec).add(ASYNC));
     }
 
-    public Command<K, V, V> get(K key) {
+    Command<K, V, Long> geoadd(K key, double longitude, double latitude, V member) {
         notNullKey(key);
 
-        return createCommand(GET, new ValueOutput<K, V>(codec), key);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(longitude).add(latitude).addValue(member);
+        return createCommand(GEOADD, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> getbit(K key, long offset) {
+    Command<K, V, Long> geoadd(K key, Object[] lngLatMember) {
+
         notNullKey(key);
+        LettuceAssert.notNull(lngLatMember, "LngLatMember " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(lngLatMember, "LngLatMember " + MUST_NOT_BE_EMPTY);
+        LettuceAssert.noNullElements(lngLatMember, "LngLatMember " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
+        LettuceAssert
+                .isTrue(lngLatMember.length % 3 == 0,
+                        "LngLatMember.length must be a multiple of 3 and contain a "
+                                + "sequence of longitude1, latitude1, member1, longitude2, latitude2, member2, ... longitudeN, latitudeN, memberN");
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(offset);
-        return createCommand(GETBIT, new IntegerOutput<K, V>(codec), args);
-    }
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key);
 
-    public Command<K, V, V> getrange(K key, long start, long end) {
-        notNullKey(key);
+        for (int i = 0; i < lngLatMember.length; i += 3) {
+            args.add((Double) lngLatMember[i]);
+            args.add((Double) lngLatMember[i + 1]);
+            args.addValue((V) lngLatMember[i + 2]);
+        }
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(start).add(end);
-        return createCommand(GETRANGE, new ValueOutput<K, V>(codec), args);
+        return createCommand(GEOADD, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, V> getset(K key, V value) {
+    Command<K, V, Double> geodist(K key, V from, V to, GeoArgs.Unit unit) {
         notNullKey(key);
+        LettuceAssert.notNull(from, "From " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(from, "To " + MUST_NOT_BE_NULL);
 
-        return createCommand(GETSET, new ValueOutput<K, V>(codec), key, value);
-    }
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addValue(from).addValue(to);
 
-    public Command<K, V, Long> hdel(K key, K... fields) {
-        notNullKey(key);
-        LettuceAssert.notNull(fields, "Fields " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(fields, "Fields " + MUST_NOT_BE_EMPTY);
+        if (unit != null) {
+            args.add(unit.name());
+        }
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKeys(fields);
-        return createCommand(HDEL, new IntegerOutput<K, V>(codec), args);
+        return createCommand(GEODIST, new DoubleOutput<>(codec), args);
     }
 
-    public Command<K, V, Boolean> hexists(K key, K field) {
+    Command<K, V, List<String>> geohash(K key, V... members) {
         notNullKey(key);
-        LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(members, "Members " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(members, "Members " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKey(field);
-        return createCommand(HEXISTS, new BooleanOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addValues(members);
+        return createCommand(GEOHASH, new StringListOutput<>(codec), args);
     }
 
-    public Command<K, V, V> hget(K key, K field) {
+    Command<K, V, List<GeoCoordinates>> geopos(K key, V[] members) {
         notNullKey(key);
-        LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(members, "Members " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(members, "Members " + MUST_NOT_BE_EMPTY);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addValues(members);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKey(field);
-        return createCommand(HGET, new ValueOutput<K, V>(codec), args);
+        return createCommand(GEOPOS, new GeoCoordinatesListOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> hincrby(K key, K field, long amount) {
+    Command<K, V, Set<V>> georadius(CommandType commandType, K key, double longitude, double latitude, double distance,
+            String unit) {
         notNullKey(key);
-        LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKey(field).add(amount);
-        return createCommand(HINCRBY, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(longitude).add(latitude).add(distance).add(unit);
+        return createCommand(commandType, new ValueSetOutput<>(codec), args);
     }
 
-    public Command<K, V, Double> hincrbyfloat(K key, K field, double amount) {
+    Command<K, V, List<GeoWithin<V>>> georadius(CommandType commandType, K key, double longitude, double latitude,
+            double distance, String unit, GeoArgs geoArgs) {
+
         notNullKey(key);
-        LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
+        LettuceAssert.notNull(geoArgs, "GeoArgs " + MUST_NOT_BE_NULL);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(longitude).add(latitude).add(distance).add(unit);
+        geoArgs.build(args);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKey(field).add(amount);
-        return createCommand(HINCRBYFLOAT, new DoubleOutput<K, V>(codec), args);
+        return createCommand(commandType, new GeoWithinListOutput<>(codec, geoArgs.isWithDistance(), geoArgs.isWithHash(),
+                geoArgs.isWithCoordinates()), args);
     }
 
-    public Command<K, V, Map<K, V>> hgetall(K key) {
+    Command<K, V, Long> georadius(K key, double longitude, double latitude, double distance, String unit,
+            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
+
         notNullKey(key);
+        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
+        LettuceAssert.notNull(geoRadiusStoreArgs, "GeoRadiusStoreArgs " + MUST_NOT_BE_NULL);
+        LettuceAssert.isTrue(geoRadiusStoreArgs.getStoreKey() != null || geoRadiusStoreArgs.getStoreDistKey() != null,
+                "At least STORE key or STORDIST key is required");
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(longitude).add(latitude).add(distance).add(unit);
+        geoRadiusStoreArgs.build(args);
 
-        return createCommand(HGETALL, new MapOutput<K, V>(codec), key);
+        return createCommand(GEORADIUS, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> hgetall(KeyValueStreamingChannel<K, V> channel, K key) {
+    Command<K, V, Set<V>> georadiusbymember(CommandType commandType, K key, V member, double distance, String unit) {
+
         notNullKey(key);
-        notNull(channel);
+        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
 
-        return createCommand(HGETALL, new KeyValueStreamingOutput<K, V>(codec, channel), key);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addValue(member).add(distance).add(unit);
+        return createCommand(commandType, new ValueSetOutput<>(codec), args);
     }
 
-    public Command<K, V, List<K>> hkeys(K key) {
+    Command<K, V, List<GeoWithin<V>>> georadiusbymember(CommandType commandType, K key, V member, double distance, String unit,
+            GeoArgs geoArgs) {
+
         notNullKey(key);
+        LettuceAssert.notNull(geoArgs, "GeoArgs " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addValue(member).add(distance).add(unit);
+        geoArgs.build(args);
 
-        return createCommand(HKEYS, new KeyListOutput<K, V>(codec), key);
+        return createCommand(commandType, new GeoWithinListOutput<>(codec, geoArgs.isWithDistance(), geoArgs.isWithHash(),
+                geoArgs.isWithCoordinates()), args);
     }
 
-    public Command<K, V, Long> hkeys(KeyStreamingChannel<K> channel, K key) {
+    Command<K, V, Long> georadiusbymember(K key, V member, double distance, String unit,
+            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
+
         notNullKey(key);
-        notNull(channel);
+        LettuceAssert.notNull(geoRadiusStoreArgs, "GeoRadiusStoreArgs " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
+        LettuceAssert.isTrue(geoRadiusStoreArgs.getStoreKey() != null || geoRadiusStoreArgs.getStoreDistKey() != null,
+                "At least STORE key or STORDIST key is required");
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addValue(member).add(distance).add(unit);
+        geoRadiusStoreArgs.build(args);
 
-        return createCommand(HKEYS, new KeyStreamingOutput<K, V>(codec, channel), key);
+        return createCommand(GEORADIUSBYMEMBER, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> hlen(K key) {
+    Command<K, V, V> get(K key) {
         notNullKey(key);
 
-        return createCommand(HLEN, new IntegerOutput<K, V>(codec), key);
+        return createCommand(GET, new ValueOutput<>(codec), key);
     }
 
-    public Command<K, V, Long> hstrlen(K key, K field) {
+    Command<K, V, Long> getbit(K key, long offset) {
         notNullKey(key);
-        LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKey(field);
-        return createCommand(HSTRLEN, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(offset);
+        return createCommand(GETBIT, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, List<V>> hmget(K key, K... fields) {
+    Command<K, V, V> getrange(K key, long start, long end) {
         notNullKey(key);
-        LettuceAssert.notNull(fields, "Fields " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(fields, "Fields " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKeys(fields);
-        return createCommand(HMGET, new ValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(start).add(end);
+        return createCommand(GETRANGE, new ValueOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> hmget(ValueStreamingChannel<V> channel, K key, K... fields) {
+    Command<K, V, V> getset(K key, V value) {
         notNullKey(key);
-        LettuceAssert.notNull(fields, "Fields " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(fields, "Fields " + MUST_NOT_BE_EMPTY);
-        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKeys(fields);
-        return createCommand(HMGET, new ValueStreamingOutput<K, V>(codec, channel), args);
+        return createCommand(GETSET, new ValueOutput<>(codec), key, value);
     }
 
-    public Command<K, V, String> hmset(K key, Map<K, V> map) {
+    Command<K, V, Long> hdel(K key, K... fields) {
         notNullKey(key);
-        LettuceAssert.notNull(map, "Map " + MUST_NOT_BE_NULL);
-        LettuceAssert.isTrue(!map.isEmpty(), "Map " + MUST_NOT_BE_EMPTY);
+        LettuceAssert.notNull(fields, "Fields " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(fields, "Fields " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(map);
-        return createCommand(HMSET, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKeys(fields);
+        return createCommand(HDEL, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Boolean> hset(K key, K field, V value) {
+    Command<K, V, Boolean> hexists(K key, K field) {
         notNullKey(key);
         LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKey(field).addValue(value);
-        return createCommand(HSET, new BooleanOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKey(field);
+        return createCommand(HEXISTS, new BooleanOutput<>(codec), args);
     }
 
-    public Command<K, V, Boolean> hsetnx(K key, K field, V value) {
+    Command<K, V, V> hget(K key, K field) {
         notNullKey(key);
         LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKey(field).addValue(value);
-        return createCommand(HSETNX, new BooleanOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKey(field);
+        return createCommand(HGET, new ValueOutput<>(codec), args);
     }
 
-    public Command<K, V, List<V>> hvals(K key) {
+    Command<K, V, Map<K, V>> hgetall(K key) {
         notNullKey(key);
 
-        return createCommand(HVALS, new ValueListOutput<K, V>(codec), key);
+        return createCommand(HGETALL, new MapOutput<>(codec), key);
     }
 
-    public Command<K, V, Long> hvals(ValueStreamingChannel<V> channel, K key) {
+    Command<K, V, Long> hgetall(KeyValueStreamingChannel<K, V> channel, K key) {
         notNullKey(key);
         notNull(channel);
 
-        return createCommand(HVALS, new ValueStreamingOutput<K, V>(codec, channel), key);
+        return createCommand(HGETALL, new KeyValueStreamingOutput<>(codec, channel), key);
     }
 
-    public Command<K, V, Long> incr(K key) {
+    Command<K, V, Long> hincrby(K key, K field, long amount) {
         notNullKey(key);
+        LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
 
-        return createCommand(INCR, new IntegerOutput<K, V>(codec), key);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKey(field).add(amount);
+        return createCommand(HINCRBY, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> incrby(K key, long amount) {
+    Command<K, V, Double> hincrbyfloat(K key, K field, double amount) {
         notNullKey(key);
+        LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(amount);
-        return createCommand(INCRBY, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKey(field).add(amount);
+        return createCommand(HINCRBYFLOAT, new DoubleOutput<>(codec), args);
     }
 
-    public Command<K, V, Double> incrbyfloat(K key, double amount) {
+    Command<K, V, List<K>> hkeys(K key) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(amount);
-        return createCommand(INCRBYFLOAT, new DoubleOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> info() {
-        return createCommand(INFO, new StatusOutput<K, V>(codec));
+        return createCommand(HKEYS, new KeyListOutput<>(codec), key);
     }
 
-    public Command<K, V, String> info(String section) {
-        LettuceAssert.notNull(section, "Section " + MUST_NOT_BE_NULL);
+    Command<K, V, Long> hkeys(KeyStreamingChannel<K> channel, K key) {
+        notNullKey(key);
+        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(section);
-        return createCommand(INFO, new StatusOutput<K, V>(codec), args);
+        return createCommand(HKEYS, new KeyStreamingOutput<>(codec, channel), key);
     }
 
-    public Command<K, V, List<K>> keys(K pattern) {
-        LettuceAssert.notNull(pattern, "Pattern " + MUST_NOT_BE_NULL);
+    Command<K, V, Long> hlen(K key) {
+        notNullKey(key);
 
-        return createCommand(KEYS, new KeyListOutput<K, V>(codec), pattern);
+        return createCommand(HLEN, new IntegerOutput<>(codec), key);
     }
 
-    public Command<K, V, Long> keys(KeyStreamingChannel<K> channel, K pattern) {
-        LettuceAssert.notNull(pattern, "Pattern " + MUST_NOT_BE_NULL);
-        notNull(channel);
-
-        return createCommand(KEYS, new KeyStreamingOutput<K, V>(codec, channel), pattern);
-    }
+    Command<K, V, List<V>> hmget(K key, K... fields) {
+        notNullKey(key);
+        LettuceAssert.notNull(fields, "Fields " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(fields, "Fields " + MUST_NOT_BE_EMPTY);
 
-    public Command<K, V, Date> lastsave() {
-        return createCommand(LASTSAVE, new DateOutput<K, V>(codec));
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKeys(fields);
+        return createCommand(HMGET, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, V> lindex(K key, long index) {
+    Command<K, V, Long> hmget(ValueStreamingChannel<V> channel, K key, K... fields) {
         notNullKey(key);
+        LettuceAssert.notNull(fields, "Fields " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(fields, "Fields " + MUST_NOT_BE_EMPTY);
+        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(index);
-        return createCommand(LINDEX, new ValueOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKeys(fields);
+        return createCommand(HMGET, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> linsert(K key, boolean before, V pivot, V value) {
+    Command<K, V, String> hmset(K key, Map<K, V> map) {
         notNullKey(key);
+        LettuceAssert.notNull(map, "Map " + MUST_NOT_BE_NULL);
+        LettuceAssert.isTrue(!map.isEmpty(), "Map " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(before ? BEFORE : AFTER).addValue(pivot).addValue(value);
-        return createCommand(LINSERT, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(map);
+        return createCommand(HMSET, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> llen(K key) {
+    Command<K, V, MapScanCursor<K, V>> hscan(K key) {
         notNullKey(key);
 
-        return createCommand(LLEN, new IntegerOutput<K, V>(codec), key);
+        return hscan(key, ScanCursor.INITIAL, null);
     }
 
-    public Command<K, V, V> lpop(K key) {
+    Command<K, V, MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor) {
         notNullKey(key);
 
-        return createCommand(LPOP, new ValueOutput<K, V>(codec), key);
+        return hscan(key, scanCursor, null);
     }
 
-    public Command<K, V, Long> lpush(K key, V... values) {
+    Command<K, V, MapScanCursor<K, V>> hscan(K key, ScanArgs scanArgs) {
         notNullKey(key);
-        notEmptyValues(values);
 
-        return createCommand(LPUSH, new IntegerOutput<K, V>(codec), key, values);
+        return hscan(key, ScanCursor.INITIAL, scanArgs);
     }
 
-    public Command<K, V, Long> lpushx(K key, V... values) {
+    Command<K, V, MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
         notNullKey(key);
-        notEmptyValues(values);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addValues(values);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key);
+
+        scanArgs(scanCursor, scanArgs, args);
 
-        return createCommand(LPUSHX, new IntegerOutput<K, V>(codec), args);
+        MapScanOutput<K, V> output = new MapScanOutput<>(codec);
+        return createCommand(HSCAN, output, args);
     }
 
-    public Command<K, V, List<V>> lrange(K key, long start, long stop) {
+    Command<K, V, StreamScanCursor> hscanStreaming(KeyValueStreamingChannel<K, V> channel, K key) {
         notNullKey(key);
+        notNull(channel);
+
+        return hscanStreaming(channel, key, ScanCursor.INITIAL, null);
+    }
+
+    Command<K, V, StreamScanCursor> hscanStreaming(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor) {
+        notNullKey(key);
+        notNull(channel);
+
+        return hscanStreaming(channel, key, scanCursor, null);
+    }
+
+    Command<K, V, StreamScanCursor> hscanStreaming(KeyValueStreamingChannel<K, V> channel, K key, ScanArgs scanArgs) {
+        notNullKey(key);
+        notNull(channel);
+
+        return hscanStreaming(channel, key, ScanCursor.INITIAL, scanArgs);
+    }
+
+    Command<K, V, StreamScanCursor> hscanStreaming(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor,
+            ScanArgs scanArgs) {
+        notNullKey(key);
+        notNull(channel);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+
+        args.addKey(key);
+        scanArgs(scanCursor, scanArgs, args);
+
+        KeyValueScanStreamingOutput<K, V> output = new KeyValueScanStreamingOutput<>(codec, channel);
+        return createCommand(HSCAN, output, args);
+    }
+
+    Command<K, V, Boolean> hset(K key, K field, V value) {
+        notNullKey(key);
+        LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKey(field).addValue(value);
+        return createCommand(HSET, new BooleanOutput<>(codec), args);
+    }
+
+    Command<K, V, Boolean> hsetnx(K key, K field, V value) {
+        notNullKey(key);
+        LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKey(field).addValue(value);
+        return createCommand(HSETNX, new BooleanOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> hstrlen(K key, K field) {
+        notNullKey(key);
+        LettuceAssert.notNull(field, "Field " + MUST_NOT_BE_NULL);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKey(field);
+        return createCommand(HSTRLEN, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, List<V>> hvals(K key) {
+        notNullKey(key);
+
+        return createCommand(HVALS, new ValueListOutput<>(codec), key);
+    }
+
+    Command<K, V, Long> hvals(ValueStreamingChannel<V> channel, K key) {
+        notNullKey(key);
+        notNull(channel);
+
+        return createCommand(HVALS, new ValueStreamingOutput<>(codec, channel), key);
+    }
+
+    Command<K, V, Long> incr(K key) {
+        notNullKey(key);
+
+        return createCommand(INCR, new IntegerOutput<>(codec), key);
+    }
+
+    Command<K, V, Long> incrby(K key, long amount) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(amount);
+        return createCommand(INCRBY, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, Double> incrbyfloat(K key, double amount) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(amount);
+        return createCommand(INCRBYFLOAT, new DoubleOutput<>(codec), args);
+    }
+
+    Command<K, V, String> info() {
+        return createCommand(INFO, new StatusOutput<>(codec));
+    }
+
+    Command<K, V, String> info(String section) {
+        LettuceAssert.notNull(section, "Section " + MUST_NOT_BE_NULL);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(section);
+        return createCommand(INFO, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, List<K>> keys(K pattern) {
+        LettuceAssert.notNull(pattern, "Pattern " + MUST_NOT_BE_NULL);
+
+        return createCommand(KEYS, new KeyListOutput<>(codec), pattern);
+    }
+
+    Command<K, V, Long> keys(KeyStreamingChannel<K> channel, K pattern) {
+        LettuceAssert.notNull(pattern, "Pattern " + MUST_NOT_BE_NULL);
+        notNull(channel);
+
+        return createCommand(KEYS, new KeyStreamingOutput<>(codec, channel), pattern);
+    }
+
+    Command<K, V, Date> lastsave() {
+        return createCommand(LASTSAVE, new DateOutput<>(codec));
+    }
+
+    Command<K, V, V> lindex(K key, long index) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(index);
+        return createCommand(LINDEX, new ValueOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> linsert(K key, boolean before, V pivot, V value) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(before ? BEFORE : AFTER).addValue(pivot).addValue(value);
+        return createCommand(LINSERT, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> llen(K key) {
+        notNullKey(key);
+
+        return createCommand(LLEN, new IntegerOutput<>(codec), key);
+    }
+
+    Command<K, V, V> lpop(K key) {
+        notNullKey(key);
+
+        return createCommand(LPOP, new ValueOutput<>(codec), key);
+    }
+
+    Command<K, V, Long> lpush(K key, V... values) {
+        notNullKey(key);
+        notEmptyValues(values);
+
+        return createCommand(LPUSH, new IntegerOutput<>(codec), key, values);
+    }
+
+    Command<K, V, Long> lpushx(K key, V... values) {
+        notNullKey(key);
+        notEmptyValues(values);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addValues(values);
+
+        return createCommand(LPUSHX, new IntegerOutput<>(codec), args);
+    }
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(start).add(stop);
-        return createCommand(LRANGE, new ValueListOutput<K, V>(codec), args);
+    Command<K, V, List<V>> lrange(K key, long start, long stop) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(start).add(stop);
+        return createCommand(LRANGE, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> lrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
+    Command<K, V, Long> lrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
         notNullKey(key);
         notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(start).add(stop);
-        return createCommand(LRANGE, new ValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(start).add(stop);
+        return createCommand(LRANGE, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> lrem(K key, long count, V value) {
+    Command<K, V, Long> lrem(K key, long count, V value) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(count).addValue(value);
-        return createCommand(LREM, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(count).addValue(value);
+        return createCommand(LREM, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, String> lset(K key, long index, V value) {
+    Command<K, V, String> lset(K key, long index, V value) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(index).addValue(value);
-        return createCommand(LSET, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(index).addValue(value);
+        return createCommand(LSET, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> ltrim(K key, long start, long stop) {
+    Command<K, V, String> ltrim(K key, long start, long stop) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(start).add(stop);
-        return createCommand(LTRIM, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(start).add(stop);
+        return createCommand(LTRIM, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, List<V>> mget(K... keys) {
+        notEmpty(keys);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(MGET, new ValueListOutput<>(codec), args);
+    }
+
+    Command<K, V, List<V>> mget(Iterable<K> keys) {
+        LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(MGET, new ValueListOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> mget(ValueStreamingChannel<V> channel, K... keys) {
+        notEmpty(keys);
+        notNull(channel);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(MGET, new ValueStreamingOutput<>(codec, channel), args);
+    }
+
+    Command<K, V, Long> mget(ValueStreamingChannel<V> channel, Iterable<K> keys) {
+        LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
+        notNull(channel);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(MGET, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, String> migrate(String host, int port, K key, int db, long timeout) {
+    Command<K, V, String> migrate(String host, int port, K key, int db, long timeout) {
         LettuceAssert.notNull(host, "Host " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(host, "Host " + MUST_NOT_BE_EMPTY);
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.add(host).add(port).addKey(key).add(db).add(timeout);
-        return createCommand(MIGRATE, new StatusOutput<K, V>(codec), args);
+        return createCommand(MIGRATE, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> migrate(String host, int port, int db, long timeout, MigrateArgs<K> migrateArgs) {
+    Command<K, V, String> migrate(String host, int port, int db, long timeout, MigrateArgs<K> migrateArgs) {
         LettuceAssert.notNull(host, "Host " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(host, "Host " + MUST_NOT_BE_EMPTY);
         LettuceAssert.notNull(migrateArgs, "migrateArgs " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
 
         args.add(host).add(port);
 
@@ -800,638 +1193,798 @@ public Command<K, V, String> migrate(String host, int port, int db, long timeout
         args.add(db).add(timeout);
         migrateArgs.build(args);
 
-        return createCommand(MIGRATE, new StatusOutput<K, V>(codec), args);
+        return createCommand(MIGRATE, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, List<V>> mget(K... keys) {
-        notEmpty(keys);
+    Command<K, V, Boolean> move(K key, int db) {
+        notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(MGET, new ValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(db);
+        return createCommand(MOVE, new BooleanOutput<>(codec), args);
     }
 
-    public Command<K, V, List<V>> mget(Iterable<K> keys) {
-        LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
+    Command<K, V, String> mset(Map<K, V> map) {
+        LettuceAssert.notNull(map, "Map " + MUST_NOT_BE_NULL);
+        LettuceAssert.isTrue(!map.isEmpty(), "Map " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(MGET, new ValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(map);
+        return createCommand(MSET, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> mget(ValueStreamingChannel<V> channel, K... keys) {
-        notEmpty(keys);
-        notNull(channel);
+    Command<K, V, Boolean> msetnx(Map<K, V> map) {
+        LettuceAssert.notNull(map, "Map " + MUST_NOT_BE_NULL);
+        LettuceAssert.isTrue(!map.isEmpty(), "Map " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(MGET, new ValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(map);
+        return createCommand(MSETNX, new BooleanOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> mget(ValueStreamingChannel<V> channel, Iterable<K> keys) {
-        LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
-        notNull(channel);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(MGET, new ValueStreamingOutput<K, V>(codec, channel), args);
+    Command<K, V, String> multi() {
+        return createCommand(MULTI, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, Boolean> move(K key, int db) {
+    Command<K, V, String> objectEncoding(K key) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(db);
-        return createCommand(MOVE, new BooleanOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(ENCODING).addKey(key);
+        return createCommand(OBJECT, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> multi() {
-        return createCommand(MULTI, new StatusOutput<K, V>(codec));
+    Command<K, V, Long> objectIdletime(K key) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(IDLETIME).addKey(key);
+        return createCommand(OBJECT, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, String> mset(Map<K, V> map) {
-        LettuceAssert.notNull(map, "Map " + MUST_NOT_BE_NULL);
-        LettuceAssert.isTrue(!map.isEmpty(), "Map " + MUST_NOT_BE_EMPTY);
+    Command<K, V, Long> objectRefcount(K key) {
+        notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(map);
-        return createCommand(MSET, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(REFCOUNT).addKey(key);
+        return createCommand(OBJECT, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Boolean> msetnx(Map<K, V> map) {
-        LettuceAssert.notNull(map, "Map " + MUST_NOT_BE_NULL);
-        LettuceAssert.isTrue(!map.isEmpty(), "Map " + MUST_NOT_BE_EMPTY);
+    Command<K, V, Boolean> persist(K key) {
+        notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(map);
-        return createCommand(MSETNX, new BooleanOutput<K, V>(codec), args);
+        return createCommand(PERSIST, new BooleanOutput<>(codec), key);
     }
 
-    public Command<K, V, String> objectEncoding(K key) {
+    Command<K, V, Boolean> pexpire(K key, long milliseconds) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(ENCODING).addKey(key);
-        return createCommand(OBJECT, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(milliseconds);
+        return createCommand(PEXPIRE, new BooleanOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> objectIdletime(K key) {
+    Command<K, V, Boolean> pexpireat(K key, long timestamp) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(IDLETIME).addKey(key);
-        return createCommand(OBJECT, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(timestamp);
+        return createCommand(PEXPIREAT, new BooleanOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> objectRefcount(K key) {
+    Command<K, V, Long> pfadd(K key, V value, V... moreValues) {
         notNullKey(key);
+        LettuceAssert.notNull(value, "Value " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(moreValues, "MoreValues " + MUST_NOT_BE_NULL);
+        LettuceAssert.noNullElements(moreValues, "MoreValues " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(REFCOUNT).addKey(key);
-        return createCommand(OBJECT, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addValue(value).addValues(moreValues);
+        return createCommand(PFADD, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Boolean> persist(K key) {
+    Command<K, V, Long> pfadd(K key, V... values) {
         notNullKey(key);
+        notEmptyValues(values);
+        LettuceAssert.noNullElements(values, "Values " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
 
-        return createCommand(PERSIST, new BooleanOutput<K, V>(codec), key);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addValues(values);
+        return createCommand(PFADD, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Boolean> pexpire(K key, long milliseconds) {
+    Command<K, V, Long> pfcount(K key, K... moreKeys) {
         notNullKey(key);
+        LettuceAssert.notNull(moreKeys, "MoreKeys " + MUST_NOT_BE_NULL);
+        LettuceAssert.noNullElements(moreKeys, "MoreKeys " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(milliseconds);
-        return createCommand(PEXPIRE, new BooleanOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKeys(moreKeys);
+        return createCommand(PFCOUNT, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Boolean> pexpireat(K key, long timestamp) {
-        notNullKey(key);
+    Command<K, V, Long> pfcount(K... keys) {
+        notEmpty(keys);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(PFCOUNT, new IntegerOutput<>(codec), args);
+    }
+
+    @SuppressWarnings("unchecked")
+    Command<K, V, String> pfmerge(K destkey, K sourcekey, K... moreSourceKeys) {
+        LettuceAssert.notNull(destkey, "Destkey " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(sourcekey, "Sourcekey " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(moreSourceKeys, "MoreSourceKeys " + MUST_NOT_BE_NULL);
+        LettuceAssert.noNullElements(moreSourceKeys, "MoreSourceKeys " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(timestamp);
-        return createCommand(PEXPIREAT, new BooleanOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(destkey).addKey(sourcekey).addKeys(moreSourceKeys);
+        return createCommand(PFMERGE, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> ping() {
-        return createCommand(PING, new StatusOutput<K, V>(codec));
+    @SuppressWarnings("unchecked")
+    Command<K, V, String> pfmerge(K destkey, K... sourcekeys) {
+        LettuceAssert.notNull(destkey, "Destkey " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(sourcekeys, "Sourcekeys " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(sourcekeys, "Sourcekeys " + MUST_NOT_BE_EMPTY);
+        LettuceAssert.noNullElements(sourcekeys, "Sourcekeys " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(destkey).addKeys(sourcekeys);
+        return createCommand(PFMERGE, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> readOnly() {
-        return createCommand(READONLY, new StatusOutput<K, V>(codec));
+    Command<K, V, String> ping() {
+        return createCommand(PING, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, String> readWrite() {
-        return createCommand(READWRITE, new StatusOutput<K, V>(codec));
+    Command<K, V, String> psetex(K key, long milliseconds, V value) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(milliseconds).addValue(value);
+        return createCommand(PSETEX, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> pttl(K key) {
+    Command<K, V, Long> pttl(K key) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key);
-        return createCommand(PTTL, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key);
+        return createCommand(PTTL, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> publish(K channel, V message) {
+    Command<K, V, Long> publish(K channel, V message) {
         LettuceAssert.notNull(channel, "Channel " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(channel).addValue(message);
-        return createCommand(PUBLISH, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(channel).addValue(message);
+        return createCommand(PUBLISH, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, List<K>> pubsubChannels() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(CHANNELS);
-        return createCommand(PUBSUB, new KeyListOutput<K, V>(codec), args);
+    Command<K, V, List<K>> pubsubChannels() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(CHANNELS);
+        return createCommand(PUBSUB, new KeyListOutput<>(codec), args);
     }
 
-    public Command<K, V, List<K>> pubsubChannels(K pattern) {
+    Command<K, V, List<K>> pubsubChannels(K pattern) {
         LettuceAssert.notNull(pattern, "Pattern " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(CHANNELS).addKey(pattern);
-        return createCommand(PUBSUB, new KeyListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(CHANNELS).addKey(pattern);
+        return createCommand(PUBSUB, new KeyListOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> pubsubNumpat() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(NUMPAT);
+        return createCommand(PUBSUB, new IntegerOutput<>(codec), args);
     }
 
     @SuppressWarnings({ "unchecked", "rawtypes" })
-    public Command<K, V, Map<K, Long>> pubsubNumsub(K... pattern) {
+    Command<K, V, Map<K, Long>> pubsubNumsub(K... pattern) {
         LettuceAssert.notNull(pattern, "Pattern " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(pattern, "Pattern " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(NUMSUB).addKeys(pattern);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(NUMSUB).addKeys(pattern);
         return createCommand(PUBSUB, (MapOutput) new MapOutput<K, Long>((RedisCodec) codec), args);
     }
 
-    public Command<K, V, Long> pubsubNumpat() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(NUMPAT);
-        return createCommand(PUBSUB, new IntegerOutput<K, V>(codec), args);
+    Command<K, V, String> quit() {
+        return createCommand(QUIT, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, String> quit() {
-        return createCommand(QUIT, new StatusOutput<K, V>(codec));
+    Command<K, V, V> randomkey() {
+        return createCommand(RANDOMKEY, new ValueOutput<>(codec));
     }
 
-    public Command<K, V, V> randomkey() {
-        return createCommand(RANDOMKEY, new ValueOutput<K, V>(codec));
+    Command<K, V, String> readOnly() {
+        return createCommand(READONLY, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, List<Object>> role() {
-        return createCommand(ROLE, new ArrayOutput<K, V>(codec));
+    Command<K, V, String> readWrite() {
+        return createCommand(READWRITE, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, String> rename(K key, K newKey) {
+    Command<K, V, String> rename(K key, K newKey) {
         notNullKey(key);
         LettuceAssert.notNull(newKey, "NewKey " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKey(newKey);
-        return createCommand(RENAME, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKey(newKey);
+        return createCommand(RENAME, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, Boolean> renamenx(K key, K newKey) {
+    Command<K, V, Boolean> renamenx(K key, K newKey) {
         notNullKey(key);
         LettuceAssert.notNull(newKey, "NewKey " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKey(newKey);
-        return createCommand(RENAMENX, new BooleanOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addKey(newKey);
+        return createCommand(RENAMENX, new BooleanOutput<>(codec), args);
     }
 
-    public Command<K, V, String> restore(K key, long ttl, byte[] value) {
+    Command<K, V, String> restore(K key, long ttl, byte[] value) {
         notNullKey(key);
         LettuceAssert.notNull(value, "Value " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(ttl).add(value);
-        return createCommand(RESTORE, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(ttl).add(value);
+        return createCommand(RESTORE, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, List<Object>> role() {
+        return createCommand(ROLE, new ArrayOutput<>(codec));
     }
 
-    public Command<K, V, V> rpop(K key) {
+    Command<K, V, V> rpop(K key) {
         notNullKey(key);
 
-        return createCommand(RPOP, new ValueOutput<K, V>(codec), key);
+        return createCommand(RPOP, new ValueOutput<>(codec), key);
     }
 
-    public Command<K, V, V> rpoplpush(K source, K destination) {
+    Command<K, V, V> rpoplpush(K source, K destination) {
         LettuceAssert.notNull(source, "Source " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(source).addKey(destination);
-        return createCommand(RPOPLPUSH, new ValueOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(source).addKey(destination);
+        return createCommand(RPOPLPUSH, new ValueOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> rpush(K key, V... values) {
+    Command<K, V, Long> rpush(K key, V... values) {
         notNullKey(key);
         notEmptyValues(values);
 
-        return createCommand(RPUSH, new IntegerOutput<K, V>(codec), key, values);
+        return createCommand(RPUSH, new IntegerOutput<>(codec), key, values);
     }
 
-    public Command<K, V, Long> rpushx(K key, V... values) {
+    Command<K, V, Long> rpushx(K key, V... values) {
         notNullKey(key);
         notEmptyValues(values);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addValues(values);
-        return createCommand(RPUSHX, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addValues(values);
+        return createCommand(RPUSHX, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> sadd(K key, V... members) {
+    Command<K, V, Long> sadd(K key, V... members) {
         notNullKey(key);
         LettuceAssert.notNull(members, "Members " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(members, "Members " + MUST_NOT_BE_EMPTY);
 
-        return createCommand(SADD, new IntegerOutput<K, V>(codec), key, members);
+        return createCommand(SADD, new IntegerOutput<>(codec), key, members);
+    }
+
+    Command<K, V, String> save() {
+        return createCommand(SAVE, new StatusOutput<>(codec));
+    }
+
+    Command<K, V, KeyScanCursor<K>> scan() {
+        return scan(ScanCursor.INITIAL, null);
+    }
+
+    Command<K, V, KeyScanCursor<K>> scan(ScanCursor scanCursor) {
+        return scan(scanCursor, null);
+    }
+
+    Command<K, V, KeyScanCursor<K>> scan(ScanArgs scanArgs) {
+        return scan(ScanCursor.INITIAL, scanArgs);
+    }
+
+    Command<K, V, KeyScanCursor<K>> scan(ScanCursor scanCursor, ScanArgs scanArgs) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+
+        scanArgs(scanCursor, scanArgs, args);
+
+        KeyScanOutput<K, V> output = new KeyScanOutput<>(codec);
+        return createCommand(SCAN, output, args);
+    }
+
+    protected void scanArgs(ScanCursor scanCursor, ScanArgs scanArgs, CommandArgs<K, V> args) {
+        LettuceAssert.notNull(scanCursor, "ScanCursor " + MUST_NOT_BE_NULL);
+        LettuceAssert.isTrue(!scanCursor.isFinished(), "ScanCursor must not be finished");
+
+        args.add(scanCursor.getCursor());
+
+        if (scanArgs != null) {
+            scanArgs.build(args);
+        }
+    }
+
+    Command<K, V, StreamScanCursor> scanStreaming(KeyStreamingChannel<K> channel) {
+        notNull(channel);
+        LettuceAssert.notNull(channel, "KeyStreamingChannel " + MUST_NOT_BE_NULL);
+
+        return scanStreaming(channel, ScanCursor.INITIAL, null);
+    }
+
+    Command<K, V, StreamScanCursor> scanStreaming(KeyStreamingChannel<K> channel, ScanCursor scanCursor) {
+        notNull(channel);
+        LettuceAssert.notNull(channel, "KeyStreamingChannel " + MUST_NOT_BE_NULL);
+
+        return scanStreaming(channel, scanCursor, null);
+    }
+
+    Command<K, V, StreamScanCursor> scanStreaming(KeyStreamingChannel<K> channel, ScanArgs scanArgs) {
+        notNull(channel);
+        LettuceAssert.notNull(channel, "KeyStreamingChannel " + MUST_NOT_BE_NULL);
+
+        return scanStreaming(channel, ScanCursor.INITIAL, scanArgs);
     }
 
-    public Command<K, V, String> save() {
-        return createCommand(SAVE, new StatusOutput<K, V>(codec));
+    Command<K, V, StreamScanCursor> scanStreaming(KeyStreamingChannel<K> channel, ScanCursor scanCursor, ScanArgs scanArgs) {
+        notNull(channel);
+        LettuceAssert.notNull(channel, "KeyStreamingChannel " + MUST_NOT_BE_NULL);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        scanArgs(scanCursor, scanArgs, args);
+
+        KeyScanStreamingOutput<K, V> output = new KeyScanStreamingOutput<>(codec, channel);
+        return createCommand(SCAN, output, args);
     }
 
-    public Command<K, V, Long> scard(K key) {
+    Command<K, V, Long> scard(K key) {
         notNullKey(key);
 
-        return createCommand(SCARD, new IntegerOutput<K, V>(codec), key);
+        return createCommand(SCARD, new IntegerOutput<>(codec), key);
     }
 
-    public Command<K, V, List<Boolean>> scriptExists(String... digests) {
+    Command<K, V, List<Boolean>> scriptExists(String... digests) {
         LettuceAssert.notNull(digests, "Digests " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(digests, "Digests " + MUST_NOT_BE_EMPTY);
         LettuceAssert.noNullElements(digests, "Digests " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(EXISTS);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(EXISTS);
         for (String sha : digests) {
             args.add(sha);
         }
-        return createCommand(SCRIPT, new BooleanListOutput<K, V>(codec), args);
+        return createCommand(SCRIPT, new BooleanListOutput<>(codec), args);
     }
 
-    public Command<K, V, String> scriptFlush() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(FLUSH);
-        return createCommand(SCRIPT, new StatusOutput<K, V>(codec), args);
+    Command<K, V, String> scriptFlush() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(FLUSH);
+        return createCommand(SCRIPT, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> scriptKill() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(KILL);
-        return createCommand(SCRIPT, new StatusOutput<K, V>(codec), args);
+    Command<K, V, String> scriptKill() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(KILL);
+        return createCommand(SCRIPT, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> scriptLoad(V script) {
+    Command<K, V, String> scriptLoad(V script) {
         LettuceAssert.notNull(script, "Script " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(LOAD).addValue(script);
-        return createCommand(SCRIPT, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(LOAD).addValue(script);
+        return createCommand(SCRIPT, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, Set<V>> sdiff(K... keys) {
+    Command<K, V, Set<V>> sdiff(K... keys) {
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(SDIFF, new ValueSetOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(SDIFF, new ValueSetOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> sdiff(ValueStreamingChannel<V> channel, K... keys) {
+    Command<K, V, Long> sdiff(ValueStreamingChannel<V> channel, K... keys) {
         notEmpty(keys);
         notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(SDIFF, new ValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(SDIFF, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> sdiffstore(K destination, K... keys) {
+    Command<K, V, Long> sdiffstore(K destination, K... keys) {
         notEmpty(keys);
         LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(destination).addKeys(keys);
-        return createCommand(SDIFFSTORE, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> select(int db) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(db);
-        return createCommand(SELECT, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(destination).addKeys(keys);
+        return createCommand(SDIFFSTORE, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, String> swapdb(int db1, int db2) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(db1).add(db2);
-        return createCommand(SWAPDB, new StatusOutput<K, V>(codec), args);
+    Command<K, V, String> select(int db) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(db);
+        return createCommand(SELECT, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> set(K key, V value) {
+    Command<K, V, String> set(K key, V value) {
         notNullKey(key);
 
-        return createCommand(SET, new StatusOutput<K, V>(codec), key, value);
+        return createCommand(SET, new StatusOutput<>(codec), key, value);
     }
 
-    public Command<K, V, String> set(K key, V value, SetArgs setArgs) {
+    Command<K, V, String> set(K key, V value, SetArgs setArgs) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addValue(value);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).addValue(value);
         setArgs.build(args);
-        return createCommand(SET, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> setbit(K key, long offset, int value) {
-        notNullKey(key);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(offset).add(value);
-        return createCommand(SETBIT, new IntegerOutput<K, V>(codec), args);
+        return createCommand(SET, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> setex(K key, long seconds, V value) {
+    Command<K, V, Long> setbit(K key, long offset, int value) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(seconds).addValue(value);
-        return createCommand(SETEX, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(offset).add(value);
+        return createCommand(SETBIT, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, String> psetex(K key, long milliseconds, V value) {
+    Command<K, V, String> setex(K key, long seconds, V value) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(milliseconds).addValue(value);
-        return createCommand(PSETEX, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(seconds).addValue(value);
+        return createCommand(SETEX, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, Boolean> setnx(K key, V value) {
+    Command<K, V, Boolean> setnx(K key, V value) {
         notNullKey(key);
-        return createCommand(SETNX, new BooleanOutput<K, V>(codec), key, value);
+        return createCommand(SETNX, new BooleanOutput<>(codec), key, value);
     }
 
-    public Command<K, V, Long> setrange(K key, long offset, V value) {
+    Command<K, V, Long> setrange(K key, long offset, V value) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(offset).addValue(value);
-        return createCommand(SETRANGE, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(offset).addValue(value);
+        return createCommand(SETRANGE, new IntegerOutput<>(codec), args);
     }
 
     @Deprecated
-    public Command<K, V, String> shutdown() {
-        return createCommand(SHUTDOWN, new StatusOutput<K, V>(codec));
+    Command<K, V, String> shutdown() {
+        return createCommand(SHUTDOWN, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, String> shutdown(boolean save) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        return createCommand(SHUTDOWN, new StatusOutput<K, V>(codec), save ? args.add(SAVE) : args.add(NOSAVE));
+    Command<K, V, String> shutdown(boolean save) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        return createCommand(SHUTDOWN, new StatusOutput<>(codec), save ? args.add(SAVE) : args.add(NOSAVE));
     }
 
-    public Command<K, V, Set<V>> sinter(K... keys) {
+    Command<K, V, Set<V>> sinter(K... keys) {
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(SINTER, new ValueSetOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(SINTER, new ValueSetOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> sinter(ValueStreamingChannel<V> channel, K... keys) {
+    Command<K, V, Long> sinter(ValueStreamingChannel<V> channel, K... keys) {
         notEmpty(keys);
         notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(SINTER, new ValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(SINTER, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> sinterstore(K destination, K... keys) {
+    Command<K, V, Long> sinterstore(K destination, K... keys) {
         LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(destination).addKeys(keys);
-        return createCommand(SINTERSTORE, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(destination).addKeys(keys);
+        return createCommand(SINTERSTORE, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Boolean> sismember(K key, V member) {
+    Command<K, V, Boolean> sismember(K key, V member) {
         notNullKey(key);
-        return createCommand(SISMEMBER, new BooleanOutput<K, V>(codec), key, member);
-    }
-
-    public Command<K, V, Boolean> smove(K source, K destination, V member) {
-        LettuceAssert.notNull(source, "Source " + MUST_NOT_BE_NULL);
-        LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(source).addKey(destination).addValue(member);
-        return createCommand(SMOVE, new BooleanOutput<K, V>(codec), args);
+        return createCommand(SISMEMBER, new BooleanOutput<>(codec), key, member);
     }
 
-    public Command<K, V, String> slaveof(String host, int port) {
+    Command<K, V, String> slaveof(String host, int port) {
         LettuceAssert.notNull(host, "Host " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(host, "Host " + MUST_NOT_BE_EMPTY);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(host).add(port);
-        return createCommand(SLAVEOF, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(host).add(port);
+        return createCommand(SLAVEOF, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, String> slaveofNoOne() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(NO).add(ONE);
-        return createCommand(SLAVEOF, new StatusOutput<K, V>(codec), args);
+    Command<K, V, String> slaveofNoOne() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(NO).add(ONE);
+        return createCommand(SLAVEOF, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, List<Object>> slowlogGet() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(GET);
-        return createCommand(SLOWLOG, new NestedMultiOutput<K, V>(codec), args);
+    Command<K, V, List<Object>> slowlogGet() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(GET);
+        return createCommand(SLOWLOG, new NestedMultiOutput<>(codec), args);
     }
 
-    public Command<K, V, List<Object>> slowlogGet(int count) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(GET).add(count);
-        return createCommand(SLOWLOG, new NestedMultiOutput<K, V>(codec), args);
+    Command<K, V, List<Object>> slowlogGet(int count) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(GET).add(count);
+        return createCommand(SLOWLOG, new NestedMultiOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> slowlogLen() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(LEN);
-        return createCommand(SLOWLOG, new IntegerOutput<K, V>(codec), args);
+    Command<K, V, Long> slowlogLen() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(LEN);
+        return createCommand(SLOWLOG, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, String> slowlogReset() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(RESET);
-        return createCommand(SLOWLOG, new StatusOutput<K, V>(codec), args);
+    Command<K, V, String> slowlogReset() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(RESET);
+        return createCommand(SLOWLOG, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, Set<V>> smembers(K key) {
+    Command<K, V, Set<V>> smembers(K key) {
         notNullKey(key);
 
-        return createCommand(SMEMBERS, new ValueSetOutput<K, V>(codec), key);
+        return createCommand(SMEMBERS, new ValueSetOutput<>(codec), key);
     }
 
-    public Command<K, V, Long> smembers(ValueStreamingChannel<V> channel, K key) {
+    Command<K, V, Long> smembers(ValueStreamingChannel<V> channel, K key) {
         notNullKey(key);
         notNull(channel);
 
-        return createCommand(SMEMBERS, new ValueStreamingOutput<K, V>(codec, channel), key);
+        return createCommand(SMEMBERS, new ValueStreamingOutput<>(codec, channel), key);
     }
 
-    public Command<K, V, List<V>> sort(K key) {
+    Command<K, V, Boolean> smove(K source, K destination, V member) {
+        LettuceAssert.notNull(source, "Source " + MUST_NOT_BE_NULL);
+        LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(source).addKey(destination).addValue(member);
+        return createCommand(SMOVE, new BooleanOutput<>(codec), args);
+    }
+
+    Command<K, V, List<V>> sort(K key) {
         notNullKey(key);
 
-        return createCommand(SORT, new ValueListOutput<K, V>(codec), key);
+        return createCommand(SORT, new ValueListOutput<>(codec), key);
     }
 
-    public Command<K, V, List<V>> sort(K key, SortArgs sortArgs) {
+    Command<K, V, List<V>> sort(K key, SortArgs sortArgs) {
         notNullKey(key);
         LettuceAssert.notNull(sortArgs, "SortArgs " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key);
         sortArgs.build(args, null);
-        return createCommand(SORT, new ValueListOutput<K, V>(codec), args);
+        return createCommand(SORT, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> sort(ValueStreamingChannel<V> channel, K key) {
+    Command<K, V, Long> sort(ValueStreamingChannel<V> channel, K key) {
         notNullKey(key);
         notNull(channel);
 
-        return createCommand(SORT, new ValueStreamingOutput<K, V>(codec, channel), key);
+        return createCommand(SORT, new ValueStreamingOutput<>(codec, channel), key);
     }
 
-    public Command<K, V, Long> sort(ValueStreamingChannel<V> channel, K key, SortArgs sortArgs) {
+    Command<K, V, Long> sort(ValueStreamingChannel<V> channel, K key, SortArgs sortArgs) {
         notNullKey(key);
         notNull(channel);
         LettuceAssert.notNull(sortArgs, "SortArgs " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key);
         sortArgs.build(args, null);
-        return createCommand(SORT, new ValueStreamingOutput<K, V>(codec, channel), args);
+        return createCommand(SORT, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> sortStore(K key, SortArgs sortArgs, K destination) {
+    Command<K, V, Long> sortStore(K key, SortArgs sortArgs, K destination) {
         notNullKey(key);
         LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(sortArgs, "SortArgs " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key);
         sortArgs.build(args, destination);
-        return createCommand(SORT, new IntegerOutput<K, V>(codec), args);
+        return createCommand(SORT, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, V> spop(K key) {
+    Command<K, V, V> spop(K key) {
         notNullKey(key);
 
-        return createCommand(SPOP, new ValueOutput<K, V>(codec), key);
+        return createCommand(SPOP, new ValueOutput<>(codec), key);
     }
 
-    public Command<K, V, Set<V>> spop(K key, long count) {
+    Command<K, V, Set<V>> spop(K key, long count) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(count);
-        return createCommand(SPOP, new ValueSetOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(count);
+        return createCommand(SPOP, new ValueSetOutput<>(codec), args);
     }
 
-    public Command<K, V, V> srandmember(K key) {
+    Command<K, V, V> srandmember(K key) {
         notNullKey(key);
 
-        return createCommand(SRANDMEMBER, new ValueOutput<K, V>(codec), key);
+        return createCommand(SRANDMEMBER, new ValueOutput<>(codec), key);
     }
 
-    public Command<K, V, List<V>> srandmember(K key, long count) {
+    Command<K, V, List<V>> srandmember(K key, long count) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(count);
-        return createCommand(SRANDMEMBER, new ValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(count);
+        return createCommand(SRANDMEMBER, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> srandmember(ValueStreamingChannel<V> channel, K key, long count) {
+    Command<K, V, Long> srandmember(ValueStreamingChannel<V> channel, K key, long count) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(count);
-        return createCommand(SRANDMEMBER, new ValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(count);
+        return createCommand(SRANDMEMBER, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> srem(K key, V... members) {
+    Command<K, V, Long> srem(K key, V... members) {
         notNullKey(key);
         LettuceAssert.notNull(members, "Members " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(members, "Members " + MUST_NOT_BE_EMPTY);
 
-        return createCommand(SREM, new IntegerOutput<K, V>(codec), key, members);
+        return createCommand(SREM, new IntegerOutput<>(codec), key, members);
     }
 
-    public Command<K, V, Set<V>> sunion(K... keys) {
-        notEmpty(keys);
+    Command<K, V, ValueScanCursor<V>> sscan(K key) {
+        notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(SUNION, new ValueSetOutput<K, V>(codec), args);
+        return sscan(key, ScanCursor.INITIAL, null);
     }
 
-    public Command<K, V, Long> sunion(ValueStreamingChannel<V> channel, K... keys) {
-        notEmpty(keys);
-        notNull(channel);
+    Command<K, V, ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor) {
+        notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(SUNION, new ValueStreamingOutput<K, V>(codec, channel), args);
+        return sscan(key, scanCursor, null);
     }
 
-    public Command<K, V, Long> sunionstore(K destination, K... keys) {
-        LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
-        notEmpty(keys);
+    Command<K, V, ValueScanCursor<V>> sscan(K key, ScanArgs scanArgs) {
+        notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(destination).addKeys(keys);
-        return createCommand(SUNIONSTORE, new IntegerOutput<K, V>(codec), args);
+        return sscan(key, ScanCursor.INITIAL, scanArgs);
     }
 
-    public Command<K, V, String> sync() {
-        return createCommand(SYNC, new StatusOutput<K, V>(codec));
+    Command<K, V, ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key);
+
+        scanArgs(scanCursor, scanArgs, args);
+
+        ValueScanOutput<K, V> output = new ValueScanOutput<>(codec);
+        return createCommand(SSCAN, output, args);
+    }
+
+    Command<K, V, StreamScanCursor> sscanStreaming(ValueStreamingChannel<V> channel, K key) {
+        notNullKey(key);
+        notNull(channel);
+
+        return sscanStreaming(channel, key, ScanCursor.INITIAL, null);
+    }
+
+    Command<K, V, StreamScanCursor> sscanStreaming(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor) {
+        notNullKey(key);
+        notNull(channel);
+
+        return sscanStreaming(channel, key, scanCursor, null);
+    }
+
+    Command<K, V, StreamScanCursor> sscanStreaming(ValueStreamingChannel<V> channel, K key, ScanArgs scanArgs) {
+        notNullKey(key);
+        notNull(channel);
+
+        return sscanStreaming(channel, key, ScanCursor.INITIAL, scanArgs);
+    }
+
+    Command<K, V, StreamScanCursor> sscanStreaming(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor,
+            ScanArgs scanArgs) {
+        notNullKey(key);
+        notNull(channel);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+
+        args.addKey(key);
+        scanArgs(scanCursor, scanArgs, args);
+
+        ValueScanStreamingOutput<K, V> output = new ValueScanStreamingOutput<>(codec, channel);
+        return createCommand(SSCAN, output, args);
     }
 
-    public Command<K, V, Long> strlen(K key) {
+    Command<K, V, Long> strlen(K key) {
         notNullKey(key);
 
-        return createCommand(STRLEN, new IntegerOutput<K, V>(codec), key);
+        return createCommand(STRLEN, new IntegerOutput<>(codec), key);
+    }
+
+    Command<K, V, Set<V>> sunion(K... keys) {
+        notEmpty(keys);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(SUNION, new ValueSetOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> sunion(ValueStreamingChannel<V> channel, K... keys) {
+        notEmpty(keys);
+        notNull(channel);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(SUNION, new ValueStreamingOutput<>(codec, channel), args);
+    }
+
+    Command<K, V, Long> sunionstore(K destination, K... keys) {
+        LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
+        notEmpty(keys);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(destination).addKeys(keys);
+        return createCommand(SUNIONSTORE, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, String> swapdb(int db1, int db2) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(db1).add(db2);
+        return createCommand(SWAPDB, new StatusOutput<>(codec), args);
+    }
+
+    Command<K, V, String> sync() {
+        return createCommand(SYNC, new StatusOutput<>(codec));
+    }
+
+    Command<K, V, List<V>> time() {
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        return createCommand(TIME, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> touch(K... keys) {
+    Command<K, V, Long> touch(K... keys) {
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(TOUCH, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(TOUCH, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> touch(Iterable<K> keys) {
+    Command<K, V, Long> touch(Iterable<K> keys) {
         LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(TOUCH, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(TOUCH, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> ttl(K key) {
+    Command<K, V, Long> ttl(K key) {
         notNullKey(key);
 
-        return createCommand(TTL, new IntegerOutput<K, V>(codec), key);
+        return createCommand(TTL, new IntegerOutput<>(codec), key);
     }
 
-    public Command<K, V, String> type(K key) {
+    Command<K, V, String> type(K key) {
         notNullKey(key);
 
-        return createCommand(TYPE, new StatusOutput<K, V>(codec), key);
+        return createCommand(TYPE, new StatusOutput<>(codec), key);
     }
 
-    public Command<K, V, String> watch(K... keys) {
+    Command<K, V, Long> unlink(K... keys) {
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(WATCH, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(UNLINK, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> wait(int replicas, long timeout) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(replicas).add(timeout);
+    Command<K, V, Long> unlink(Iterable<K> keys) {
+        LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
 
-        return createCommand(WAIT, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(UNLINK, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, String> unwatch() {
-        return createCommand(UNWATCH, new StatusOutput<K, V>(codec));
+    Command<K, V, String> unwatch() {
+        return createCommand(UNWATCH, new StatusOutput<>(codec));
     }
 
-    public Command<K, V, Long> zadd(K key, ZAddArgs zAddArgs, double score, V member) {
-        notNullKey(key);
+    Command<K, V, Long> wait(int replicas, long timeout) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).add(replicas).add(timeout);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key);
+        return createCommand(WAIT, new IntegerOutput<>(codec), args);
+    }
 
-        if (zAddArgs != null) {
-            zAddArgs.build(args);
-        }
-        args.add(score).addValue(member);
+    Command<K, V, String> watch(K... keys) {
+        notEmpty(keys);
 
-        return createCommand(ZADD, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKeys(keys);
+        return createCommand(WATCH, new StatusOutput<>(codec), args);
     }
 
-    public Command<K, V, Double> zaddincr(K key, ZAddArgs zAddArgs, double score, V member) {
+    Command<K, V, Long> zadd(K key, ZAddArgs zAddArgs, double score, V member) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key);
 
         if (zAddArgs != null) {
             zAddArgs.build(args);
         }
-
-        args.add(INCR);
         args.add(score).addValue(member);
 
-        return createCommand(ZADD, new DoubleOutput<K, V>(codec), args);
+        return createCommand(ZADD, new IntegerOutput<>(codec), args);
     }
 
     @SuppressWarnings("unchecked")
-    public Command<K, V, Long> zadd(K key, ZAddArgs zAddArgs, Object... scoresAndValues) {
+    Command<K, V, Long> zadd(K key, ZAddArgs zAddArgs, Object... scoresAndValues) {
         notNullKey(key);
         LettuceAssert.notNull(scoresAndValues, "ScoresAndValues " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(scoresAndValues, "ScoresAndValues " + MUST_NOT_BE_EMPTY);
         LettuceAssert.noNullElements(scoresAndValues, "ScoresAndValues " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key);
 
         if (zAddArgs != null) {
             zAddArgs.build(args);
@@ -1457,464 +2010,532 @@ public Command<K, V, Long> zadd(K key, ZAddArgs zAddArgs, Object... scoresAndVal
             }
         }
 
-        return createCommand(ZADD, new IntegerOutput<K, V>(codec), args);
+        return createCommand(ZADD, new IntegerOutput<>(codec), args);
     }
 
-    private boolean allElementsInstanceOf(Object[] objects, Class<?> expectedAssignableType) {
+    Command<K, V, Double> zaddincr(K key, ZAddArgs zAddArgs, double score, V member) {
+        notNullKey(key);
 
-        for (Object object : objects) {
-            if (!expectedAssignableType.isAssignableFrom(object.getClass())) {
-                return false;
-            }
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key);
+
+        if (zAddArgs != null) {
+            zAddArgs.build(args);
         }
 
-        return true;
+        args.add(INCR);
+        args.add(score).addValue(member);
+
+        return createCommand(ZADD, new DoubleOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zcard(K key) {
+    Command<K, V, Long> zcard(K key) {
         notNullKey(key);
 
-        return createCommand(ZCARD, new IntegerOutput<K, V>(codec), key);
+        return createCommand(ZCARD, new IntegerOutput<>(codec), key);
     }
 
-    public Command<K, V, Long> zcount(K key, double min, double max) {
+    Command<K, V, Long> zcount(K key, double min, double max) {
         return zcount(key, string(min), string(max));
     }
 
-    public Command<K, V, Long> zcount(K key, String min, String max) {
+    Command<K, V, Long> zcount(K key, String min, String max) {
         notNullKey(key);
         notNullMinMax(min, max);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(min).add(max);
-        return createCommand(ZCOUNT, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(min).add(max);
+        return createCommand(ZCOUNT, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zcount(K key, Range<? extends Number> range) {
+    Command<K, V, Long> zcount(K key, Range<? extends Number> range) {
         notNullKey(key);
         notNullRange(range);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(min(range)).add(max(range));
-        return createCommand(ZCOUNT, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(min(range)).add(max(range));
+        return createCommand(ZCOUNT, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Double> zincrby(K key, double amount, K member) {
+    Command<K, V, Double> zincrby(K key, double amount, K member) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(amount).addKey(member);
-        return createCommand(ZINCRBY, new DoubleOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(amount).addKey(member);
+        return createCommand(ZINCRBY, new DoubleOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zinterstore(K destination, K... keys) {
+    Command<K, V, Long> zinterstore(K destination, K... keys) {
         notEmpty(keys);
 
         return zinterstore(destination, new ZStoreArgs(), keys);
     }
 
-    public Command<K, V, Long> zinterstore(K destination, ZStoreArgs storeArgs, K... keys) {
+    Command<K, V, Long> zinterstore(K destination, ZStoreArgs storeArgs, K... keys) {
         LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(storeArgs, "ZStoreArgs " + MUST_NOT_BE_NULL);
         notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(destination).add(keys.length).addKeys(keys);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(destination).add(keys.length).addKeys(keys);
         storeArgs.build(args);
-        return createCommand(ZINTERSTORE, new IntegerOutput<K, V>(codec), args);
+        return createCommand(ZINTERSTORE, new IntegerOutput<>(codec), args);
+    }
+
+    RedisCommand<K, V, Long> zlexcount(K key, String min, String max) {
+        notNullKey(key);
+        notNullMinMax(min, max);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(min).add(max);
+        return createCommand(ZLEXCOUNT, new IntegerOutput<>(codec), args);
+    }
+
+    RedisCommand<K, V, Long> zlexcount(K key, Range<? extends V> range) {
+        notNullKey(key);
+        notNullRange(range);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(minValue(range)).add(maxValue(range));
+        return createCommand(ZLEXCOUNT, new IntegerOutput<>(codec), args);
+    }
+
+    Command<K, V, List<V>> zrange(K key, long start, long stop) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(start).add(stop);
+        return createCommand(ZRANGE, new ValueListOutput<>(codec), args);
+    }
+
+    Command<K, V, Long> zrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(start).add(stop);
+        return createCommand(ZRANGE, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, List<V>> zrange(K key, long start, long stop) {
+    Command<K, V, List<ScoredValue<V>>> zrangeWithScores(K key, long start, long stop) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(start).add(stop);
-        return createCommand(ZRANGE, new ValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(start).add(stop).add(WITHSCORES);
+        return createCommand(ZRANGE, new ScoredValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrangeWithScores(K key, long start, long stop) {
+    Command<K, V, Long> zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
         notNullKey(key);
+        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.addKey(key).add(start).add(stop).add(WITHSCORES);
-        return createCommand(ZRANGE, new ScoredValueListOutput<K, V>(codec), args);
+        return createCommand(ZRANGE, new ScoredValueStreamingOutput<>(codec, channel), args);
+    }
+
+    RedisCommand<K, V, List<V>> zrangebylex(K key, String min, String max) {
+        notNullKey(key);
+        notNullMinMax(min, max);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(min).add(max);
+        return createCommand(ZRANGEBYLEX, new ValueListOutput<>(codec), args);
+    }
+
+    RedisCommand<K, V, List<V>> zrangebylex(K key, String min, String max, long offset, long count) {
+        notNullKey(key);
+        notNullMinMax(min, max);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        addLimit(args.addKey(key).add(min).add(max), Limit.create(offset, count));
+        return createCommand(ZRANGEBYLEX, new ValueListOutput<>(codec), args);
+    }
+
+    RedisCommand<K, V, List<V>> zrangebylex(K key, Range<? extends V> range, Limit limit) {
+        notNullKey(key);
+        notNullRange(range);
+        notNullLimit(limit);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        addLimit(args.addKey(key).add(minValue(range)).add(maxValue(range)), limit);
+        return createCommand(ZRANGEBYLEX, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, List<V>> zrangebyscore(K key, double min, double max) {
+    Command<K, V, List<V>> zrangebyscore(K key, double min, double max) {
         return zrangebyscore(key, string(min), string(max));
     }
 
-    public Command<K, V, List<V>> zrangebyscore(K key, String min, String max) {
+    Command<K, V, List<V>> zrangebyscore(K key, String min, String max) {
         notNullKey(key);
         notNullMinMax(min, max);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(min).add(max);
-        return createCommand(ZRANGEBYSCORE, new ValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(min).add(max);
+        return createCommand(ZRANGEBYSCORE, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, List<V>> zrangebyscore(K key, double min, double max, long offset, long count) {
+    Command<K, V, List<V>> zrangebyscore(K key, double min, double max, long offset, long count) {
         return zrangebyscore(key, string(min), string(max), offset, count);
     }
 
-    public Command<K, V, List<V>> zrangebyscore(K key, String min, String max, long offset, long count) {
+    Command<K, V, List<V>> zrangebyscore(K key, String min, String max, long offset, long count) {
         notNullKey(key);
         notNullMinMax(min, max);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.addKey(key).add(min).add(max).add(LIMIT).add(offset).add(count);
-        return createCommand(ZRANGEBYSCORE, new ValueListOutput<K, V>(codec), args);
+        return createCommand(ZRANGEBYSCORE, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, List<V>> zrangebyscore(K key, Range<? extends Number> range, Limit limit) {
+    Command<K, V, List<V>> zrangebyscore(K key, Range<? extends Number> range, Limit limit) {
         notNullKey(key);
         notNullRange(range);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.addKey(key).add(min(range)).add(max(range));
 
         if (limit.isLimited()) {
             args.add(LIMIT).add(limit.getOffset()).add(limit.getCount());
         }
-        return createCommand(ZRANGEBYSCORE, new ValueListOutput<K, V>(codec), args);
+        return createCommand(ZRANGEBYSCORE, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrangebyscoreWithScores(K key, double min, double max) {
-        return zrangebyscoreWithScores(key, string(min), string(max));
+    Command<K, V, Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max) {
+        return zrangebyscore(channel, key, string(min), string(max));
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrangebyscoreWithScores(K key, String min, String max) {
+    Command<K, V, Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max) {
         notNullKey(key);
         notNullMinMax(min, max);
+        LettuceAssert.notNull(channel, "ScoredValueStreamingChannel " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(min).add(max).add(WITHSCORES);
-        return createCommand(ZRANGEBYSCORE, new ScoredValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(min).add(max);
+        return createCommand(ZRANGEBYSCORE, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrangebyscoreWithScores(K key, double min, double max, long offset, long count) {
-        return zrangebyscoreWithScores(key, string(min), string(max), offset, count);
+    Command<K, V, Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max, long offset,
+            long count) {
+        return zrangebyscore(channel, key, string(min), string(max), offset, count);
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrangebyscoreWithScores(K key, String min, String max, long offset, long count) {
+    Command<K, V, Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max, long offset,
+            long count) {
         notNullKey(key);
         notNullMinMax(min, max);
+        LettuceAssert.notNull(channel, "ScoredValueStreamingChannel " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        addLimit(args.addKey(key).add(min).add(max).add(WITHSCORES), Limit.create(offset, count));
-        return createCommand(ZRANGEBYSCORE, new ScoredValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        addLimit(args.addKey(key).add(min).add(max), Limit.create(offset, count));
+        return createCommand(ZRANGEBYSCORE, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
+    Command<K, V, Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) {
         notNullKey(key);
         notNullRange(range);
         notNullLimit(limit);
+        LettuceAssert.notNull(channel, "ScoredValueStreamingChannel " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        addLimit(args.addKey(key).add(min(range)).add(max(range)).add(WITHSCORES), limit);
-        return createCommand(ZRANGEBYSCORE, new ScoredValueListOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> zrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(start).add(stop);
-        return createCommand(ZRANGE, new ValueStreamingOutput<K, V>(codec, channel), args);
-    }
-
-    public Command<K, V, Long> zrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
-        notNullKey(key);
-        notNull(channel);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(start).add(stop).add(WITHSCORES);
-        return createCommand(ZRANGE, new ScoredValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        addLimit(args.addKey(key).add(min(range)).add(max(range)), limit);
+        return createCommand(ZRANGEBYSCORE, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max) {
-        return zrangebyscore(channel, key, string(min), string(max));
+    Command<K, V, List<ScoredValue<V>>> zrangebyscoreWithScores(K key, double min, double max) {
+        return zrangebyscoreWithScores(key, string(min), string(max));
     }
 
-    public Command<K, V, Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max) {
+    Command<K, V, List<ScoredValue<V>>> zrangebyscoreWithScores(K key, String min, String max) {
         notNullKey(key);
         notNullMinMax(min, max);
-        LettuceAssert.notNull(channel, "ScoredValueStreamingChannel " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(min).add(max);
-        return createCommand(ZRANGEBYSCORE, new ValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(min).add(max).add(WITHSCORES);
+        return createCommand(ZRANGEBYSCORE, new ScoredValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, double min, double max, long offset,
-            long count) {
-        return zrangebyscore(channel, key, string(min), string(max), offset, count);
+    Command<K, V, List<ScoredValue<V>>> zrangebyscoreWithScores(K key, double min, double max, long offset, long count) {
+        return zrangebyscoreWithScores(key, string(min), string(max), offset, count);
     }
 
-    public Command<K, V, Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, String min, String max, long offset,
-            long count) {
+    Command<K, V, List<ScoredValue<V>>> zrangebyscoreWithScores(K key, String min, String max, long offset, long count) {
         notNullKey(key);
         notNullMinMax(min, max);
-        LettuceAssert.notNull(channel, "ScoredValueStreamingChannel " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        addLimit(args.addKey(key).add(min).add(max), Limit.create(offset, count));
-        return createCommand(ZRANGEBYSCORE, new ValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        addLimit(args.addKey(key).add(min).add(max).add(WITHSCORES), Limit.create(offset, count));
+        return createCommand(ZRANGEBYSCORE, new ScoredValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range, Limit limit) {
+    Command<K, V, List<ScoredValue<V>>> zrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
         notNullKey(key);
         notNullRange(range);
         notNullLimit(limit);
-        LettuceAssert.notNull(channel, "ScoredValueStreamingChannel " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        addLimit(args.addKey(key).add(min(range)).add(max(range)), limit);
-        return createCommand(ZRANGEBYSCORE, new ValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        addLimit(args.addKey(key).add(min(range)).add(max(range)).add(WITHSCORES), limit);
+        return createCommand(ZRANGEBYSCORE, new ScoredValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max) {
+    Command<K, V, Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max) {
         return zrangebyscoreWithScores(channel, key, string(min), string(max));
     }
 
-    public Command<K, V, Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max) {
+    Command<K, V, Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max) {
         notNullKey(key);
         notNullMinMax(min, max);
         notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.addKey(key).add(min).add(max).add(WITHSCORES);
-        return createCommand(ZRANGEBYSCORE, new ScoredValueStreamingOutput<K, V>(codec, channel), args);
+        return createCommand(ZRANGEBYSCORE, new ScoredValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max,
+    Command<K, V, Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double min, double max,
             long offset, long count) {
         return zrangebyscoreWithScores(channel, key, string(min), string(max), offset, count);
     }
 
-    public Command<K, V, Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max,
+    Command<K, V, Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String min, String max,
             long offset, long count) {
         notNullKey(key);
         notNullMinMax(min, max);
         notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         addLimit(args.addKey(key).add(min).add(max).add(WITHSCORES), Limit.create(offset, count));
-        return createCommand(ZRANGEBYSCORE, new ScoredValueStreamingOutput<K, V>(codec, channel), args);
+        return createCommand(ZRANGEBYSCORE, new ScoredValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key,
+    Command<K, V, Long> zrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key,
             Range<? extends Number> range, Limit limit) {
         notNullKey(key);
         notNullRange(range);
         notNullLimit(limit);
         notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         addLimit(args.addKey(key).add(min(range)).add(max(range)).add(WITHSCORES), limit);
-        return createCommand(ZRANGEBYSCORE, new ScoredValueStreamingOutput<K, V>(codec, channel), args);
+        return createCommand(ZRANGEBYSCORE, new ScoredValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> zrank(K key, V member) {
+    Command<K, V, Long> zrank(K key, V member) {
         notNullKey(key);
 
-        return createCommand(ZRANK, new IntegerOutput<K, V>(codec), key, member);
+        return createCommand(ZRANK, new IntegerOutput<>(codec), key, member);
     }
 
-    public Command<K, V, Long> zrem(K key, V... members) {
+    Command<K, V, Long> zrem(K key, V... members) {
         notNullKey(key);
         LettuceAssert.notNull(members, "Members " + MUST_NOT_BE_NULL);
         LettuceAssert.notEmpty(members, "Members " + MUST_NOT_BE_EMPTY);
 
-        return createCommand(ZREM, new IntegerOutput<K, V>(codec), key, members);
+        return createCommand(ZREM, new IntegerOutput<>(codec), key, members);
+    }
+
+    RedisCommand<K, V, Long> zremrangebylex(K key, String min, String max) {
+        notNullKey(key);
+        notNullMinMax(min, max);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(min).add(max);
+        return createCommand(ZREMRANGEBYLEX, new IntegerOutput<>(codec), args);
+    }
+
+    RedisCommand<K, V, Long> zremrangebylex(K key, Range<? extends V> range) {
+        notNullKey(key);
+        notNullRange(range);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(minValue(range)).add(maxValue(range));
+        return createCommand(ZREMRANGEBYLEX, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zremrangebyrank(K key, long start, long stop) {
+    Command<K, V, Long> zremrangebyrank(K key, long start, long stop) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(start).add(stop);
-        return createCommand(ZREMRANGEBYRANK, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(start).add(stop);
+        return createCommand(ZREMRANGEBYRANK, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zremrangebyscore(K key, double min, double max) {
+    Command<K, V, Long> zremrangebyscore(K key, double min, double max) {
         return zremrangebyscore(key, string(min), string(max));
     }
 
-    public Command<K, V, Long> zremrangebyscore(K key, String min, String max) {
+    Command<K, V, Long> zremrangebyscore(K key, String min, String max) {
         notNullKey(key);
         notNullMinMax(min, max);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(min).add(max);
-        return createCommand(ZREMRANGEBYSCORE, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(min).add(max);
+        return createCommand(ZREMRANGEBYSCORE, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zremrangebyscore(K key, Range<? extends Number> range) {
+    Command<K, V, Long> zremrangebyscore(K key, Range<? extends Number> range) {
         notNullKey(key);
         notNullRange(range);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(min(range)).add(max(range));
-        return createCommand(ZREMRANGEBYSCORE, new IntegerOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(min(range)).add(max(range));
+        return createCommand(ZREMRANGEBYSCORE, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, List<V>> zrevrange(K key, long start, long stop) {
+    Command<K, V, List<V>> zrevrange(K key, long start, long stop) {
         notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(start).add(stop);
-        return createCommand(ZREVRANGE, new ValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(start).add(stop);
+        return createCommand(ZREVRANGE, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, List<V>> zrevrangebylex(K key, Range<? extends V> range, Limit limit) {
+    Command<K, V, Long> zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
         notNullKey(key);
-        notNullRange(range);
-        notNullLimit(limit);
+        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        addLimit(args.addKey(key).add(maxValue(range)).add(minValue(range)), limit);
-        return createCommand(ZREVRANGEBYLEX, new ValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(start).add(stop);
+        return createCommand(ZREVRANGE, new ValueStreamingOutput<>(codec, channel), args);
+    }
+
+    Command<K, V, List<ScoredValue<V>>> zrevrangeWithScores(K key, long start, long stop) {
+        notNullKey(key);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(start).add(stop).add(WITHSCORES);
+        return createCommand(ZREVRANGE, new ScoredValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrevrangeWithScores(K key, long start, long stop) {
+    Command<K, V, Long> zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
         notNullKey(key);
+        LettuceAssert.notNull(channel, "ValueStreamingChannel " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.addKey(key).add(start).add(stop).add(WITHSCORES);
-        return createCommand(ZREVRANGE, new ScoredValueListOutput<K, V>(codec), args);
+        return createCommand(ZREVRANGE, new ScoredValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, List<V>> zrevrangebyscore(K key, double max, double min) {
+    Command<K, V, List<V>> zrevrangebylex(K key, Range<? extends V> range, Limit limit) {
+        notNullKey(key);
+        notNullRange(range);
+        notNullLimit(limit);
+
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        addLimit(args.addKey(key).add(maxValue(range)).add(minValue(range)), limit);
+        return createCommand(ZREVRANGEBYLEX, new ValueListOutput<>(codec), args);
+    }
+
+    Command<K, V, List<V>> zrevrangebyscore(K key, double max, double min) {
         return zrevrangebyscore(key, string(max), string(min));
     }
 
-    public Command<K, V, List<V>> zrevrangebyscore(K key, String max, String min) {
+    Command<K, V, List<V>> zrevrangebyscore(K key, String max, String min) {
         notNullKey(key);
         notNullMinMax(min, max);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(max).add(min);
-        return createCommand(ZREVRANGEBYSCORE, new ValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(max).add(min);
+        return createCommand(ZREVRANGEBYSCORE, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, List<V>> zrevrangebyscore(K key, double max, double min, long offset, long count) {
+    Command<K, V, List<V>> zrevrangebyscore(K key, double max, double min, long offset, long count) {
         return zrevrangebyscore(key, string(max), string(min), offset, count);
     }
 
-    public Command<K, V, List<V>> zrevrangebyscore(K key, String max, String min, long offset, long count) {
+    Command<K, V, List<V>> zrevrangebyscore(K key, String max, String min, long offset, long count) {
         notNullKey(key);
         notNullMinMax(min, max);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         addLimit(args.addKey(key).add(max).add(min), Limit.create(offset, count));
-        return createCommand(ZREVRANGEBYSCORE, new ValueListOutput<K, V>(codec), args);
+        return createCommand(ZREVRANGEBYSCORE, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, List<V>> zrevrangebyscore(K key, Range<? extends Number> range, Limit limit) {
+    Command<K, V, List<V>> zrevrangebyscore(K key, Range<? extends Number> range, Limit limit) {
         notNullKey(key);
         notNullRange(range);
         notNullLimit(limit);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         addLimit(args.addKey(key).add(max(range)).add(min(range)), limit);
-        return createCommand(ZREVRANGEBYSCORE, new ValueListOutput<K, V>(codec), args);
+        return createCommand(ZREVRANGEBYSCORE, new ValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, double max, double min) {
-        return zrevrangebyscoreWithScores(key, string(max), string(min));
+    Command<K, V, Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min) {
+        return zrevrangebyscore(channel, key, string(max), string(min));
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, String max, String min) {
+    Command<K, V, Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min) {
         notNullKey(key);
         notNullMinMax(min, max);
+        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(max).add(min).add(WITHSCORES);
-        return createCommand(ZREVRANGEBYSCORE, new ScoredValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec).addKey(key).add(max).add(min);
+        return createCommand(ZREVRANGEBYSCORE, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count) {
-        return zrevrangebyscoreWithScores(key, string(max), string(min), offset, count);
+    Command<K, V, Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min, long offset,
+            long count) {
+        return zrevrangebyscore(channel, key, string(max), string(min), offset, count);
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count) {
+    Command<K, V, Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min, long offset,
+            long count) {
         notNullKey(key);
         notNullMinMax(min, max);
+        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        addLimit(args.addKey(key).add(max).add(min).add(WITHSCORES), Limit.create(offset, count));
-        return createCommand(ZREVRANGEBYSCORE, new ScoredValueListOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        addLimit(args.addKey(key).add(max).add(min), Limit.create(offset, count));
+        return createCommand(ZREVRANGEBYSCORE, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
+    Command<K, V, Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range,
+            Limit limit) {
         notNullKey(key);
         notNullRange(range);
         notNullLimit(limit);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        addLimit(args.addKey(key).add(max(range)).add(min(range)).add(WITHSCORES), limit);
-        return createCommand(ZREVRANGEBYSCORE, new ScoredValueListOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> zrevrange(ValueStreamingChannel<V> channel, K key, long start, long stop) {
-        notNullKey(key);
         notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(start).add(stop);
-        return createCommand(ZREVRANGE, new ValueStreamingOutput<K, V>(codec, channel), args);
-    }
-
-    public Command<K, V, Long> zrevrangeWithScores(ScoredValueStreamingChannel<V> channel, K key, long start, long stop) {
-        notNullKey(key);
-        LettuceAssert.notNull(channel, "ValueStreamingChannel " + MUST_NOT_BE_NULL);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(start).add(stop).add(WITHSCORES);
-        return createCommand(ZREVRANGE, new ScoredValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        addLimit(args.addKey(key).add(max(range)).add(min(range)), limit);
+        return createCommand(ZREVRANGEBYSCORE, new ValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min) {
-        return zrevrangebyscore(channel, key, string(max), string(min));
+    Command<K, V, List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, double max, double min) {
+        return zrevrangebyscoreWithScores(key, string(max), string(min));
     }
 
-    public Command<K, V, Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min) {
+    Command<K, V, List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, String max, String min) {
         notNullKey(key);
         notNullMinMax(min, max);
-        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(max).add(min);
-        return createCommand(ZREVRANGEBYSCORE, new ValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key).add(max).add(min).add(WITHSCORES);
+        return createCommand(ZREVRANGEBYSCORE, new ScoredValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, double max, double min, long offset,
-            long count) {
-        return zrevrangebyscore(channel, key, string(max), string(min), offset, count);
+    Command<K, V, List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, double max, double min, long offset, long count) {
+        return zrevrangebyscoreWithScores(key, string(max), string(min), offset, count);
     }
 
-    public Command<K, V, Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, String max, String min, long offset,
-            long count) {
+    Command<K, V, List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, String max, String min, long offset, long count) {
         notNullKey(key);
         notNullMinMax(min, max);
-        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        addLimit(args.addKey(key).add(max).add(min), Limit.create(offset, count));
-        return createCommand(ZREVRANGEBYSCORE, new ValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        addLimit(args.addKey(key).add(max).add(min).add(WITHSCORES), Limit.create(offset, count));
+        return createCommand(ZREVRANGEBYSCORE, new ScoredValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zrevrangebyscore(ValueStreamingChannel<V> channel, K key, Range<? extends Number> range,
-            Limit limit) {
+    Command<K, V, List<ScoredValue<V>>> zrevrangebyscoreWithScores(K key, Range<? extends Number> range, Limit limit) {
         notNullKey(key);
         notNullRange(range);
         notNullLimit(limit);
-        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        addLimit(args.addKey(key).add(max(range)).add(min(range)), limit);
-        return createCommand(ZREVRANGEBYSCORE, new ValueStreamingOutput<K, V>(codec, channel), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        addLimit(args.addKey(key).add(max(range)).add(min(range)).add(WITHSCORES), limit);
+        return createCommand(ZREVRANGEBYSCORE, new ScoredValueListOutput<>(codec), args);
     }
 
-    public Command<K, V, Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min) {
+    Command<K, V, Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max, double min) {
         return zrevrangebyscoreWithScores(channel, key, string(max), string(min));
     }
 
-    public Command<K, V, Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min) {
+    Command<K, V, Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max, String min) {
         notNullKey(key);
         notNullMinMax(min, max);
         notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         args.addKey(key).add(max).add(min).add(WITHSCORES);
-        return createCommand(ZREVRANGEBYSCORE, new ScoredValueStreamingOutput<K, V>(codec, channel), args);
+        return createCommand(ZREVRANGEBYSCORE, new ScoredValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max,
+    Command<K, V, Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, double max,
             double min, long offset, long count) {
         notNullKey(key);
         LettuceAssert.notNull(min, "Min " + MUST_NOT_BE_NULL);
@@ -1923,811 +2544,184 @@ public Command<K, V, Long> zrevrangebyscoreWithScores(ScoredValueStreamingChanne
         return zrevrangebyscoreWithScores(channel, key, string(max), string(min), offset, count);
     }
 
-    public Command<K, V, Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max,
+    Command<K, V, Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key, String max,
             String min, long offset, long count) {
         notNullKey(key);
         notNullMinMax(min, max);
         notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         addLimit(args.addKey(key).add(max).add(min).add(WITHSCORES), Limit.create(offset, count));
-        return createCommand(ZREVRANGEBYSCORE, new ScoredValueStreamingOutput<K, V>(codec, channel), args);
+        return createCommand(ZREVRANGEBYSCORE, new ScoredValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key,
+    Command<K, V, Long> zrevrangebyscoreWithScores(ScoredValueStreamingChannel<V> channel, K key,
             Range<? extends Number> range, Limit limit) {
         notNullKey(key);
         notNullRange(range);
         notNullLimit(limit);
         notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
         addLimit(args.addKey(key).add(max(range)).add(min(range)).add(WITHSCORES), limit);
-        return createCommand(ZREVRANGEBYSCORE, new ScoredValueStreamingOutput<K, V>(codec, channel), args);
+        return createCommand(ZREVRANGEBYSCORE, new ScoredValueStreamingOutput<>(codec, channel), args);
     }
 
-    public Command<K, V, Long> zrevrank(K key, V member) {
+    Command<K, V, Long> zrevrank(K key, V member) {
         notNullKey(key);
 
-        return createCommand(ZREVRANK, new IntegerOutput<K, V>(codec), key, member);
+        return createCommand(ZREVRANK, new IntegerOutput<>(codec), key, member);
     }
 
-    public Command<K, V, Double> zscore(K key, V member) {
+    Command<K, V, ScoredValueScanCursor<V>> zscan(K key) {
         notNullKey(key);
 
-        return createCommand(ZSCORE, new DoubleOutput<K, V>(codec), key, member);
+        return zscan(key, ScanCursor.INITIAL, null);
     }
 
-    public Command<K, V, Long> zunionstore(K destination, K... keys) {
-        notEmpty(keys);
-        LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
+    Command<K, V, ScoredValueScanCursor<V>> zscan(K key, ScanCursor scanCursor) {
+        notNullKey(key);
 
-        return zunionstore(destination, new ZStoreArgs(), keys);
+        return zscan(key, scanCursor, null);
     }
 
-    public Command<K, V, Long> zunionstore(K destination, ZStoreArgs storeArgs, K... keys) {
-        notEmpty(keys);
+    Command<K, V, ScoredValueScanCursor<V>> zscan(K key, ScanArgs scanArgs) {
+        notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(destination).add(keys.length).addKeys(keys);
-        storeArgs.build(args);
-        return createCommand(ZUNIONSTORE, new IntegerOutput<K, V>(codec), args);
+        return zscan(key, ScanCursor.INITIAL, scanArgs);
     }
 
-    public RedisCommand<K, V, Long> zlexcount(K key, String min, String max) {
+    Command<K, V, ScoredValueScanCursor<V>> zscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
         notNullKey(key);
-        notNullMinMax(min, max);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(min).add(max);
-        return createCommand(ZLEXCOUNT, new IntegerOutput<K, V>(codec), args);
-    }
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(key);
 
-    public RedisCommand<K, V, Long> zlexcount(K key, Range<? extends V> range) {
-        notNullKey(key);
-        notNullRange(range);
+        scanArgs(scanCursor, scanArgs, args);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(minValue(range)).add(maxValue(range));
-        return createCommand(ZLEXCOUNT, new IntegerOutput<K, V>(codec), args);
+        ScoredValueScanOutput<K, V> output = new ScoredValueScanOutput<>(codec);
+        return createCommand(ZSCAN, output, args);
     }
 
-    public RedisCommand<K, V, Long> zremrangebylex(K key, String min, String max) {
+    Command<K, V, StreamScanCursor> zscanStreaming(ScoredValueStreamingChannel<V> channel, K key) {
         notNullKey(key);
-        notNullMinMax(min, max);
+        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(min).add(max);
-        return createCommand(ZREMRANGEBYLEX, new IntegerOutput<K, V>(codec), args);
+        return zscanStreaming(channel, key, ScanCursor.INITIAL, null);
     }
 
-    public RedisCommand<K, V, Long> zremrangebylex(K key, Range<? extends V> range) {
+    Command<K, V, StreamScanCursor> zscanStreaming(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor) {
         notNullKey(key);
-        notNullRange(range);
+        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(minValue(range)).add(maxValue(range));
-        return createCommand(ZREMRANGEBYLEX, new IntegerOutput<K, V>(codec), args);
+        return zscanStreaming(channel, key, scanCursor, null);
     }
 
-    public RedisCommand<K, V, List<V>> zrangebylex(K key, String min, String max) {
+    Command<K, V, StreamScanCursor> zscanStreaming(ScoredValueStreamingChannel<V> channel, K key, ScanArgs scanArgs) {
         notNullKey(key);
-        notNullMinMax(min, max);
+        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key).add(min).add(max);
-        return createCommand(ZRANGEBYLEX, new ValueListOutput<K, V>(codec), args);
+        return zscanStreaming(channel, key, ScanCursor.INITIAL, scanArgs);
     }
 
-    public RedisCommand<K, V, List<V>> zrangebylex(K key, String min, String max, long offset, long count) {
+    Command<K, V, StreamScanCursor> zscanStreaming(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor,
+            ScanArgs scanArgs) {
         notNullKey(key);
-        notNullMinMax(min, max);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        addLimit(args.addKey(key).add(min).add(max), Limit.create(offset, count));
-        return createCommand(ZRANGEBYLEX, new ValueListOutput<K, V>(codec), args);
-    }
-
-    public RedisCommand<K, V, List<V>> zrangebylex(K key, Range<? extends V> range, Limit limit) {
-        notNullKey(key);
-        notNullRange(range);
-        notNullLimit(limit);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        addLimit(args.addKey(key).add(minValue(range)).add(maxValue(range)), limit);
-        return createCommand(ZRANGEBYLEX, new ValueListOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, List<V>> time() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        return createCommand(TIME, new ValueListOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, KeyScanCursor<K>> scan() {
-        return scan(ScanCursor.INITIAL, null);
-    }
-
-    public Command<K, V, KeyScanCursor<K>> scan(ScanCursor scanCursor) {
-        return scan(scanCursor, null);
-    }
-
-    public Command<K, V, KeyScanCursor<K>> scan(ScanArgs scanArgs) {
-        return scan(ScanCursor.INITIAL, scanArgs);
-    }
-
-    public Command<K, V, KeyScanCursor<K>> scan(ScanCursor scanCursor, ScanArgs scanArgs) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-
-        scanArgs(scanCursor, scanArgs, args);
-
-        KeyScanOutput<K, V> output = new KeyScanOutput<K, V>(codec);
-        return createCommand(SCAN, output, args);
-    }
-
-    protected void scanArgs(ScanCursor scanCursor, ScanArgs scanArgs, CommandArgs<K, V> args) {
-        LettuceAssert.notNull(scanCursor, "ScanCursor " + MUST_NOT_BE_NULL);
-        LettuceAssert.isTrue(!scanCursor.isFinished(), "ScanCursor must not be finished");
-
-        args.add(scanCursor.getCursor());
-
-        if (scanArgs != null) {
-            scanArgs.build(args);
-        }
-    }
-
-    public Command<K, V, StreamScanCursor> scanStreaming(KeyStreamingChannel<K> channel) {
-        notNull(channel);
-        LettuceAssert.notNull(channel, "KeyStreamingChannel " + MUST_NOT_BE_NULL);
-
-        return scanStreaming(channel, ScanCursor.INITIAL, null);
-    }
-
-    public Command<K, V, StreamScanCursor> scanStreaming(KeyStreamingChannel<K> channel, ScanCursor scanCursor) {
-        notNull(channel);
-        LettuceAssert.notNull(channel, "KeyStreamingChannel " + MUST_NOT_BE_NULL);
-
-        return scanStreaming(channel, scanCursor, null);
-    }
-
-    public Command<K, V, StreamScanCursor> scanStreaming(KeyStreamingChannel<K> channel, ScanArgs scanArgs) {
-        notNull(channel);
-        LettuceAssert.notNull(channel, "KeyStreamingChannel " + MUST_NOT_BE_NULL);
-
-        return scanStreaming(channel, ScanCursor.INITIAL, scanArgs);
-    }
-
-    public Command<K, V, StreamScanCursor> scanStreaming(KeyStreamingChannel<K> channel, ScanCursor scanCursor,
-            ScanArgs scanArgs) {
-        notNull(channel);
-        LettuceAssert.notNull(channel, "KeyStreamingChannel " + MUST_NOT_BE_NULL);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        scanArgs(scanCursor, scanArgs, args);
-
-        KeyScanStreamingOutput<K, V> output = new KeyScanStreamingOutput<K, V>(codec, channel);
-        return createCommand(SCAN, output, args);
-    }
-
-    public Command<K, V, ValueScanCursor<V>> sscan(K key) {
-        notNullKey(key);
-
-        return sscan(key, ScanCursor.INITIAL, null);
-    }
-
-    public Command<K, V, ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor) {
-        notNullKey(key);
-
-        return sscan(key, scanCursor, null);
-    }
-
-    public Command<K, V, ValueScanCursor<V>> sscan(K key, ScanArgs scanArgs) {
-        notNullKey(key);
-
-        return sscan(key, ScanCursor.INITIAL, scanArgs);
-    }
-
-    public Command<K, V, ValueScanCursor<V>> sscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
-        notNullKey(key);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key);
-
-        scanArgs(scanCursor, scanArgs, args);
-
-        ValueScanOutput<K, V> output = new ValueScanOutput<K, V>(codec);
-        return createCommand(SSCAN, output, args);
-    }
-
-    public Command<K, V, StreamScanCursor> sscanStreaming(ValueStreamingChannel<V> channel, K key) {
-        notNullKey(key);
-        notNull(channel);
-
-        return sscanStreaming(channel, key, ScanCursor.INITIAL, null);
-    }
-
-    public Command<K, V, StreamScanCursor> sscanStreaming(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor) {
-        notNullKey(key);
-        notNull(channel);
-
-        return sscanStreaming(channel, key, scanCursor, null);
-    }
-
-    public Command<K, V, StreamScanCursor> sscanStreaming(ValueStreamingChannel<V> channel, K key, ScanArgs scanArgs) {
-        notNullKey(key);
-        notNull(channel);
-
-        return sscanStreaming(channel, key, ScanCursor.INITIAL, scanArgs);
-    }
-
-    public Command<K, V, StreamScanCursor> sscanStreaming(ValueStreamingChannel<V> channel, K key, ScanCursor scanCursor,
-            ScanArgs scanArgs) {
-        notNullKey(key);
-        notNull(channel);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-
-        args.addKey(key);
-        scanArgs(scanCursor, scanArgs, args);
-
-        ValueScanStreamingOutput<K, V> output = new ValueScanStreamingOutput<K, V>(codec, channel);
-        return createCommand(SSCAN, output, args);
-    }
-
-    public Command<K, V, MapScanCursor<K, V>> hscan(K key) {
-        notNullKey(key);
-
-        return hscan(key, ScanCursor.INITIAL, null);
-    }
-
-    public Command<K, V, MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor) {
-        notNullKey(key);
-
-        return hscan(key, scanCursor, null);
-    }
-
-    public Command<K, V, MapScanCursor<K, V>> hscan(K key, ScanArgs scanArgs) {
-        notNullKey(key);
-
-        return hscan(key, ScanCursor.INITIAL, scanArgs);
-    }
-
-    public Command<K, V, MapScanCursor<K, V>> hscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
-        notNullKey(key);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key);
-
-        scanArgs(scanCursor, scanArgs, args);
-
-        MapScanOutput<K, V> output = new MapScanOutput<K, V>(codec);
-        return createCommand(HSCAN, output, args);
-    }
-
-    public Command<K, V, StreamScanCursor> hscanStreaming(KeyValueStreamingChannel<K, V> channel, K key) {
-        notNullKey(key);
-        notNull(channel);
-
-        return hscanStreaming(channel, key, ScanCursor.INITIAL, null);
-    }
-
-    public Command<K, V, StreamScanCursor> hscanStreaming(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor) {
-        notNullKey(key);
-        notNull(channel);
-
-        return hscanStreaming(channel, key, scanCursor, null);
-    }
-
-    public Command<K, V, StreamScanCursor> hscanStreaming(KeyValueStreamingChannel<K, V> channel, K key, ScanArgs scanArgs) {
-        notNullKey(key);
-        notNull(channel);
-
-        return hscanStreaming(channel, key, ScanCursor.INITIAL, scanArgs);
-    }
-
-    public Command<K, V, StreamScanCursor> hscanStreaming(KeyValueStreamingChannel<K, V> channel, K key, ScanCursor scanCursor,
-            ScanArgs scanArgs) {
-        notNullKey(key);
-        notNull(channel);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-
-        args.addKey(key);
-        scanArgs(scanCursor, scanArgs, args);
-
-        KeyValueScanStreamingOutput<K, V> output = new KeyValueScanStreamingOutput<K, V>(codec, channel);
-        return createCommand(HSCAN, output, args);
-    }
-
-    public Command<K, V, ScoredValueScanCursor<V>> zscan(K key) {
-        notNullKey(key);
-
-        return zscan(key, ScanCursor.INITIAL, null);
-    }
-
-    public Command<K, V, ScoredValueScanCursor<V>> zscan(K key, ScanCursor scanCursor) {
-        notNullKey(key);
-
-        return zscan(key, scanCursor, null);
-    }
-
-    public Command<K, V, ScoredValueScanCursor<V>> zscan(K key, ScanArgs scanArgs) {
-        notNullKey(key);
-
-        return zscan(key, ScanCursor.INITIAL, scanArgs);
-    }
-
-    public Command<K, V, ScoredValueScanCursor<V>> zscan(K key, ScanCursor scanCursor, ScanArgs scanArgs) {
-        notNullKey(key);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        args.addKey(key);
-
-        scanArgs(scanCursor, scanArgs, args);
-
-        ScoredValueScanOutput<K, V> output = new ScoredValueScanOutput<K, V>(codec);
-        return createCommand(ZSCAN, output, args);
-    }
-
-    public Command<K, V, StreamScanCursor> zscanStreaming(ScoredValueStreamingChannel<V> channel, K key) {
-        notNullKey(key);
-        notNull(channel);
-
-        return zscanStreaming(channel, key, ScanCursor.INITIAL, null);
-    }
-
-    public Command<K, V, StreamScanCursor> zscanStreaming(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor) {
-        notNullKey(key);
-        notNull(channel);
-
-        return zscanStreaming(channel, key, scanCursor, null);
-    }
-
-    public Command<K, V, StreamScanCursor> zscanStreaming(ScoredValueStreamingChannel<V> channel, K key, ScanArgs scanArgs) {
-        notNullKey(key);
-        notNull(channel);
-
-        return zscanStreaming(channel, key, ScanCursor.INITIAL, scanArgs);
-    }
-
-    public Command<K, V, StreamScanCursor> zscanStreaming(ScoredValueStreamingChannel<V> channel, K key, ScanCursor scanCursor,
-            ScanArgs scanArgs) {
-        notNullKey(key);
-        notNull(channel);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-
-        args.addKey(key);
-        scanArgs(scanCursor, scanArgs, args);
-
-        ScoredValueScanStreamingOutput<K, V> output = new ScoredValueScanStreamingOutput<K, V>(codec, channel);
-        return createCommand(ZSCAN, output, args);
-    }
-
-    public Command<K, V, Long> pfadd(K key, V value, V... moreValues) {
-        notNullKey(key);
-        LettuceAssert.notNull(value, "Value " + MUST_NOT_BE_NULL);
-        LettuceAssert.notNull(moreValues, "MoreValues " + MUST_NOT_BE_NULL);
-        LettuceAssert.noNullElements(moreValues, "MoreValues " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addValue(value).addValues(moreValues);
-        return createCommand(PFADD, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> pfadd(K key, V... values) {
-        notNullKey(key);
-        notEmptyValues(values);
-        LettuceAssert.noNullElements(values, "Values " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addValues(values);
-        return createCommand(PFADD, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> pfcount(K key, K... moreKeys) {
-        notNullKey(key);
-        LettuceAssert.notNull(moreKeys, "MoreKeys " + MUST_NOT_BE_NULL);
-        LettuceAssert.noNullElements(moreKeys, "MoreKeys " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addKeys(moreKeys);
-        return createCommand(PFCOUNT, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> pfcount(K... keys) {
-        notEmpty(keys);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(keys);
-        return createCommand(PFCOUNT, new IntegerOutput<K, V>(codec), args);
-    }
-
-    @SuppressWarnings("unchecked")
-    public Command<K, V, String> pfmerge(K destkey, K sourcekey, K... moreSourceKeys) {
-        LettuceAssert.notNull(destkey, "Destkey " + MUST_NOT_BE_NULL);
-        LettuceAssert.notNull(sourcekey, "Sourcekey " + MUST_NOT_BE_NULL);
-        LettuceAssert.notNull(moreSourceKeys, "MoreSourceKeys " + MUST_NOT_BE_NULL);
-        LettuceAssert.noNullElements(moreSourceKeys, "MoreSourceKeys " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(destkey).addKey(sourcekey).addKeys(moreSourceKeys);
-        return createCommand(PFMERGE, new StatusOutput<K, V>(codec), args);
-    }
-
-    @SuppressWarnings("unchecked")
-    public Command<K, V, String> pfmerge(K destkey, K... sourcekeys) {
-        LettuceAssert.notNull(destkey, "Destkey " + MUST_NOT_BE_NULL);
-        LettuceAssert.notNull(sourcekeys, "Sourcekeys " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(sourcekeys, "Sourcekeys " + MUST_NOT_BE_EMPTY);
-        LettuceAssert.noNullElements(sourcekeys, "Sourcekeys " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKeys(destkey).addKeys(sourcekeys);
-        return createCommand(PFMERGE, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterBumpepoch() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(BUMPEPOCH);
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterMeet(String ip, int port) {
-        LettuceAssert.notNull(ip, "IP " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(ip, "IP " + MUST_NOT_BE_EMPTY);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(MEET).add(ip).add(port);
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterForget(String nodeId) {
-        assertNodeId(nodeId);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(FORGET).add(nodeId);
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterAddslots(int[] slots) {
-        notEmptySlots(slots);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(ADDSLOTS);
-
-        for (int slot : slots) {
-            args.add(slot);
-        }
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterDelslots(int[] slots) {
-        notEmptySlots(slots);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(DELSLOTS);
-
-        for (int slot : slots) {
-            args.add(slot);
-        }
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterInfo() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(INFO);
-
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterMyId() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(MYID);
-
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterNodes() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(NODES);
-
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, List<K>> clusterGetKeysInSlot(int slot, int count) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(GETKEYSINSLOT).add(slot).add(count);
-        return createCommand(CLUSTER, new KeyListOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> clusterCountKeysInSlot(int slot) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(COUNTKEYSINSLOT).add(slot);
-        return createCommand(CLUSTER, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> clusterCountFailureReports(String nodeId) {
-        assertNodeId(nodeId);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add("COUNT-FAILURE-REPORTS").add(nodeId);
-        return createCommand(CLUSTER, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> clusterKeyslot(K key) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(KEYSLOT).addKey(key);
-        return createCommand(CLUSTER, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterSaveconfig() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(SAVECONFIG);
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterSetConfigEpoch(long configEpoch) {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add("SET-CONFIG-EPOCH").add(configEpoch);
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, List<Object>> clusterSlots() {
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(SLOTS);
-        return createCommand(CLUSTER, new ArrayOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterSetSlotNode(int slot, String nodeId) {
-        assertNodeId(nodeId);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(SETSLOT).add(slot).add(NODE).add(nodeId);
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterSetSlotStable(int slot) {
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(SETSLOT).add(slot).add(STABLE);
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterSetSlotMigrating(int slot, String nodeId) {
-        assertNodeId(nodeId);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(SETSLOT).add(slot).add(MIGRATING).add(nodeId);
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterSetSlotImporting(int slot, String nodeId) {
-        assertNodeId(nodeId);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(SETSLOT).add(slot).add(IMPORTING).add(nodeId);
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, String> clusterReplicate(String nodeId) {
-        assertNodeId(nodeId);
+        notNull(channel);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(REPLICATE).add(nodeId);
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
 
-    public Command<K, V, String> asking() {
+        args.addKey(key);
+        scanArgs(scanCursor, scanArgs, args);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec);
-        return createCommand(ASKING, new StatusOutput<K, V>(codec), args);
+        ScoredValueScanStreamingOutput<K, V> output = new ScoredValueScanStreamingOutput<>(codec, channel);
+        return createCommand(ZSCAN, output, args);
     }
 
-    public Command<K, V, String> clusterFlushslots() {
+    Command<K, V, Double> zscore(K key, V member) {
+        notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(FLUSHSLOTS);
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
+        return createCommand(ZSCORE, new DoubleOutput<>(codec), key, member);
     }
 
-    public Command<K, V, List<String>> clusterSlaves(String nodeId) {
-        assertNodeId(nodeId);
+    Command<K, V, Long> zunionstore(K destination, K... keys) {
+        notEmpty(keys);
+        LettuceAssert.notNull(destination, "Destination " + MUST_NOT_BE_NULL);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(SLAVES).add(nodeId);
-        return createCommand(CLUSTER, new StringListOutput<K, V>(codec), args);
+        return zunionstore(destination, new ZStoreArgs(), keys);
     }
 
-    public Command<K, V, String> clusterFailover(boolean force) {
+    Command<K, V, Long> zunionstore(K destination, ZStoreArgs storeArgs, K... keys) {
+        notEmpty(keys);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(FAILOVER);
-        if (force) {
-            args.add(FORCE);
-        }
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
+        CommandArgs<K, V> args = new CommandArgs<>(codec);
+        args.addKey(destination).add(keys.length).addKeys(keys);
+        storeArgs.build(args);
+        return createCommand(ZUNIONSTORE, new IntegerOutput<>(codec), args);
     }
 
-    public Command<K, V, String> clusterReset(boolean hard) {
+    private boolean allElementsInstanceOf(Object[] objects, Class<?> expectedAssignableType) {
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).add(RESET);
-        if (hard) {
-            args.add(HARD);
-        } else {
-            args.add(SOFT);
+        for (Object object : objects) {
+            if (!expectedAssignableType.isAssignableFrom(object.getClass())) {
+                return false;
+            }
         }
-        return createCommand(CLUSTER, new StatusOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Long> geoadd(K key, double longitude, double latitude, V member) {
-        notNullKey(key);
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(longitude).add(latitude).addValue(member);
-        return createCommand(GEOADD, new IntegerOutput<K, V>(codec), args);
+        return true;
     }
 
-    public Command<K, V, Long> geoadd(K key, Object[] lngLatMember) {
-
-        notNullKey(key);
-        LettuceAssert.notNull(lngLatMember, "LngLatMember " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(lngLatMember, "LngLatMember " + MUST_NOT_BE_EMPTY);
-        LettuceAssert.noNullElements(lngLatMember, "LngLatMember " + MUST_NOT_CONTAIN_NULL_ELEMENTS);
-        LettuceAssert
-                .isTrue(lngLatMember.length % 3 == 0,
-                        "LngLatMember.length must be a multiple of 3 and contain a "
-                                + "sequence of longitude1, latitude1, member1, longitude2, latitude2, member2, ... longitudeN, latitudeN, memberN");
+    private byte[] maxValue(Range<? extends V> range) {
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key);
+        Range.Boundary<? extends V> upper = range.getUpper();
 
-        for (int i = 0; i < lngLatMember.length; i += 3) {
-            args.add((Double) lngLatMember[i]);
-            args.add((Double) lngLatMember[i + 1]);
-            args.addValue((V) lngLatMember[i + 2]);
+        if (upper.getValue() == null) {
+            return PLUS_BYTES;
         }
 
-        return createCommand(GEOADD, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, List<String>> geohash(K key, V... members) {
-        notNullKey(key);
-        LettuceAssert.notNull(members, "Members " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(members, "Members " + MUST_NOT_BE_EMPTY);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addValues(members);
-        return createCommand(GEOHASH, new StringListOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Set<V>> georadius(CommandType commandType, K key, double longitude, double latitude, double distance,
-            String unit) {
-        notNullKey(key);
-        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(longitude).add(latitude).add(distance).add(unit);
-        return createCommand(commandType, new ValueSetOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, List<GeoWithin<V>>> georadius(CommandType commandType, K key, double longitude, double latitude,
-            double distance, String unit,
-            GeoArgs geoArgs) {
-
-        notNullKey(key);
-        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
-        LettuceAssert.notNull(geoArgs, "GeoArgs " + MUST_NOT_BE_NULL);
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(longitude).add(latitude).add(distance).add(unit);
-        geoArgs.build(args);
-
-        return createCommand(commandType, new GeoWithinListOutput<K, V>(codec, geoArgs.isWithDistance(), geoArgs.isWithHash(),
-                geoArgs.isWithCoordinates()), args);
-    }
-
-    public Command<K, V, Long> georadius(K key, double longitude, double latitude, double distance, String unit,
-            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
-
-        notNullKey(key);
-        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
-        LettuceAssert.notNull(geoRadiusStoreArgs, "GeoRadiusStoreArgs " + MUST_NOT_BE_NULL);
-        LettuceAssert.isTrue(geoRadiusStoreArgs.getStoreKey() != null || geoRadiusStoreArgs.getStoreDistKey() != null,
-                "At least STORE key or STORDIST key is required");
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).add(longitude).add(latitude).add(distance).add(unit);
-        geoRadiusStoreArgs.build(args);
-
-        return createCommand(GEORADIUS, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, Set<V>> georadiusbymember(CommandType commandType, K key, V member, double distance, String unit) {
-
-        notNullKey(key);
-        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addValue(member).add(distance).add(unit);
-        return createCommand(commandType, new ValueSetOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, List<GeoWithin<V>>> georadiusbymember(CommandType commandType, K key, V member, double distance,
-            String unit, GeoArgs geoArgs) {
-
-        notNullKey(key);
-        LettuceAssert.notNull(geoArgs, "GeoArgs " + MUST_NOT_BE_NULL);
-        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addValue(member).add(distance).add(unit);
-        geoArgs.build(args);
-
-        return createCommand(
-commandType,
-                new GeoWithinListOutput<K, V>(codec, geoArgs.isWithDistance(), geoArgs.isWithHash(), geoArgs
-                        .isWithCoordinates()), args);
-    }
-
-    public Command<K, V, Long> georadiusbymember(K key, V member, double distance, String unit,
-            GeoRadiusStoreArgs<K> geoRadiusStoreArgs) {
-
-        notNullKey(key);
-        LettuceAssert.notNull(geoRadiusStoreArgs, "GeoRadiusStoreArgs " + MUST_NOT_BE_NULL);
-        LettuceAssert.notNull(unit, "Unit " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(unit, "Unit " + MUST_NOT_BE_EMPTY);
-        LettuceAssert.isTrue(geoRadiusStoreArgs.getStoreKey() != null || geoRadiusStoreArgs.getStoreDistKey() != null,
-                "At least STORE key or STORDIST key is required");
-
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addValue(member).add(distance).add(unit);
-        geoRadiusStoreArgs.build(args);
-
-        return createCommand(GEORADIUSBYMEMBER, new IntegerOutput<K, V>(codec), args);
-    }
-
-    public Command<K, V, List<GeoCoordinates>> geopos(K key, V[] members) {
-        notNullKey(key);
-        LettuceAssert.notNull(members, "Members " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(members, "Members " + MUST_NOT_BE_EMPTY);
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addValues(members);
+        ByteBuffer encoded = codec.encodeValue(upper.getValue());
+        ByteBuffer allocated = ByteBuffer.allocate(encoded.remaining() + 1);
+        allocated.put(upper.isIncluding() ? (byte) '[' : (byte) '(').put(encoded);
 
-        return createCommand(GEOPOS, new GeoCoordinatesListOutput<K, V>(codec), args);
+        return allocated.array();
     }
 
-    public Command<K, V, Double> geodist(K key, V from, V to, GeoArgs.Unit unit) {
-        notNullKey(key);
-        LettuceAssert.notNull(from, "From " + MUST_NOT_BE_NULL);
-        LettuceAssert.notNull(from, "To " + MUST_NOT_BE_NULL);
+    private byte[] minValue(Range<? extends V> range) {
 
-        CommandArgs<K, V> args = new CommandArgs<K, V>(codec).addKey(key).addValue(from).addValue(to);
+        Range.Boundary<? extends V> lower = range.getLower();
 
-        if (unit != null) {
-            args.add(unit.name());
+        if (lower.getValue() == null) {
+            return MINUS_BYTES;
         }
 
-        return createCommand(GEODIST, new DoubleOutput<K, V>(codec), args);
+        ByteBuffer encoded = codec.encodeValue(lower.getValue());
+        ByteBuffer allocated = ByteBuffer.allocate(encoded.remaining() + 1);
+        allocated.put(lower.isIncluding() ? (byte) '[' : (byte) '(').put(encoded);
+
+        return allocated.array();
     }
 
-    public static void notNull(ScoredValueStreamingChannel<?> channel) {
+    static void notNull(ScoredValueStreamingChannel<?> channel) {
         LettuceAssert.notNull(channel, "ScoredValueStreamingChannel " + MUST_NOT_BE_NULL);
     }
 
-    public static void notNull(KeyStreamingChannel<?> channel) {
+    static void notNull(KeyStreamingChannel<?> channel) {
         LettuceAssert.notNull(channel, "KeyValueStreamingChannel " + MUST_NOT_BE_NULL);
     }
 
-    public static void notNull(ValueStreamingChannel<?> channel) {
+    static void notNull(ValueStreamingChannel<?> channel) {
         LettuceAssert.notNull(channel, "ValueStreamingChannel " + MUST_NOT_BE_NULL);
     }
 
-    public static void notNull(KeyValueStreamingChannel<?, ?> channel) {
+    static void notNull(KeyValueStreamingChannel<?, ?> channel) {
         LettuceAssert.notNull(channel, "KeyValueStreamingChannel " + MUST_NOT_BE_NULL);
     }
 
-    private static void notNullKey(Object key) {
-        LettuceAssert.notNull(key, "Key " + MUST_NOT_BE_NULL);
-    }
-
-    private static void notNullRange(Range<?> range) {
-        LettuceAssert.notNull(range, "Range " + MUST_NOT_BE_NULL);
-    }
-
-    private static void notNullLimit(Limit limit) {
-        LettuceAssert.notNull(limit, "Limit " + MUST_NOT_BE_NULL);
-    }
-
-    public static void notNullMinMax(String min, String max) {
+    static void notNullMinMax(String min, String max) {
         LettuceAssert.notNull(min, "Min " + MUST_NOT_BE_NULL);
         LettuceAssert.notNull(max, "Max " + MUST_NOT_BE_NULL);
     }
 
-    private static void notEmpty(Object[] keys) {
-        LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(keys, "Keys " + MUST_NOT_BE_EMPTY);
-    }
-
-    private static void notEmptyValues(Object[] values) {
-        LettuceAssert.notNull(values, "Values " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(values, "Values " + MUST_NOT_BE_EMPTY);
-    }
-
-    private static void assertNodeId(String nodeId) {
-        LettuceAssert.notNull(nodeId, "NodeId " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(nodeId, "NodeId " + MUST_NOT_BE_EMPTY);
-    }
-
-    private static void notEmptySlots(int[] slots) {
-        LettuceAssert.notNull(slots, "Slots " + MUST_NOT_BE_NULL);
-        LettuceAssert.notEmpty(slots, "Slots " + MUST_NOT_BE_EMPTY);
-    }
-
     private static void addLimit(CommandArgs<?, ?> args, Limit limit) {
 
         if (limit.isLimited()) {
@@ -2735,20 +2729,9 @@ private static void addLimit(CommandArgs<?, ?> args, Limit limit) {
         }
     }
 
-    private static String min(Range<? extends Number> range) {
-
-        Range.Boundary<? extends Number> lower = range.getLower();
-
-        if (lower.getValue() == null || lower.getValue() instanceof Double
-                && lower.getValue().doubleValue() == Double.NEGATIVE_INFINITY) {
-            return "-inf";
-        }
-
-        if (!lower.isIncluding()) {
-            return "(" + lower.getValue();
-        }
-
-        return lower.getValue().toString();
+    private static void assertNodeId(String nodeId) {
+        LettuceAssert.notNull(nodeId, "NodeId " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(nodeId, "NodeId " + MUST_NOT_BE_EMPTY);
     }
 
     private static String max(Range<? extends Number> range) {
@@ -2767,33 +2750,46 @@ private static String max(Range<? extends Number> range) {
         return upper.getValue().toString();
     }
 
-    private byte[] minValue(Range<? extends V> range) {
+    private static String min(Range<? extends Number> range) {
 
-        Range.Boundary<? extends V> lower = range.getLower();
+        Range.Boundary<? extends Number> lower = range.getLower();
 
-        if (lower.getValue() == null) {
-            return MINUS_BYTES;
+        if (lower.getValue() == null || lower.getValue() instanceof Double
+                && lower.getValue().doubleValue() == Double.NEGATIVE_INFINITY) {
+            return "-inf";
         }
 
-        ByteBuffer encoded = codec.encodeValue(lower.getValue());
-        ByteBuffer allocated = ByteBuffer.allocate(encoded.remaining() + 1);
-        allocated.put(lower.isIncluding() ? (byte) '[' : (byte) '(').put(encoded);
+        if (!lower.isIncluding()) {
+            return "(" + lower.getValue();
+        }
 
-        return allocated.array();
+        return lower.getValue().toString();
     }
 
-    private byte[] maxValue(Range<? extends V> range) {
+    private static void notEmpty(Object[] keys) {
+        LettuceAssert.notNull(keys, "Keys " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(keys, "Keys " + MUST_NOT_BE_EMPTY);
+    }
 
-        Range.Boundary<? extends V> upper = range.getUpper();
+    private static void notEmptySlots(int[] slots) {
+        LettuceAssert.notNull(slots, "Slots " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(slots, "Slots " + MUST_NOT_BE_EMPTY);
+    }
 
-        if (upper.getValue() == null) {
-            return PLUS_BYTES;
-        }
+    private static void notEmptyValues(Object[] values) {
+        LettuceAssert.notNull(values, "Values " + MUST_NOT_BE_NULL);
+        LettuceAssert.notEmpty(values, "Values " + MUST_NOT_BE_EMPTY);
+    }
 
-        ByteBuffer encoded = codec.encodeValue(upper.getValue());
-        ByteBuffer allocated = ByteBuffer.allocate(encoded.remaining() + 1);
-        allocated.put(upper.isIncluding() ? (byte) '[' : (byte) '(').put(encoded);
+    private static void notNullKey(Object key) {
+        LettuceAssert.notNull(key, "Key " + MUST_NOT_BE_NULL);
+    }
 
-        return allocated.array();
+    private static void notNullLimit(Limit limit) {
+        LettuceAssert.notNull(limit, "Limit " + MUST_NOT_BE_NULL);
+    }
+
+    private static void notNullRange(Range<?> range) {
+        LettuceAssert.notNull(range, "Range " + MUST_NOT_BE_NULL);
     }
 }