diff --git a/src/main/java/redis/clients/jedis/BasicRedisPipeline.java b/src/main/java/redis/clients/jedis/BasicRedisPipeline.java
index 0b4ac36..97658d8 100644
--- a/src/main/java/redis/clients/jedis/BasicRedisPipeline.java
+++ b/src/main/java/redis/clients/jedis/BasicRedisPipeline.java
@@ -22,12 +22,6 @@ public interface BasicRedisPipeline {
 
     Response<Long> lastsave();
 
-    Response<String> discard();
-
-    Response<List<Object>> exec();
-
-    Response<String> multi();
-
     Response<String> flushDB();
 
     Response<String> flushAll();
diff --git a/src/main/java/redis/clients/jedis/BinaryRedisPipeline.java b/src/main/java/redis/clients/jedis/BinaryRedisPipeline.java
index 3722351..5c04491 100644
--- a/src/main/java/redis/clients/jedis/BinaryRedisPipeline.java
+++ b/src/main/java/redis/clients/jedis/BinaryRedisPipeline.java
@@ -111,18 +111,18 @@ public interface BinaryRedisPipeline {
 
     Response<Long> setrange(String key, long offset, String value);
 
-    Response<Set<String>> smembers(byte[] key);
+    Response<Set<byte[]>> smembers(byte[] key);
 
     Response<Boolean> sismember(byte[] key, byte[] member);
 
-    Response<Long> sort(byte[] key);
+    Response<List<byte[]>> sort(byte[] key);
 
-    Response<List<String>> sort(byte[] key,
+    Response<List<byte[]>> sort(byte[] key,
                                 SortingParams sortingParameters);
 
-    Response<String> spop(byte[] key);
+    Response<byte[]> spop(byte[] key);
 
-    Response<String> srandmember(byte[] key);
+    Response<byte[]> srandmember(byte[] key);
 
     Response<Long> srem(byte[] key, byte[] member);
 
@@ -142,18 +142,18 @@ public interface BinaryRedisPipeline {
 
     Response<Double> zincrby(byte[] key, double score, byte[] member);
 
-    Response<Set<String>> zrange(byte[] key, int start, int end);
+    Response<Set<byte[]>> zrange(byte[] key, int start, int end);
 
-    Response<Set<String>> zrangeByScore(byte[] key, double min,
+    Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
                                         double max);
 
-    Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
+    Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
                                         byte[] max);
 
-    Response<Set<String>> zrangeByScore(byte[] key, double min,
+    Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
                                         double max, int offset, int count);
 
-    Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
+    Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
                                         byte[] max, int offset, int count);
 
     Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
@@ -168,16 +168,16 @@ public interface BinaryRedisPipeline {
     Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
                                                  byte[] max, int offset, int count);
 
-    Response<Set<String>> zrevrangeByScore(byte[] key, double max,
+    Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
                                            double min);
 
-    Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
+    Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
                                            byte[] min);
 
-    Response<Set<String>> zrevrangeByScore(byte[] key, double max,
+    Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
                                            double min, int offset, int count);
 
-    Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
+    Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
                                            byte[] min, int offset, int count);
 
     Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
@@ -204,7 +204,7 @@ public interface BinaryRedisPipeline {
 
     Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end);
 
-    Response<Set<String>> zrevrange(byte[] key, int start, int end);
+    Response<Set<byte[]>> zrevrange(byte[] key, int start, int end);
 
     Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
                                              int end);
diff --git a/src/main/java/redis/clients/jedis/MultiKeyBinaryRedisPipeline.java b/src/main/java/redis/clients/jedis/MultiKeyBinaryRedisPipeline.java
index 74f0e3d..85d004b 100644
--- a/src/main/java/redis/clients/jedis/MultiKeyBinaryRedisPipeline.java
+++ b/src/main/java/redis/clients/jedis/MultiKeyBinaryRedisPipeline.java
@@ -23,7 +23,7 @@ public interface MultiKeyBinaryRedisPipeline {
 
     Response<Long> msetnx(byte[]... keysvalues);
 
-    Response<byte[]> rename(byte[] oldkey, byte[] newkey);
+    Response<String> rename(byte[] oldkey, byte[] newkey);
 
     Response<Long> renamenx(byte[] oldkey, byte[] newkey);
 
@@ -43,7 +43,7 @@ public interface MultiKeyBinaryRedisPipeline {
 
     Response<List<byte[]>> sort(byte[] key, byte[] dstkey);
 
-    Response<Set<String>> sunion(byte[]... keys);
+    Response<Set<byte[]>> sunion(byte[]... keys);
 
     Response<Long> sunionstore(byte[] dstkey, byte[]... keys);
 
diff --git a/src/main/java/redis/clients/jedis/Pipeline.java b/src/main/java/redis/clients/jedis/Pipeline.java
index afd98f5..d605f25 100755
--- a/src/main/java/redis/clients/jedis/Pipeline.java
+++ b/src/main/java/redis/clients/jedis/Pipeline.java
@@ -586,9 +586,9 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING);
     }
 
