diff --git a/src/main/java/redis/clients/jedis/BinaryTransaction.java b/src/main/java/redis/clients/jedis/BinaryTransaction.java
index 3ae9656..7b903b0 100644
--- a/src/main/java/redis/clients/jedis/BinaryTransaction.java
+++ b/src/main/java/redis/clients/jedis/BinaryTransaction.java
@@ -1,11 +1,13 @@
 package redis.clients.jedis;
 
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import redis.clients.jedis.BinaryClient.LIST_POSITION;
 
-public class BinaryTransaction {
+public class BinaryTransaction extends Queable {
     protected Client client = null;
     protected boolean inTransaction = true;
 
@@ -16,363 +18,533 @@ public class BinaryTransaction {
         this.client = client;
     }
 
-    public void ping() {
-        client.ping();
-    }
-
-    public void set(final byte[] key, final byte[] value) {
-        client.set(key, value);
-    }
-
-    public void get(final byte[] key) {
-        client.get(key);
-    }
-
-    public void exists(final byte[] key) {
-        client.exists(key);
-    }
-
-    public void del(final byte[]... keys) {
-        client.del(keys);
-    }
-
-    public void type(final byte[] key) {
-        client.type(key);
-    }
-
-    public void flushDB() {
-        client.flushDB();
-    }
-
-    public void keys(final byte[] pattern) {
-        client.keys(pattern);
-    }
-
-    public void randomBinaryKey() {
-        client.randomKey();
-    }
-
-    public void rename(final byte[] oldkey, final byte[] newkey) {
-        client.rename(oldkey, newkey);
-    }
-
-    public void renamenx(final byte[] oldkey, final byte[] newkey) {
-        client.renamenx(oldkey, newkey);
-    }
-
-    public void dbSize() {
-        client.dbSize();
-    }
-
-    public void expire(final byte[] key, final int seconds) {
-        client.expire(key, seconds);
-    }
-
-    public void expireAt(final byte[] key, final long unixTime) {
-        client.expireAt(key, unixTime);
-    }
-
-    public void ttl(final byte[] key) {
-        client.ttl(key);
-    }
-
-    public void select(final int index) {
-        client.select(index);
-    }
-
-    public void move(final byte[] key, final int dbIndex) {
-        client.move(key, dbIndex);
-    }
-
-    public void flushAll() {
-        client.flushAll();
-    }
-
-    public void getSet(final byte[] key, final byte[] value) {
-        client.getSet(key, value);
-    }
-
-    public void mget(final byte[]... keys) {
-        client.mget(keys);
-    }
-
-    public void setnx(final byte[] key, final byte[] value) {
-        client.setnx(key, value);
-    }
-
-    public void setex(final byte[] key, final int seconds, final byte[] value) {
-        client.setex(key, seconds, value);
-    }
-
-    public void mset(final byte[]... keysvalues) {
-        client.mset(keysvalues);
-    }
-
-    public void msetnx(final byte[]... keysvalues) {
-        client.msetnx(keysvalues);
-    }
-
-    public void decrBy(final byte[] key, final int integer) {
-        client.decrBy(key, integer);
-    }
-
-    public void decr(final byte[] key) {
-        client.decr(key);
-    }
-
-    public void incrBy(final byte[] key, final int integer) {
-        client.incrBy(key, integer);
-    }
-
-    public void incr(final byte[] key) {
-        client.incr(key);
-    }
-
-    public void append(final byte[] key, final byte[] value) {
-        client.append(key, value);
-    }
-
-    public void substr(final byte[] key, final int start, final int end) {
-        client.substr(key, start, end);
-    }
-
-    public void hset(final byte[] key, final byte[] field, final byte[] value) {
-        client.hset(key, field, value);
-    }
-
-    public void hget(final byte[] key, final byte[] field) {
-        client.hget(key, field);
-    }
-
-    public void hsetnx(final byte[] key, final byte[] field,
-            final byte[] value) {
-        client.hsetnx(key, field, value);
-    }
-
-    public void hmset(final byte[] key, final Map<byte[], byte[]> hash) {
-        client.hmset(key, hash);
-    }
-
-    public void hmget(final byte[] key, final byte[]... fields) {
-        client.hmget(key, fields);
-    }
-
-    public void hincrBy(final byte[] key, final byte[] field, final int value) {
-        client.hincrBy(key, field, value);
-    }
-
-    public void hexists(final byte[] key, final byte[] field) {
-        client.hexists(key, field);
-    }
-
-    public void hdel(final byte[] key, final byte[] field) {
-        client.hdel(key, field);
-    }
-
-    public void hlen(final byte[] key) {
-        client.hlen(key);
-    }
-
-    public void hkeys(final byte[] key) {
-        client.hkeys(key);
-    }
-
-    public void hvals(final byte[] key) {
-        client.hvals(key);
-    }
-
-    public void hgetAll(final byte[] key) {
-        client.hgetAll(key);
-    }
-
-    public void rpush(final byte[] key, final byte[] string) {
-        client.rpush(key, string);
-    }
-
-    public void lpush(final byte[] key, final byte[] string) {
-        client.lpush(key, string);
-    }
-
-    public void llen(final byte[] key) {
-        client.llen(key);
-    }
-
-    public void lrange(final byte[] key, final int start, final int end) {
-        client.lrange(key, start, end);
-    }
-
-    public void ltrim(final byte[] key, final int start, final int end) {
-        client.ltrim(key, start, end);
-    }
-
-    public void lindex(final byte[] key, final int index) {
-        client.lindex(key, index);
-    }
-
-    public void lset(final byte[] key, final int index, final byte[] value) {
-        client.lset(key, index, value);
-    }
-
-    public void lrem(final byte[] key, final int count, final byte[] value) {
-        client.lrem(key, count, value);
-    }
-
-    public void lpop(final byte[] key) {
-        client.lpop(key);
-    }
-
-    public void rpop(final byte[] key) {
-        client.rpop(key);
-    }
-
-    public void rpoplpush(final byte[] srckey, final byte[] dstkey) {
-        client.rpoplpush(srckey, dstkey);
-    }
-
-    public void sadd(final byte[] key, final byte[] member) {
-        client.sadd(key, member);
-    }
-
-    public void smembers(final byte[] key) {
-        client.smembers(key);
-    }
-
-    public void srem(final byte[] key, final byte[] member) {
-        client.srem(key, member);
-    }
-
-    public void spop(final byte[] key) {
-        client.spop(key);
-    }
-
-    public void smove(final byte[] srckey, final byte[] dstkey,
-            final byte[] member) {
-        client.smove(srckey, dstkey, member);
-    }
-
-    public void scard(final byte[] key) {
-        client.scard(key);
-    }
-
-    public void sismember(final byte[] key, final byte[] member) {
-        client.sismember(key, member);
-    }
-
-    public void sinter(final byte[]... keys) {
-        client.sinter(keys);
-    }
-
-    public void sinterstore(final byte[] dstkey, final byte[]... keys) {
-        client.sinterstore(dstkey, keys);
-    }
-
-    public void sunion(final byte[]... keys) {
-        client.sunion(keys);
-    }
-
-    public void sunionstore(final byte[] dstkey, final byte[]... keys) {
-        client.sunionstore(dstkey, keys);
-    }
-
-    public void sdiff(final byte[]... keys) {
-        client.sdiff(keys);
-    }
-
-    public void sdiffstore(final byte[] dstkey, final byte[]... keys) {
-        client.sdiffstore(dstkey, keys);
-    }
-
-    public void srandmember(final byte[] key) {
-        client.srandmember(key);
-    }
-
-    public void zadd(final byte[] key, final double score, final byte[] member) {
-        client.zadd(key, score, member);
-    }
-
-    public void zrange(final byte[] key, final int start, final int end) {
-        client.zrange(key, start, end);
-    }
-
-    public void zrem(final byte[] key, final byte[] member) {
-        client.zrem(key, member);
-    }
-
-    public void zincrby(final byte[] key, final double score,
-            final byte[] member) {
-        client.zincrby(key, score, member);
-    }
-
-    public void zrank(final byte[] key, final byte[] member) {
-        client.zrank(key, member);
-    }
-
-    public void zrevrank(final byte[] key, final byte[] member) {
-        client.zrevrank(key, member);
-    }
-
-    public void zrevrange(final byte[] key, final int start, final int end) {
-        client.zrevrange(key, start, end);
-    }
-
-    public void zrangeWithScores(final byte[] key, final int start,
-            final int end) {
-        client.zrangeWithScores(key, start, end);
-    }
-
-    public void zrevrangeWithScores(final byte[] key, final int start,
-            final int end) {
-        client.zrevrangeWithScores(key, start, end);
-    }
-
-    public void zcard(final byte[] key) {
-        client.zcard(key);
-    }
-
-    public void zscore(final byte[] key, final byte[] member) {
-        client.zscore(key, member);
-    }
-
     public List<Object> exec() {
         client.exec();
         client.getAll(1); // Discard all but the last reply
-        return client.getObjectMultiBulkReply();
+
+        List<Object> unformatted = client.getObjectMultiBulkReply();
+        if (unformatted == null) {
+            return null;
+        }
+        List<Object> formatted = new ArrayList<Object>();
+        for (Object o : unformatted) {
+            formatted.add(generateResponse(o).get());
+        }
+        return formatted;
     }
 
     public String discard() {
         client.discard();
         client.getAll(1); // Discard all but the last reply
         inTransaction = false;
+        clean();
         return client.getStatusCodeReply();
     }
 
-    public void sort(final byte[] key) {
-        client.sort(key);
+    public Response<Long> append(byte[] key, byte[] value) {
+        client.append(key, value);
+        return getResponse(BuilderFactory.LONG);
     }
 
-    public void sort(final byte[] key, final SortingParams sortingParameters) {
-        client.sort(key, sortingParameters);
+    public Response<List<String>> blpop(byte[]... args) {
+        client.blpop(args);
+        return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public void sort(final byte[] key, final SortingParams sortingParameters,
-            final byte[] dstkey) {
-        client.sort(key, sortingParameters, dstkey);
+    public Response<List<String>> brpop(byte[]... args) {
+        client.brpop(args);
+        return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public void sort(final byte[] key, final byte[] dstkey) {
-        client.sort(key, dstkey);
+    public Response<Long> decr(byte[] key) {
+        client.decr(key);
+        return getResponse(BuilderFactory.LONG);
     }
 
-    public void setbit(byte[] key, long offset, byte[] value) {
-        client.setbit(key, offset, value);
+    public Response<Long> decrBy(byte[] key, long integer) {
+        client.decrBy(key, integer);
+        return getResponse(BuilderFactory.LONG);
     }
 
-    public void getbit(byte[] key, long offset) {
-        client.getbit(key, offset);
+    public Response<Long> del(byte[]... keys) {
+        client.del(keys);
+        return getResponse(BuilderFactory.LONG);
     }
 
-    public void linsert(final byte[] key, final LIST_POSITION where,
-            final byte[] pivot, final byte[] value) {
+    public Response<String> echo(byte[] string) {
+        client.echo(string);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Boolean> exists(byte[] key) {
+        client.exists(key);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<Long> expire(byte[] key, int seconds) {
+        client.expire(key, seconds);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> expireAt(byte[] key, long unixTime) {
+        client.expireAt(key, unixTime);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> get(byte[] key) {
+        client.get(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> getSet(byte[] key, byte[] value) {
+        client.getSet(key, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> hdel(byte[] key, byte[] field) {
+        client.hdel(key, field);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Boolean> hexists(byte[] key, byte[] field) {
+        client.hexists(key, field);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<String> hget(byte[] key, byte[] field) {
+        client.hget(key, field);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Map<String, String>> hgetAll(byte[] key) {
+        client.hgetAll(key);
+        return getResponse(BuilderFactory.STRING_MAP);
+    }
+
+    public Response<Long> hincrBy(byte[] key, byte[] field, long value) {
+        client.hincrBy(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> hkeys(byte[] key) {
+        client.hkeys(key);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Long> hlen(byte[] key) {
+        client.hlen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> hmget(byte[] key, byte[]... fields) {
+        client.hmget(key, fields);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<String> hmset(byte[] key, Map<byte[], byte[]> hash) {
+        client.hmset(key, hash);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> hset(byte[] key, byte[] field, byte[] value) {
+        client.hset(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> hsetnx(byte[] key, byte[] field, byte[] value) {
+        client.hsetnx(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> hvals(byte[] key) {
+        client.hvals(key);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<Long> incr(byte[] key) {
+        client.incr(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> incrBy(byte[] key, long integer) {
+        client.incrBy(key, integer);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> keys(byte[] pattern) {
+        client.keys(pattern);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<String> lindex(byte[] key, int index) {
+        client.lindex(key, index);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> linsert(byte[] key, LIST_POSITION where,
+            byte[] pivot, byte[] value) {
         client.linsert(key, where, pivot, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> llen(byte[] key) {
+        client.llen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> lpop(byte[] key) {
+        client.lpop(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> lpush(byte[] key, byte[] string) {
+        client.lpush(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> lpushx(byte[] key, byte[] bytes) {
+        client.lpushx(key, bytes);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> lrange(byte[] key, int start, int end) {
+        client.lrange(key, start, end);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<Long> lrem(byte[] key, int count, byte[] value) {
+        client.lrem(key, count, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> lset(byte[] key, int index, byte[] value) {
+        client.lset(key, index, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> ltrim(byte[] key, int start, int end) {
+        client.ltrim(key, start, end);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<List<String>> mget(byte[]... keys) {
+        client.mget(keys);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<Long> move(byte[] key, int dbIndex) {
+        client.move(key, dbIndex);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> mset(byte[]... keysvalues) {
+        client.mset(keysvalues);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> msetnx(byte[]... keysvalues) {
+        client.msetnx(keysvalues);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> persist(byte[] key) {
+        client.persist(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> rename(byte[] oldkey, byte[] newkey) {
+        client.rename(oldkey, newkey);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> renamenx(byte[] oldkey, byte[] newkey) {
+        client.renamenx(oldkey, newkey);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> rpop(byte[] key) {
+        client.rpop(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> rpoplpush(byte[] srckey, byte[] dstkey) {
+        client.rpoplpush(srckey, dstkey);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> rpush(byte[] key, byte[] string) {
+        client.rpush(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> rpushx(byte[] key, byte[] string) {
+        client.rpushx(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sadd(byte[] key, byte[] member) {
+        client.sadd(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> scard(byte[] key) {
+        client.scard(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> sdiff(byte[]... keys) {
+        client.sdiff(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Long> sdiffstore(byte[] dstkey, byte[]... keys) {
+        client.sdiffstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> set(byte[] key, byte[] value) {
+        client.set(key, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Boolean> setbit(String key, long offset, boolean value) {
+        client.setbit(key, offset, value);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<String> setex(byte[] key, int seconds, byte[] value) {
+        client.setex(key, seconds, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> setnx(byte[] key, byte[] value) {
+        client.setnx(key, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> sinter(byte[]... keys) {
+        client.sinter(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Long> sinterstore(byte[] dstkey, byte[]... keys) {
+        client.sinterstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Boolean> sismember(byte[] key, byte[] member) {
+        client.sismember(key, member);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<Set<String>> smembers(byte[] key) {
+        client.smembers(key);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member) {
+        client.smove(srckey, dstkey, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> sort(byte[] key) {
+        client.sort(key);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<String>> sort(byte[] key,
+            SortingParams sortingParameters) {
+        client.sort(key, sortingParameters);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<String>> sort(byte[] key,
+            SortingParams sortingParameters, byte[] dstkey) {
+        client.sort(key, sortingParameters, dstkey);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<String>> sort(byte[] key, byte[] dstkey) {
+        client.sort(key, dstkey);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<String> spop(byte[] key) {
+        client.spop(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> srandmember(byte[] key) {
+        client.srandmember(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> srem(byte[] key, byte[] member) {
+        client.srem(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> strlen(byte[] key) {
+        client.strlen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> substr(byte[] key, int start, int end) {
+        client.substr(key, start, end);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Set<String>> sunion(byte[]... keys) {
+        client.sunion(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Long> sunionstore(byte[] dstkey, byte[]... keys) {
+        client.sunionstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> ttl(byte[] key) {
+        client.ttl(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> type(byte[] key) {
+        client.type(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> watch(byte[]... keys) {
+        client.watch(keys);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> zadd(byte[] key, double score, byte[] member) {
+        client.zadd(key, score, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zcard(byte[] key) {
+        client.zcard(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zcount(byte[] key, double min, double max) {
+        client.zcount(key, min, max);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Double> zincrby(byte[] key, double score, byte[] member) {
+        client.zincrby(key, score, member);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<Long> zinterstore(byte[] dstkey, byte[]... sets) {
+        client.zinterstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zinterstore(byte[] dstkey, ZParams params,
+            byte[]... sets) {
+        client.zinterstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> zrange(byte[] key, int start, int end) {
+        client.zrange(key, start, end);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(byte[] key, double min,
+            double max) {
+        client.zrangeByScore(key, min, max);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
+            byte[] max) {
+        client.zrangeByScore(key, min, max);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(byte[] key, double min,
+            double max, int offset, int count) {
+        client.zrangeByScore(key, min, max, offset, count);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
+            double max) {
+        client.zrangeByScoreWithScores(key, min, max);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
+            double max, int offset, int count) {
+        client.zrangeByScoreWithScores(key, min, max, offset, count);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end) {
+        client.zrangeWithScores(key, start, end);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Long> zrank(byte[] key, byte[] member) {
+        client.zrank(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zrem(byte[] key, byte[] member) {
+        client.zrem(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zremrangeByRank(byte[] key, int start, int end) {
+        client.zremrangeByRank(key, start, end);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zremrangeByScore(byte[] key, double start, double end) {
+        client.zremrangeByScore(key, start, end);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> zrevrange(byte[] key, int start, int end) {
+        client.zrevrange(key, start, end);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
+            int end) {
+        client.zrevrangeWithScores(key, start, end);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Long> zrevrank(byte[] key, byte[] member) {
+        client.zrevrank(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Double> zscore(byte[] key, byte[] member) {
+        client.zscore(key, member);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<Long> zunionstore(byte[] dstkey, byte[]... sets) {
+        client.zunionstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zunionstore(byte[] dstkey, ZParams params,
+            byte[]... sets) {
+        client.zunionstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> brpoplpush(byte[] source, byte[] destination,
+            int timeout) {
+        client.brpoplpush(source, destination, timeout);
+        return getResponse(BuilderFactory.STRING);
     }
 }
\ No newline at end of file
diff --git a/src/main/java/redis/clients/jedis/Pipeline.java b/src/main/java/redis/clients/jedis/Pipeline.java
index 9af12ef..432ec5f 100644
--- a/src/main/java/redis/clients/jedis/Pipeline.java
+++ b/src/main/java/redis/clients/jedis/Pipeline.java
@@ -1,30 +1,19 @@
 package redis.clients.jedis;
 
 import java.util.ArrayList;
-import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-import java.util.Queue;
 import java.util.Set;
 
 import redis.clients.jedis.BinaryClient.LIST_POSITION;
 
-public class Pipeline {
+public class Pipeline extends Queable {
     private Client client;
-    private Queue<Response<?>> pipelinedResponses = new LinkedList<Response<?>>();
 
     public void setClient(Client client) {
         this.client = client;
     }
 
-    private Response<?> generateResponse(Object data) {
-        Response<?> response = pipelinedResponses.poll();
-        if (response != null) {
-            response.set(data);
-        }
-        return response;
-    }
-
     public List<Object> sync() {
         List<Object> unformatted = client.getAll();
         List<Object> formatted = new ArrayList<Object>();
@@ -34,12 +23,6 @@ public class Pipeline {
         return formatted;
     }
 
-    private <T> Response<T> getResponse(Builder<T> builder) {
-        Response<T> lr = new Response<T>(builder);
-        pipelinedResponses.add(lr);
-        return lr;
-    }
-
     public Response<Long> append(String key, String value) {
         client.append(key, value);
         return getResponse(BuilderFactory.LONG);
diff --git a/src/main/java/redis/clients/jedis/Queable.java b/src/main/java/redis/clients/jedis/Queable.java
new file mode 100644
index 0000000..b8ff0e5
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/Queable.java
@@ -0,0 +1,27 @@
+package redis.clients.jedis;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Queable {
+    private Queue<Response<?>> pipelinedResponses = new LinkedList<Response<?>>();
+
+    protected void clean() {
+        pipelinedResponses.clear();
+    }
+
+    protected Response<?> generateResponse(Object data) {
+        Response<?> response = pipelinedResponses.poll();
+        if (response != null) {
+            response.set(data);
+        }
+        return response;
+    }
+
+    protected <T> Response<T> getResponse(Builder<T> builder) {
+        Response<T> lr = new Response<T>(builder);
+        pipelinedResponses.add(lr);
+        return lr;
+    }
+
+}
diff --git a/src/main/java/redis/clients/jedis/Transaction.java b/src/main/java/redis/clients/jedis/Transaction.java
index 32529f8..fa1446c 100644
--- a/src/main/java/redis/clients/jedis/Transaction.java
+++ b/src/main/java/redis/clients/jedis/Transaction.java
@@ -1,6 +1,8 @@
 package redis.clients.jedis;
 
+import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import redis.clients.jedis.BinaryClient.LIST_POSITION;
 
@@ -12,339 +14,556 @@ public class Transaction extends BinaryTransaction {
         super(client);
     }
 
-    public void set(final String key, final String value) {
-        client.set(key, value);
-    }
-
-    public void get(final String key) {
-        client.get(key);
-    }
-
-    public void exists(final String key) {
-        client.exists(key);
-    }
-
-    public void del(final String... keys) {
-        client.del(keys);
-    }
-
-    public void type(final String key) {
-        client.type(key);
-    }
-
-    public void keys(final String pattern) {
-        client.keys(pattern);
-    }
-
-    public void randomKey() {
-        client.randomKey();
-    }
-
-    public void rename(final String oldkey, final String newkey) {
-        client.rename(oldkey, newkey);
-    }
-
-    public void renamenx(final String oldkey, final String newkey) {
-        client.renamenx(oldkey, newkey);
-    }
-
-    public void expire(final String key, final int seconds) {
-        client.expire(key, seconds);
-    }
-
-    public void expireAt(final String key, final long unixTime) {
-        client.expireAt(key, unixTime);
-    }
-
-    public void ttl(final String key) {
-        client.ttl(key);
-    }
-
-    public void move(final String key, final int dbIndex) {
-        client.move(key, dbIndex);
-    }
-
-    public void getSet(final String key, final String value) {
-        client.getSet(key, value);
-    }
-
-    public void mget(final String... keys) {
-        client.mget(keys);
-    }
-
-    public void setnx(final String key, final String value) {
-        client.setnx(key, value);
-    }
-
-    public void setex(final String key, final int seconds, final String value) {
-        client.setex(key, seconds, value);
-    }
-
-    public void mset(final String... keysvalues) {
-        client.mset(keysvalues);
-    }
-
-    public void msetnx(final String... keysvalues) {
-        client.msetnx(keysvalues);
-    }
-
-    public void decrBy(final String key, final int integer) {
-        client.decrBy(key, integer);
-    }
-
-    public void decr(final String key) {
-        client.decr(key);
-    }
-
-    public void incrBy(final String key, final int integer) {
-        client.incrBy(key, integer);
-    }
-
-    public void incr(final String key) {
-        client.incr(key);
-    }
-
-    public void append(final String key, final String value) {
+    public Response<Long> append(String key, String value) {
         client.append(key, value);
+        return getResponse(BuilderFactory.LONG);
     }
 
-    public void substr(final String key, final int start, final int end) {
-        client.substr(key, start, end);
+    public Response<List<String>> blpop(String... args) {
+        client.blpop(args);
+        return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public void hset(final String key, final String field, final String value) {
-        client.hset(key, field, value);
+    public Response<List<String>> brpop(String... args) {
+        client.brpop(args);
+        return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public void hget(final String key, final String field) {
-        client.hget(key, field);
+    public Response<Long> decr(String key) {
+        client.decr(key);
+        return getResponse(BuilderFactory.LONG);
     }
 
-    public void hsetnx(final String key, final String field, final String value) {
-        client.hsetnx(key, field, value);
+    public Response<Long> decrBy(String key, long integer) {
+        client.decrBy(key, integer);
+        return getResponse(BuilderFactory.LONG);
     }
 
-    public void hmset(final String key, final Map<String, String> hash) {
-        client.hmset(key, hash);
+    public Response<Long> del(String... keys) {
+        client.del(keys);
+        return getResponse(BuilderFactory.LONG);
     }
 
-    public void hmget(final String key, final String... fields) {
-        client.hmget(key, fields);
+    public Response<String> echo(String string) {
+        client.echo(string);
+        return getResponse(BuilderFactory.STRING);
     }
 
-    public void hincrBy(final String key, final String field, final int value) {
-        client.hincrBy(key, field, value);
+    public Response<Boolean> exists(String key) {
+        client.exists(key);
+        return getResponse(BuilderFactory.BOOLEAN);
     }
 
-    public void hexists(final String key, final String field) {
-        client.hexists(key, field);
+    public Response<Long> expire(String key, int seconds) {
+        client.expire(key, seconds);
+        return getResponse(BuilderFactory.LONG);
     }
 
-    public void hdel(final String key, final String field) {
-        client.hdel(key, field);
+    public Response<Long> expireAt(String key, long unixTime) {
+        client.expireAt(key, unixTime);
+        return getResponse(BuilderFactory.LONG);
     }
 
-    public void hlen(final String key) {
-        client.hlen(key);
+    public Response<String> get(String key) {
+        client.get(key);
+        return getResponse(BuilderFactory.STRING);
     }
 
-    public void hkeys(final String key) {
-        client.hkeys(key);
-    }
-
-    public void hvals(final String key) {
-        client.hvals(key);
-    }
-
-    public void hgetAll(final String key) {
-        client.hgetAll(key);
-    }
-
-    public void rpush(final String key, final String string) {
-        client.rpush(key, string);
-    }
-
-    public void lpush(final String key, final String string) {
-        client.lpush(key, string);
-    }
-
-    public void llen(final String key) {
-        client.llen(key);
-    }
-
-    public void lrange(final String key, final int start, final int end) {
-        client.lrange(key, start, end);
-    }
-
-    public void ltrim(String key, final int start, final int end) {
-        client.ltrim(key, start, end);
-    }
-
-    public void lindex(final String key, final int index) {
-        client.lindex(key, index);
-    }
-
-    public void lset(final String key, final int index, final String value) {
-        client.lset(key, index, value);
-    }
-
-    public void lrem(final String key, final int count, final String value) {
-        client.lrem(key, count, value);
-    }
-
-    public void lpop(final String key) {
-        client.lpop(key);
-    }
-
-    public void rpop(final String key) {
-        client.rpop(key);
-    }
-
-    public void rpoplpush(final String srckey, final String dstkey) {
-        client.rpoplpush(srckey, dstkey);
-    }
-
-    public void sadd(final String key, final String member) {
-        client.sadd(key, member);
-    }
-
-    public void smembers(final String key) {
-        client.smembers(key);
-    }
-
-    public void srem(final String key, final String member) {
-        client.srem(key, member);
-    }
-
-    public void spop(final String key) {
-        client.spop(key);
-    }
-
-    public void smove(final String srckey, final String dstkey,
-            final String member) {
-        client.smove(srckey, dstkey, member);
-    }
-
-    public void scard(final String key) {
-        client.scard(key);
-    }
-
-    public void sismember(final String key, final String member) {
-        client.sismember(key, member);
-    }
-
-    public void sinter(final String... keys) {
-        client.sinter(keys);
-    }
-
-    public void sinterstore(final String dstkey, final String... keys) {
-        client.sinterstore(dstkey, keys);
-    }
-
-    public void sunion(final String... keys) {
-        client.sunion(keys);
-    }
-
-    public void sunionstore(final String dstkey, final String... keys) {
-        client.sunionstore(dstkey, keys);
-    }
-
-    public void sdiff(final String... keys) {
-        client.sdiff(keys);
-    }
-
-    public void sdiffstore(final String dstkey, final String... keys) {
-        client.sdiffstore(dstkey, keys);
-    }
-
-    public void srandmember(final String key) {
-        client.srandmember(key);
-    }
-
-    public void zadd(final String key, final double score, final String member) {
-        client.zadd(key, score, member);
-    }
-
-    public void zrange(final String key, final int start, final int end) {
-        client.zrange(key, start, end);
-    }
-
-    public void zrem(final String key, final String member) {
-        client.zrem(key, member);
-    }
-
-    public void zincrby(final String key, final double score,
-            final String member) {
-        client.zincrby(key, score, member);
-    }
-
-    public void zrank(final String key, final String member) {
-        client.zrank(key, member);
-    }
-
-    public void zrevrank(final String key, final String member) {
-        client.zrevrank(key, member);
-    }
-
-    public void zrevrange(final String key, final int start, final int end) {
-        client.zrevrange(key, start, end);
-    }
-
-    public void zrangeWithScores(final String key, final int start,
-            final int end) {
-        client.zrangeWithScores(key, start, end);
-    }
-
-    public void zrevrangeWithScores(final String key, final int start,
-            final int end) {
-        client.zrevrangeWithScores(key, start, end);
-    }
-
-    public void zcard(final String key) {
-        client.zcard(key);
-    }
-
-    public void zscore(final String key, final String member) {
-        client.zscore(key, member);
-    }
-
-    public void sort(final String key) {
-        client.sort(key);
-    }
-
-    public void sort(final String key, final SortingParams sortingParameters) {
-        client.sort(key, sortingParameters);
-    }
-
-    public void sort(final String key, final String dstkey) {
-        client.sort(key, dstkey);
-    }
-
-    public void sort(final String key, final SortingParams sortingParameters,
-            final String dstkey) {
-        client.sort(key, sortingParameters, dstkey);
-    }
-
-    public void setbit(String key, long offset, boolean value) {
-        client.setbit(key, offset, value);
-    }
-
-    public void getbit(String key, long offset) {
+    public Response<Boolean> getbit(String key, long offset) {
         client.getbit(key, offset);
+        return getResponse(BuilderFactory.BOOLEAN);
     }
 
-    public long setrange(String key, long offset, String value) {
-        client.setrange(key, offset, value);
-        return client.getIntegerReply();
-    }
-
-    public String getrange(String key, long startOffset, long endOffset) {
+    public Response<String> getrange(String key, long startOffset,
+            long endOffset) {
         client.getrange(key, startOffset, endOffset);
-        return client.getBulkReply();
+        return getResponse(BuilderFactory.STRING);
     }
 
-    public void linsert(final String key, final LIST_POSITION where,
-            final String pivot, final String value) {
+    public Response<String> getSet(String key, String value) {
+        client.getSet(key, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> hdel(String key, String field) {
+        client.hdel(key, field);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Boolean> hexists(String key, String field) {
+        client.hexists(key, field);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<String> hget(String key, String field) {
+        client.hget(key, field);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Map<String, String>> hgetAll(String key) {
+        client.hgetAll(key);
+        return getResponse(BuilderFactory.STRING_MAP);
+    }
+
+    public Response<Long> hincrBy(String key, String field, long value) {
+        client.hincrBy(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> hkeys(String key) {
+        client.hkeys(key);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Long> hlen(String key) {
+        client.hlen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> hmget(String key, String... fields) {
+        client.hmget(key, fields);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<String> hmset(String key, Map<String, String> hash) {
+        client.hmset(key, hash);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> hset(String key, String field, String value) {
+        client.hset(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> hsetnx(String key, String field, String value) {
+        client.hsetnx(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> hvals(String key) {
+        client.hvals(key);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<Long> incr(String key) {
+        client.incr(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> incrBy(String key, long integer) {
+        client.incrBy(key, integer);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> keys(String pattern) {
+        client.keys(pattern);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<String> lindex(String key, int index) {
+        client.lindex(key, index);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> linsert(String key, LIST_POSITION where,
+            String pivot, String value) {
         client.linsert(key, where, pivot, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> llen(String key) {
+        client.llen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> lpop(String key) {
+        client.lpop(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> lpush(String key, String string) {
+        client.lpush(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> lpushx(String key, String string) {
+        client.lpushx(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> lrange(String key, int start, int end) {
+        client.lrange(key, start, end);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<Long> lrem(String key, int count, String value) {
+        client.lrem(key, count, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> lset(String key, int index, String value) {
+        client.lset(key, index, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> ltrim(String key, int start, int end) {
+        client.ltrim(key, start, end);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<List<String>> mget(String... keys) {
+        client.mget(keys);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<Long> move(String key, int dbIndex) {
+        client.move(key, dbIndex);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> mset(String... keysvalues) {
+        client.mset(keysvalues);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> msetnx(String... keysvalues) {
+        client.msetnx(keysvalues);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> persist(String key) {
+        client.persist(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> rename(String oldkey, String newkey) {
+        client.rename(oldkey, newkey);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> renamenx(String oldkey, String newkey) {
+        client.renamenx(oldkey, newkey);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> rpop(String key) {
+        client.rpop(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> rpoplpush(String srckey, String dstkey) {
+        client.rpoplpush(srckey, dstkey);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> rpush(String key, String string) {
+        client.rpush(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> rpushx(String key, String string) {
+        client.rpushx(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sadd(String key, String member) {
+        client.sadd(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> scard(String key) {
+        client.scard(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> sdiff(String... keys) {
+        client.sdiff(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Long> sdiffstore(String dstkey, String... keys) {
+        client.sdiffstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> set(String key, String value) {
+        client.set(key, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Boolean> setbit(String key, long offset, boolean value) {
+        client.setbit(key, offset, value);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<String> setex(String key, int seconds, String value) {
+        client.setex(key, seconds, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> setnx(String key, String value) {
+        client.setnx(key, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> setrange(String key, long offset, String value) {
+        client.setrange(key, offset, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> sinter(String... keys) {
+        client.sinter(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Long> sinterstore(String dstkey, String... keys) {
+        client.sinterstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Boolean> sismember(String key, String member) {
+        client.sismember(key, member);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<Set<String>> smembers(String key) {
+        client.smembers(key);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Long> smove(String srckey, String dstkey, String member) {
+        client.smove(srckey, dstkey, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> sort(String key) {
+        client.sort(key);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<String>> sort(String key,
+            SortingParams sortingParameters) {
+        client.sort(key, sortingParameters);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<String>> sort(String key,
+            SortingParams sortingParameters, String dstkey) {
+        client.sort(key, sortingParameters, dstkey);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<String>> sort(String key, String dstkey) {
+        client.sort(key, dstkey);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<String> spop(String key) {
+        client.spop(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> srandmember(String key) {
+        client.srandmember(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> srem(String key, String member) {
+        client.srem(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> strlen(String key) {
+        client.strlen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> substr(String key, int start, int end) {
+        client.substr(key, start, end);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Set<String>> sunion(String... keys) {
+        client.sunion(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Long> sunionstore(String dstkey, String... keys) {
+        client.sunionstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> ttl(String key) {
+        client.ttl(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> type(String key) {
+        client.type(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> zadd(String key, double score, String member) {
+        client.zadd(key, score, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zcard(String key) {
+        client.zcard(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zcount(String key, double min, double max) {
+        client.zcount(key, min, max);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Double> zincrby(String key, double score, String member) {
+        client.zincrby(key, score, member);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<Long> zinterstore(String dstkey, String... sets) {
+        client.zinterstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zinterstore(String dstkey, ZParams params,
+            String... sets) {
+        client.zinterstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> zrange(String key, int start, int end) {
+        client.zrange(key, start, end);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(String key, double min,
+            double max) {
+        client.zrangeByScore(key, min, max);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(String key, String min,
+            String max) {
+        client.zrangeByScore(key, min, max);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(String key, double min,
+            double max, int offset, int count) {
+        client.zrangeByScore(key, min, max, offset, count);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
+            double max) {
+        client.zrangeByScoreWithScores(key, min, max);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
+            double max, int offset, int count) {
+        client.zrangeByScoreWithScores(key, min, max, offset, count);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
+        client.zrangeWithScores(key, start, end);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Long> zrank(String key, String member) {
+        client.zrank(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zrem(String key, String member) {
+        client.zrem(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zremrangeByRank(String key, int start, int end) {
+        client.zremrangeByRank(key, start, end);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zremrangeByScore(String key, double start, double end) {
+        client.zremrangeByScore(key, start, end);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> zrevrange(String key, int start, int end) {
+        client.zrevrange(key, start, end);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
+            int end) {
+        client.zrevrangeWithScores(key, start, end);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Long> zrevrank(String key, String member) {
+        client.zrevrank(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Double> zscore(String key, String member) {
+        client.zscore(key, member);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<Long> zunionstore(String dstkey, String... sets) {
+        client.zunionstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zunionstore(String dstkey, ZParams params,
+            String... sets) {
+        client.zunionstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> bgrewriteaof() {
+        client.bgrewriteaof();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> bgsave() {
+        client.bgsave();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> configGet(String pattern) {
+        client.configGet(pattern);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> configSet(String parameter, String value) {
+        client.configSet(parameter, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> brpoplpush(String source, String destination,
+            int timeout) {
+        client.brpoplpush(source, destination, timeout);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> configResetStat() {
+        client.configResetStat();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> save() {
+        client.save();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> lastsave() {
+        client.lastsave();
+        return getResponse(BuilderFactory.LONG);
     }
 }
\ No newline at end of file
diff --git a/src/test/java/redis/clients/jedis/tests/commands/TransactionCommandsTest.java b/src/test/java/redis/clients/jedis/tests/commands/TransactionCommandsTest.java
index 2897942..83798c2 100644
--- a/src/test/java/redis/clients/jedis/tests/commands/TransactionCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/tests/commands/TransactionCommandsTest.java
@@ -5,12 +5,13 @@ import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Set;
 
 import org.junit.Before;
 import org.junit.Test;
 
 import redis.clients.jedis.Jedis;
-import redis.clients.jedis.Protocol;
+import redis.clients.jedis.Response;
 import redis.clients.jedis.Transaction;
 import redis.clients.jedis.TransactionBlock;
 import redis.clients.jedis.Protocol.Keyword;
@@ -152,8 +153,7 @@ public class TransactionCommandsTest extends JedisCommandTestBase {
         t.set("mykey", val);
         List<Object> resp = t.exec();
         assertEquals(1, resp.size());
-        assertArrayEquals(Keyword.OK.name().getBytes(Protocol.CHARSET),
-                (byte[]) resp.get(0));
+        assertEquals("OK", resp.get(0));
 
         // Binary
         jedis.watch(bmykey);
@@ -171,8 +171,7 @@ public class TransactionCommandsTest extends JedisCommandTestBase {
         t.set(bmykey, bval);
         resp = t.exec();
         assertEquals(1, resp.size());
-        assertArrayEquals(Keyword.OK.name().getBytes(Protocol.CHARSET),
-                (byte[]) resp.get(0));
+        assertEquals("OK", resp.get(0));
     }
 
     @Test(expected = JedisDataException.class)
@@ -187,4 +186,37 @@ public class TransactionCommandsTest extends JedisCommandTestBase {
         String status = t.discard();
         assertEquals("OK", status);
     }
+
+    @Test
+    public void transactionResponse() {
+        jedis.set("string", "foo");
+        jedis.lpush("list", "foo");
+        jedis.hset("hash", "foo", "bar");
+        jedis.zadd("zset", 1, "foo");
+        jedis.sadd("set", "foo");
+
+        Transaction t = jedis.multi();
+        Response<String> string = t.get("string");
+        Response<String> list = t.lpop("list");
+        Response<String> hash = t.hget("hash", "foo");
+        Response<Set<String>> zset = t.zrange("zset", 0, -1);
+        Response<String> set = t.spop("set");
+        t.exec();
+
+        assertEquals("foo", string.get());
+        assertEquals("foo", list.get());
+        assertEquals("bar", hash.get());
+        assertEquals("foo", zset.get().iterator().next());
+        assertEquals("foo", set.get());
+    }
+
+    @Test(expected = JedisDataException.class)
+    public void transactionResponseWithinPipeline() {
+        jedis.set("string", "foo");
+
+        Transaction t = jedis.multi();
+        Response<String> string = t.get("string");
+        string.get();
+        t.exec();
+    }
 }
\ No newline at end of file