-    public Response<byte[]> rename(byte[] oldkey, byte[] newkey) {
+    public Response<String> rename(byte[] oldkey, byte[] newkey) {
         client.rename(oldkey, newkey);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
+        return getResponse(BuilderFactory.STRING);
     }
 
     public Response<Long> renamenx(String oldkey, String newkey) {
@@ -766,9 +766,9 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING_SET);
     }
 
-    public Response<Set<String>> smembers(byte[] key) {
+    public Response<Set<byte[]>> smembers(byte[] key) {
         client.smembers(key);
-        return getResponse(BuilderFactory.STRING_SET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Long> smove(String srckey, String dstkey, String member) {
@@ -781,14 +781,14 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.LONG);
     }
 
-    public Response<Long> sort(String key) {
+    public Response<List<String>> sort(String key) {
         client.sort(key);
-        return getResponse(BuilderFactory.LONG);
+        return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public Response<Long> sort(byte[] key) {
+    public Response<List<byte[]>> sort(byte[] key) {
         client.sort(key);
-        return getResponse(BuilderFactory.LONG);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
     }
 
     public Response<List<String>> sort(String key,
@@ -797,10 +797,10 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public Response<List<String>> sort(byte[] key,
+    public Response<List<byte[]>> sort(byte[] key,
                                        SortingParams sortingParameters) {
         client.sort(key, sortingParameters);
-        return getResponse(BuilderFactory.STRING_LIST);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
     }
 
     public Response<List<String>> sort(String key,
@@ -830,9 +830,9 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING);
     }
 
-    public Response<String> spop(byte[] key) {
+    public Response<byte[]> spop(byte[] key) {
         client.spop(key);
-        return getResponse(BuilderFactory.STRING);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<String> srandmember(String key) {
@@ -840,9 +840,9 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING);
     }
 
-    public Response<String> srandmember(byte[] key) {
+    public Response<byte[]> srandmember(byte[] key) {
         client.srandmember(key);
-        return getResponse(BuilderFactory.STRING);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<Long> srem(String key, String member) {
@@ -880,9 +880,9 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING_SET);
     }
 
-    public Response<Set<String>> sunion(byte[]... keys) {
+    public Response<Set<byte[]>> sunion(byte[]... keys) {
         client.sunion(keys);
-        return getResponse(BuilderFactory.STRING_SET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Long> sunionstore(String dstkey, String... keys) {
@@ -992,9 +992,9 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrange(byte[] key, int start, int end) {
+    public Response<Set<byte[]>> zrange(byte[] key, int start, int end) {
         client.zrange(key, start, end);
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(String key, double min,
@@ -1003,7 +1003,7 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrangeByScore(byte[] key, double min,
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
                                                double max) {
         return zrangeByScore(key, toByteArray(min), toByteArray(max));
     }
@@ -1014,10 +1014,10 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
                                                byte[] max) {
         client.zrangeByScore(key, min, max);
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(String key, double min,
@@ -1026,15 +1026,15 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrangeByScore(byte[] key, double min,
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
                                                double max, int offset, int count) {
         return zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
     }
     
-    public Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
                                                byte[] max, int offset, int count) {
         client.zrangeByScore(key, min, max, offset, count);
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
@@ -1051,7 +1051,7 @@ public class Pipeline extends Queable implements
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
                                                         byte[] max) {
         client.zrangeByScoreWithScores(key, min, max);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
@@ -1063,13 +1063,13 @@ public class Pipeline extends Queable implements
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
                                                         double max, int offset, int count) {
         client.zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
     
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
                                                         byte[] max, int offset, int count) {
         client.zrangeByScoreWithScores(key, min, max, offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, double max,
@@ -1078,10 +1078,10 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrevrangeByScore(byte[] key, double max,
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
                                                   double min) {
         client.zrevrangeByScore(key, toByteArray(max), toByteArray(min));
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, String max,
@@ -1090,10 +1090,10 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
                                                   byte[] min) {
         client.zrevrangeByScore(key, max, min);
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, double max,
@@ -1102,16 +1102,16 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrevrangeByScore(byte[] key, double max,
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
                                                   double min, int offset, int count) {
         client.zrevrangeByScore(key, toByteArray(max), toByteArray(min), offset, count);
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
     
-    public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
                                                   byte[] min, int offset, int count) {
         client.zrevrangeByScore(key, max, min, offset, count);
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
@@ -1123,13 +1123,13 @@ public class Pipeline extends Queable implements
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                            double max, double min) {
         client.zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
     
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                            byte[] max, byte[] min) {
         client.zrevrangeByScoreWithScores(key, max, min);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
@@ -1141,13 +1141,13 @@ public class Pipeline extends Queable implements
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                            double max, double min, int offset, int count) {
         client.zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min), offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
     
     public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
                                                            byte[] max, byte[] min, int offset, int count) {
         client.zrevrangeByScoreWithScores(key, max, min, offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
@@ -1157,7 +1157,7 @@ public class Pipeline extends Queable implements
 
     public Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end) {
         client.zrangeWithScores(key, start, end);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
     }
 
     public Response<Long> zrank(String key, String member) {
@@ -1210,9 +1210,9 @@ public class Pipeline extends Queable implements
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrevrange(byte[] key, int start, int end) {
+    public Response<Set<byte[]>> zrevrange(byte[] key, int start, int end) {
         client.zrevrange(key, start, end);
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
diff --git a/src/main/java/redis/clients/jedis/RedisPipeline.java b/src/main/java/redis/clients/jedis/RedisPipeline.java
index 8d42aa2..b1c8461 100644
--- a/src/main/java/redis/clients/jedis/RedisPipeline.java
+++ b/src/main/java/redis/clients/jedis/RedisPipeline.java
@@ -116,7 +116,7 @@ public interface RedisPipeline {
 
     Response<Set<String>> smembers(String key);
 
-    Response<Long> sort(String key);
+    Response<List<String>> sort(String key);
 
     Response<List<String>> sort(String key,
                                 SortingParams sortingParameters);
diff --git a/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java b/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
index 1234b44..2601f9c 100644
--- a/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
+++ b/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
@@ -700,11 +700,11 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         return getResponse(BuilderFactory.STRING_SET);
     }
 
-    public Response<Set<String>> smembers(byte[] key) {
+    public Response<Set<byte[]>> smembers(byte[] key) {
         Client c = getClient(key);
         c.smembers(key);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_SET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Long> srem(String key, String member) {
@@ -742,11 +742,11 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         return getResponse(BuilderFactory.STRING);
     }
 
-    public Response<String> spop(byte[] key) {
+    public Response<byte[]> spop(byte[] key) {
         Client c = getClient(key);
         c.spop(key);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<Long> scard(String key) {
@@ -784,11 +784,11 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         return getResponse(BuilderFactory.STRING);
     }
 
-    public Response<String> srandmember(byte[] key) {
+    public Response<byte[]> srandmember(byte[] key) {
         Client c = getClient(key);
         c.srandmember(key);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
     public Response<Long> zadd(String key, double score, String member) {
@@ -812,11 +812,11 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrange(byte[] key, int start, int end) {
+    public Response<Set<byte[]>> zrange(byte[] key, int start, int end) {
         Client c = getClient(key);
         c.zrange(key, start, end);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Long> zrem(String key, String member) {
@@ -882,11 +882,11 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrevrange(byte[] key, int start, int end) {
+    public Response<Set<byte[]>> zrevrange(byte[] key, int start, int end) {
         Client c = getClient(key);
         c.zrevrange(key, start, end);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
@@ -945,18 +945,18 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         return getResponse(BuilderFactory.DOUBLE);
     }
 
-    public Response<Long> sort(String key) {
+    public Response<List<String>> sort(String key) {
         Client c = getClient(key);
         c.sort(key);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
+        return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public Response<Long> sort(byte[] key) {
+    public Response<List<byte[]>> sort(byte[] key) {
         Client c = getClient(key);
         c.sort(key);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
     }
 
     public Response<List<String>> sort(String key, SortingParams sortingParameters) {
@@ -966,11 +966,11 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public Response<List<String>> sort(byte[] key, SortingParams sortingParameters) {
+    public Response<List<byte[]>> sort(byte[] key, SortingParams sortingParameters) {
         Client c = getClient(key);
         c.sort(key, sortingParameters);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_LIST);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
     }
 
     public Response<Long> zcount(String key, double min, double max) {
@@ -1001,18 +1001,18 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrevrangeByScore(byte[] key, double max, double min) {
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max, double min) {
         Client c = getClient(key);
         c.zrevrangeByScore(key, toByteArray(min), toByteArray(max));
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
-    public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
         Client c = getClient(key);
         c.zrevrangeByScore(key, min, max);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(String key, double max, double min, int offset, int count) {
@@ -1022,18 +1022,18 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
         Client c = getClient(key);
         c.zrevrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
-    public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
         Client c = getClient(key);
         c.zrevrangeByScore(key, min, max, offset, count);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(String key, String min, String max) {
@@ -1050,18 +1050,18 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrangeByScore(byte[] key, double min, double max) {
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, double min, double max) {
         Client c = getClient(key);
         c.zrangeByScore(key, toByteArray(min), toByteArray(max));
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
-    public Response<Set<String>> zrangeByScore(byte[] key, byte[] min, byte[] max) {
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min, byte[] max) {
         Client c = getClient(key);
         c.zrangeByScore(key, min, max);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(String key, double min, double max,
@@ -1072,20 +1072,20 @@ public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
-    public Response<Set<String>> zrangeByScore(byte[] key, double min, double max,
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, double min, double max,
                                                int offset, int count) {
         Client c = getClient(key);
         c.zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
-    public Response<Set<String>> zrangeByScore(byte[] key, byte[] min, byte[] max,
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min, byte[] max,
                                                int offset, int count) {
         Client c = getClient(key);
         c.zrangeByScore(key, min, max, offset, count);
         results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max) {