diff --git a/src/main/java/redis/clients/jedis/AbstractRedisClientBuilder.java b/src/main/java/redis/clients/jedis/AbstractRedisClientBuilder.java
new file mode 100644
index 0000000000..8c11f56673
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/AbstractRedisClientBuilder.java
@@ -0,0 +1,188 @@
+package redis.clients.jedis;
+
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
+import redis.clients.jedis.annots.Experimental;
+import redis.clients.jedis.csc.Cache;
+import redis.clients.jedis.json.JsonObjectMapper;
+import redis.clients.jedis.providers.ConnectionProvider;
+import redis.clients.jedis.search.SearchProtocol;
+
+/**
+ * Abstract base class for Redis client builders that provides common configuration options.
+ * <p>
+ * This class contains shared configuration fields and methods that are common across different
+ * Redis client builders (RedisClient.Builder, RedisSentinelClient.Builder, etc.). It helps
+ * eliminate code duplication and provides a consistent API for common features.
+ * <p>
+ * Common features provided:
+ * <ul>
+ * <li>Connection pool configuration</li>
+ * <li>Client-side caching</li>
+ * <li>Custom connection providers</li>
+ * <li>Key preprocessing</li>
+ * <li>JSON object mapping</li>
+ * <li>Search dialect configuration</li>
+ * </ul>
+ * @param <T> the concrete builder type for method chaining
+ * @param <C> the client type that this builder creates
+ */
+public abstract class AbstractRedisClientBuilder<T extends AbstractRedisClientBuilder<T, C>, C> {
+
+  // Common configuration fields
+  protected GenericObjectPoolConfig<Connection> poolConfig = new ConnectionPoolConfig();
+  protected Cache cache = null;
+  protected ConnectionProvider connectionProvider = null;
+  protected CommandKeyArgumentPreProcessor keyPreProcessor = null;
+  protected JsonObjectMapper jsonObjectMapper = null;
+  protected int searchDialect = SearchProtocol.DEFAULT_DIALECT;
+
+  /**
+   * Returns the concrete builder instance for method chaining. This method must be implemented by
+   * subclasses to return their own type.
+   * @return the concrete builder instance
+   */
+  protected abstract T self();
+
+  /**
+   * Builds the Redis client instance. This method must be implemented by subclasses to create their
+   * specific client type.
+   * @return the configured Redis client instance
+   */
+  public abstract C build();
+
+  /**
+   * Sets the connection pool configuration.
+   * <p>
+   * The pool configuration controls how connections are managed, including maximum number of
+   * connections, idle timeout, and other pooling parameters.
+   * @param poolConfig the pool configuration
+   * @return this builder
+   */
+  public T poolConfig(GenericObjectPoolConfig<Connection> poolConfig) {
+    this.poolConfig = poolConfig;
+    return self();
+  }
+
+  /**
+   * Sets the client-side cache for caching Redis responses.
+   * <p>
+   * Client-side caching can improve performance by storing frequently accessed data locally,
+   * reducing the number of round trips to the Redis server.
+   * @param cache the cache instance
+   * @return this builder
+   */
+  @Experimental
+  public T cache(Cache cache) {
+    this.cache = cache;
+    return self();
+  }
+
+  /**
+   * Sets a custom connection provider.
+   * <p>
+   * When a custom connection provider is set, other connection-related configuration may be ignored
+   * as the provider is responsible for managing connections. The specific behavior depends on the
+   * concrete builder implementation.
+   * @param connectionProvider the connection provider
+   * @return this builder
+   */
+  public T connectionProvider(ConnectionProvider connectionProvider) {
+    this.connectionProvider = connectionProvider;
+    return self();
+  }
+
+  /**
+   * Sets a key preprocessor for transforming Redis keys before sending commands.
+   * <p>
+   * The key preprocessor allows you to modify keys before they are sent to Redis, for example to
+   * add prefixes, apply transformations, or implement key routing logic.
+   * <p>
+   * Example usage:
+   *
+   * <pre>{@code
+   * CommandKeyArgumentPreProcessor keyProcessor = key -> "myapp:" + key;
+   * builder.keyPreProcessor(keyProcessor);
+   * }</pre>
+   *
+   * @param keyPreProcessor the key preprocessor
+   * @return this builder
+   */
+  public T keyPreProcessor(CommandKeyArgumentPreProcessor keyPreProcessor) {
+    this.keyPreProcessor = keyPreProcessor;
+    return self();
+  }
+
+  /**
+   * Sets a custom JSON object mapper for JSON operations.
+   * <p>
+   * The JSON object mapper is used for serializing and deserializing objects in JSON commands
+   * (RedisJSON module). If not set, a default Gson-based mapper will be used.
+   * <p>
+   * Example usage:
+   *
+   * <pre>{@code
+   * JsonObjectMapper customMapper = new MyCustomJsonMapper();
+   * builder.jsonObjectMapper(customMapper);
+   * }</pre>
+   *
+   * @param jsonObjectMapper the JSON object mapper
+   * @return this builder
+   */
+  public T jsonObjectMapper(JsonObjectMapper jsonObjectMapper) {
+    this.jsonObjectMapper = jsonObjectMapper;
+    return self();
+  }
+
+  /**
+   * Sets the default search dialect for RediSearch operations.
+   * <p>
+   * The search dialect determines the query syntax and features available for RediSearch commands.
+   * Different dialects support different query features and syntax variations.
+   * <p>
+   * Default is {@value redis.clients.jedis.search.SearchProtocol#DEFAULT_DIALECT}.
+   * @param searchDialect the search dialect version
+   * @return this builder
+   * @throws IllegalArgumentException if dialect is 0 (not allowed)
+   */
+  public T searchDialect(int searchDialect) {
+    if (searchDialect == 0) {
+      throw new IllegalArgumentException("DIALECT=0 cannot be set.");
+    }
+    this.searchDialect = searchDialect;
+    return self();
+  }
+
+  /**
+   * Applies common configuration to the CommandObjects instance.
+   * <p>
+   * This method is called by concrete builders to configure the CommandObjects with the common
+   * settings like key preprocessor, JSON mapper, and search dialect.
+   * @param commandObjects the CommandObjects instance to configure
+   */
+  protected void applyCommonConfiguration(CommandObjects commandObjects) {
+    if (keyPreProcessor != null) {
+      commandObjects.setKeyArgumentPreProcessor(keyPreProcessor);
+    }
+
+    if (jsonObjectMapper != null) {
+      commandObjects.setJsonObjectMapper(jsonObjectMapper);
+    }
+
+    if (searchDialect != SearchProtocol.DEFAULT_DIALECT) {
+      commandObjects.setDefaultSearchDialect(searchDialect);
+    }
+  }
+
+  /**
+   * Validates common configuration parameters.
+   * <p>
+   * This method can be called by concrete builders to validate the common configuration before
+   * building the client.
+   * @throws IllegalArgumentException if any common configuration is invalid
+   */
+  protected void validateCommonConfiguration() {
+    if (poolConfig == null) {
+      throw new IllegalArgumentException("Pool configuration cannot be null");
+    }
+  }
+}
diff --git a/src/main/java/redis/clients/jedis/BaseRedisClient.java b/src/main/java/redis/clients/jedis/BaseRedisClient.java
new file mode 100644
index 0000000000..293a25ecb5
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/BaseRedisClient.java
@@ -0,0 +1,4655 @@
+package redis.clients.jedis;
+
+import org.json.JSONArray;
+import redis.clients.jedis.args.*;
+import redis.clients.jedis.bloom.*;
+import redis.clients.jedis.bloom.commands.RedisBloomCommands;
+import redis.clients.jedis.commands.*;
+import redis.clients.jedis.csc.Cache;
+import redis.clients.jedis.json.JsonSetParams;
+import redis.clients.jedis.json.Path2;
+import redis.clients.jedis.json.commands.RedisJsonV2Commands;
+import redis.clients.jedis.params.*;
+import redis.clients.jedis.providers.ConnectionProvider;
+import redis.clients.jedis.resps.*;
+import redis.clients.jedis.search.*;
+import redis.clients.jedis.search.aggr.AggregationBuilder;
+import redis.clients.jedis.search.aggr.AggregationResult;
+import redis.clients.jedis.search.aggr.FtAggregateIteration;
+import redis.clients.jedis.search.schemafields.SchemaField;
+import redis.clients.jedis.timeseries.*;
+import redis.clients.jedis.util.KeyValue;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Abstract base class that implements all Redis command interfaces.
+ */
+public abstract class BaseRedisClient implements JedisCommands, JedisBinaryCommands,
+    SampleKeyedCommands, SampleBinaryKeyedCommands, RediSearchCommands, RedisJsonV2Commands,
+    RedisTimeSeriesCommands, RedisBloomCommands, AutoCloseable {
+
+  /**
+   * Get the command objects factory for this client.
+   * @return CommandObjects instance
+   */
+  protected abstract CommandObjects getCommandObjects();
+
+  /**
+   * Get the connection provider for this client.
+   * @return ConnectionProvider instance
+   */
+  protected abstract ConnectionProvider getConnectionProvider();
+
+  /**
+   * Get the cache for this client.
+   * @return Cache instance
+   */
+  public abstract Cache getCache();
+
+  /**
+   * Execute a Redis command.
+   * @param <T> The return type of the command
+   * @param commandObject The command to execute
+   * @return The command result
+   */
+  public abstract <T> T executeCommand(CommandObject<T> commandObject);
+
+  /**
+   * Broadcast a Redis command to all nodes in a cluster.
+   * @param <T> The return type of the command
+   * @param commandObject The command to broadcast
+   * @return The command result
+   */
+  public abstract <T> T broadcastCommand(CommandObject<T> commandObject);
+
+  /**
+   * Check if a command should be broadcast and execute accordingly.
+   * @param <T> The return type of the command
+   * @param commandObject The command to execute
+   * @return The command result
+   */
+  protected abstract <T> T checkAndBroadcastCommand(CommandObject<T> commandObject);
+
+  /**
+   * Create a new pipeline for batching commands.
+   * @return a new AbstractPipeline instance
+   */
+  public abstract AbstractPipeline pipelined();
+
+  /**
+   * Create a new transaction.
+   * @return a new AbstractTransaction instance
+   */
+  public AbstractTransaction multi() {
+    return transaction(true);
+  }
+
+  /**
+   * Create a new transaction with optional MULTI command.
+   * @param doMulti whether to execute MULTI command
+   * @return a new AbstractTransaction instance
+   */
+  public abstract AbstractTransaction transaction(boolean doMulti);
+
+  // Generic sendCommand methods for raw protocol commands
+  public Object sendCommand(ProtocolCommand cmd) {
+    return executeCommand(
+      new CommandObject<>(getCommandObjects().commandArguments(cmd), BuilderFactory.RAW_OBJECT));
+  }
+
+  public Object sendCommand(ProtocolCommand cmd, byte[]... args) {
+    return executeCommand(
+      new CommandObject<>(getCommandObjects().commandArguments(cmd).addObjects((Object[]) args),
+          BuilderFactory.RAW_OBJECT));
+  }
+
+  public Object sendBlockingCommand(ProtocolCommand cmd, byte[]... args) {
+    return executeCommand(new CommandObject<>(
+        getCommandObjects().commandArguments(cmd).addObjects((Object[]) args).blocking(),
+        BuilderFactory.RAW_OBJECT));
+  }
+
+  public Object sendCommand(ProtocolCommand cmd, String... args) {
+    return executeCommand(
+      new CommandObject<>(getCommandObjects().commandArguments(cmd).addObjects((Object[]) args),
+          BuilderFactory.RAW_OBJECT));
+  }
+
+  public Object sendBlockingCommand(ProtocolCommand cmd, String... args) {
+    return executeCommand(new CommandObject<>(
+        getCommandObjects().commandArguments(cmd).addObjects((Object[]) args).blocking(),
+        BuilderFactory.RAW_OBJECT));
+  }
+
+  public Object sendCommand(byte[] sampleKey, ProtocolCommand cmd, byte[]... args) {
+    return executeCommand(new CommandObject<>(
+        getCommandObjects().commandArguments(cmd).addObjects((Object[]) args).processKey(sampleKey),
+        BuilderFactory.RAW_OBJECT));
+  }
+
+  public Object sendBlockingCommand(byte[] sampleKey, ProtocolCommand cmd, byte[]... args) {
+    return executeCommand(new CommandObject<>(getCommandObjects().commandArguments(cmd)
+        .addObjects((Object[]) args).blocking().processKey(sampleKey), BuilderFactory.RAW_OBJECT));
+  }
+
+  public Object sendCommand(String sampleKey, ProtocolCommand cmd, String... args) {
+    return executeCommand(new CommandObject<>(
+        getCommandObjects().commandArguments(cmd).addObjects((Object[]) args).processKey(sampleKey),
+        BuilderFactory.RAW_OBJECT));
+  }
+
+  public Object sendBlockingCommand(String sampleKey, ProtocolCommand cmd, String... args) {
+    return executeCommand(new CommandObject<>(getCommandObjects().commandArguments(cmd)
+        .addObjects((Object[]) args).blocking().processKey(sampleKey), BuilderFactory.RAW_OBJECT));
+  }
+
+  // Random node commands
+  public void subscribe(final JedisPubSub jedisPubSub, final String... channels) {
+    try (Connection connection = getConnectionProvider().getConnection()) {
+      jedisPubSub.proceed(connection, channels);
+    }
+  }
+
+  public void psubscribe(final JedisPubSub jedisPubSub, final String... patterns) {
+    try (Connection connection = getConnectionProvider().getConnection()) {
+      jedisPubSub.proceedWithPatterns(connection, patterns);
+    }
+  }
+
+  public void subscribe(BinaryJedisPubSub jedisPubSub, final byte[]... channels) {
+    try (Connection connection = getConnectionProvider().getConnection()) {
+      jedisPubSub.proceed(connection, channels);
+    }
+  }
+
+  public void psubscribe(BinaryJedisPubSub jedisPubSub, final byte[]... patterns) {
+    try (Connection connection = getConnectionProvider().getConnection()) {
+      jedisPubSub.proceedWithPatterns(connection, patterns);
+    }
+  }
+  // Random node commands
+
+  // Redis command methods
+  public String ping() {
+    return checkAndBroadcastCommand(getCommandObjects().ping());
+  }
+
+  public String flushDB() {
+    return checkAndBroadcastCommand(getCommandObjects().flushDB());
+  }
+
+  public String flushAll() {
+    return checkAndBroadcastCommand(getCommandObjects().flushAll());
+  }
+
+  public String configSet(String parameter, String value) {
+    return checkAndBroadcastCommand(getCommandObjects().configSet(parameter, value));
+  }
+
+  public String info() {
+    return executeCommand(getCommandObjects().info());
+  }
+
+  public String info(String section) {
+    return executeCommand(getCommandObjects().info(section));
+  }
+
+  // Key commands
+  @Override
+  public boolean exists(String key) {
+    return executeCommand(getCommandObjects().exists(key));
+  }
+
+  @Override
+  public long exists(String... keys) {
+    return executeCommand(getCommandObjects().exists(keys));
+  }
+
+  @Override
+  public long persist(String key) {
+    return executeCommand(getCommandObjects().persist(key));
+  }
+
+  @Override
+  public String type(String key) {
+    return executeCommand(getCommandObjects().type(key));
+  }
+
+  @Override
+  public boolean exists(byte[] key) {
+    return executeCommand(getCommandObjects().exists(key));
+  }
+
+  @Override
+  public long exists(byte[]... keys) {
+    return executeCommand(getCommandObjects().exists(keys));
+  }
+
+  @Override
+  public long persist(byte[] key) {
+    return executeCommand(getCommandObjects().persist(key));
+  }
+
+  @Override
+  public String type(byte[] key) {
+    return executeCommand(getCommandObjects().type(key));
+  }
+
+  @Override
+  public byte[] dump(String key) {
+    return executeCommand(getCommandObjects().dump(key));
+  }
+
+  @Override
+  public String restore(String key, long ttl, byte[] serializedValue) {
+    return executeCommand(getCommandObjects().restore(key, ttl, serializedValue));
+  }
+
+  @Override
+  public String restore(String key, long ttl, byte[] serializedValue, RestoreParams params) {
+    return executeCommand(getCommandObjects().restore(key, ttl, serializedValue, params));
+  }
+
+  @Override
+  public byte[] dump(byte[] key) {
+    return executeCommand(getCommandObjects().dump(key));
+  }
+
+  @Override
+  public String restore(byte[] key, long ttl, byte[] serializedValue) {
+    return executeCommand(getCommandObjects().restore(key, ttl, serializedValue));
+  }
+
+  @Override
+  public String restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params) {
+    return executeCommand(getCommandObjects().restore(key, ttl, serializedValue, params));
+  }
+
+  @Override
+  public long expire(String key, long seconds) {
+    return executeCommand(getCommandObjects().expire(key, seconds));
+  }
+
+  @Override
+  public long expire(String key, long seconds, ExpiryOption expiryOption) {
+    return executeCommand(getCommandObjects().expire(key, seconds, expiryOption));
+  }
+
+  @Override
+  public long pexpire(String key, long milliseconds) {
+    return executeCommand(getCommandObjects().pexpire(key, milliseconds));
+  }
+
+  @Override
+  public long pexpire(String key, long milliseconds, ExpiryOption expiryOption) {
+    return executeCommand(getCommandObjects().pexpire(key, milliseconds, expiryOption));
+  }
+
+  @Override
+  public long expireTime(String key) {
+    return executeCommand(getCommandObjects().expireTime(key));
+  }
+
+  @Override
+  public long pexpireTime(String key) {
+    return executeCommand(getCommandObjects().pexpireTime(key));
+  }
+
+  @Override
+  public long expireAt(String key, long unixTime) {
+    return executeCommand(getCommandObjects().expireAt(key, unixTime));
+  }
+
+  @Override
+  public long expireAt(String key, long unixTime, ExpiryOption expiryOption) {
+    return executeCommand(getCommandObjects().expireAt(key, unixTime, expiryOption));
+  }
+
+  @Override
+  public long pexpireAt(String key, long millisecondsTimestamp) {
+    return executeCommand(getCommandObjects().pexpireAt(key, millisecondsTimestamp));
+  }
+
+  @Override
+  public long pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption) {
+    return executeCommand(getCommandObjects().pexpireAt(key, millisecondsTimestamp, expiryOption));
+  }
+
+  @Override
+  public long expire(byte[] key, long seconds) {
+    return executeCommand(getCommandObjects().expire(key, seconds));
+  }
+
+  @Override
+  public long expire(byte[] key, long seconds, ExpiryOption expiryOption) {
+    return executeCommand(getCommandObjects().expire(key, seconds, expiryOption));
+  }
+
+  @Override
+  public long pexpire(byte[] key, long milliseconds) {
+    return executeCommand(getCommandObjects().pexpire(key, milliseconds));
+  }
+
+  @Override
+  public long pexpire(byte[] key, long milliseconds, ExpiryOption expiryOption) {
+    return executeCommand(getCommandObjects().pexpire(key, milliseconds, expiryOption));
+  }
+
+  @Override
+  public long expireTime(byte[] key) {
+    return executeCommand(getCommandObjects().expireTime(key));
+  }
+
+  @Override
+  public long pexpireTime(byte[] key) {
+    return executeCommand(getCommandObjects().pexpireTime(key));
+  }
+
+  @Override
+  public long expireAt(byte[] key, long unixTime) {
+    return executeCommand(getCommandObjects().expireAt(key, unixTime));
+  }
+
+  @Override
+  public long expireAt(byte[] key, long unixTime, ExpiryOption expiryOption) {
+    return executeCommand(getCommandObjects().expireAt(key, unixTime, expiryOption));
+  }
+
+  @Override
+  public long pexpireAt(byte[] key, long millisecondsTimestamp) {
+    return executeCommand(getCommandObjects().pexpireAt(key, millisecondsTimestamp));
+  }
+
+  @Override
+  public long pexpireAt(byte[] key, long millisecondsTimestamp, ExpiryOption expiryOption) {
+    return executeCommand(getCommandObjects().pexpireAt(key, millisecondsTimestamp, expiryOption));
+  }
+
+  @Override
+  public long ttl(String key) {
+    return executeCommand(getCommandObjects().ttl(key));
+  }
+
+  @Override
+  public long pttl(String key) {
+    return executeCommand(getCommandObjects().pttl(key));
+  }
+
+  @Override
+  public long touch(String key) {
+    return executeCommand(getCommandObjects().touch(key));
+  }
+
+  @Override
+  public long touch(String... keys) {
+    return executeCommand(getCommandObjects().touch(keys));
+  }
+
+  @Override
+  public long ttl(byte[] key) {
+    return executeCommand(getCommandObjects().ttl(key));
+  }
+
+  @Override
+  public long pttl(byte[] key) {
+    return executeCommand(getCommandObjects().pttl(key));
+  }
+
+  @Override
+  public long touch(byte[] key) {
+    return executeCommand(getCommandObjects().touch(key));
+  }
+
+  @Override
+  public long touch(byte[]... keys) {
+    return executeCommand(getCommandObjects().touch(keys));
+  }
+
+  @Override
+  public List<String> sort(String key) {
+    return executeCommand(getCommandObjects().sort(key));
+  }
+
+  @Override
+  public List<String> sort(String key, SortingParams sortingParams) {
+    return executeCommand(getCommandObjects().sort(key, sortingParams));
+  }
+
+  @Override
+  public long sort(String key, String dstkey) {
+    return executeCommand(getCommandObjects().sort(key, dstkey));
+  }
+
+  @Override
+  public long sort(String key, SortingParams sortingParams, String dstkey) {
+    return executeCommand(getCommandObjects().sort(key, sortingParams, dstkey));
+  }
+
+  @Override
+  public List<String> sortReadonly(String key, SortingParams sortingParams) {
+    return executeCommand(getCommandObjects().sortReadonly(key, sortingParams));
+  }
+
+  @Override
+  public List<byte[]> sort(byte[] key) {
+    return executeCommand(getCommandObjects().sort(key));
+  }
+
+  @Override
+  public List<byte[]> sort(byte[] key, SortingParams sortingParams) {
+    return executeCommand(getCommandObjects().sort(key, sortingParams));
+  }
+
+  @Override
+  public long sort(byte[] key, byte[] dstkey) {
+    return executeCommand(getCommandObjects().sort(key, dstkey));
+  }
+
+  @Override
+  public List<byte[]> sortReadonly(byte[] key, SortingParams sortingParams) {
+    return executeCommand(getCommandObjects().sortReadonly(key, sortingParams));
+  }
+
+  @Override
+  public long sort(byte[] key, SortingParams sortingParams, byte[] dstkey) {
+    return executeCommand(getCommandObjects().sort(key, sortingParams, dstkey));
+  }
+
+  @Override
+  public long del(String key) {
+    return executeCommand(getCommandObjects().del(key));
+  }
+
+  @Override
+  public long del(String... keys) {
+    return executeCommand(getCommandObjects().del(keys));
+  }
+
+  @Override
+  public long unlink(String key) {
+    return executeCommand(getCommandObjects().unlink(key));
+  }
+
+  @Override
+  public long unlink(String... keys) {
+    return executeCommand(getCommandObjects().unlink(keys));
+  }
+
+  @Override
+  public long del(byte[] key) {
+    return executeCommand(getCommandObjects().del(key));
+  }
+
+  @Override
+  public long del(byte[]... keys) {
+    return executeCommand(getCommandObjects().del(keys));
+  }
+
+  @Override
+  public long unlink(byte[] key) {
+    return executeCommand(getCommandObjects().unlink(key));
+  }
+
+  @Override
+  public long unlink(byte[]... keys) {
+    return executeCommand(getCommandObjects().unlink(keys));
+  }
+
+  @Override
+  public Long memoryUsage(String key) {
+    return executeCommand(getCommandObjects().memoryUsage(key));
+  }
+
+  @Override
+  public Long memoryUsage(String key, int samples) {
+    return executeCommand(getCommandObjects().memoryUsage(key, samples));
+  }
+
+  @Override
+  public Long memoryUsage(byte[] key) {
+    return executeCommand(getCommandObjects().memoryUsage(key));
+  }
+
+  @Override
+  public Long memoryUsage(byte[] key, int samples) {
+    return executeCommand(getCommandObjects().memoryUsage(key, samples));
+  }
+
+  @Override
+  public boolean copy(String srcKey, String dstKey, boolean replace) {
+    return executeCommand(getCommandObjects().copy(srcKey, dstKey, replace));
+  }
+
+  @Override
+  public String rename(String oldkey, String newkey) {
+    return executeCommand(getCommandObjects().rename(oldkey, newkey));
+  }
+
+  @Override
+  public long renamenx(String oldkey, String newkey) {
+    return executeCommand(getCommandObjects().renamenx(oldkey, newkey));
+  }
+
+  @Override
+  public boolean copy(byte[] srcKey, byte[] dstKey, boolean replace) {
+    return executeCommand(getCommandObjects().copy(srcKey, dstKey, replace));
+  }
+
+  @Override
+  public String rename(byte[] oldkey, byte[] newkey) {
+    return executeCommand(getCommandObjects().rename(oldkey, newkey));
+  }
+
+  @Override
+  public long renamenx(byte[] oldkey, byte[] newkey) {
+    return executeCommand(getCommandObjects().renamenx(oldkey, newkey));
+  }
+
+  public long dbSize() {
+    return executeCommand(getCommandObjects().dbSize());
+  }
+
+  @Override
+  public Set<String> keys(String pattern) {
+    return executeCommand(getCommandObjects().keys(pattern));
+  }
+
+  @Override
+  public ScanResult<String> scan(String cursor) {
+    return executeCommand(getCommandObjects().scan(cursor));
+  }
+
+  @Override
+  public ScanResult<String> scan(String cursor, ScanParams params) {
+    return executeCommand(getCommandObjects().scan(cursor, params));
+  }
+
+  @Override
+  public ScanResult<String> scan(String cursor, ScanParams params, String type) {
+    return executeCommand(getCommandObjects().scan(cursor, params, type));
+  }
+
+  /**
+   * @param batchCount COUNT for each batch execution
+   * @param match pattern
+   * @return scan iteration
+   */
+  public ScanIteration scanIteration(int batchCount, String match) {
+    return new ScanIteration(getConnectionProvider(), batchCount, match);
+  }
+
+  /**
+   * @param batchCount COUNT for each batch execution
+   * @param match pattern
+   * @param type key type
+   * @return scan iteration
+   */
+  public ScanIteration scanIteration(int batchCount, String match, String type) {
+    return new ScanIteration(getConnectionProvider(), batchCount, match, type);
+  }
+
+  @Override
+  public Set<byte[]> keys(byte[] pattern) {
+    return executeCommand(getCommandObjects().keys(pattern));
+  }
+
+  @Override
+  public ScanResult<byte[]> scan(byte[] cursor) {
+    return executeCommand(getCommandObjects().scan(cursor));
+  }
+
+  @Override
+  public ScanResult<byte[]> scan(byte[] cursor, ScanParams params) {
+    return executeCommand(getCommandObjects().scan(cursor, params));
+  }
+
+  @Override
+  public ScanResult<byte[]> scan(byte[] cursor, ScanParams params, byte[] type) {
+    return executeCommand(getCommandObjects().scan(cursor, params, type));
+  }
+
+  @Override
+  public String randomKey() {
+    return executeCommand(getCommandObjects().randomKey());
+  }
+
+  @Override
+  public byte[] randomBinaryKey() {
+    return executeCommand(getCommandObjects().randomBinaryKey());
+  }
+
+  @Override
+  public String psetex(String key, long milliseconds, String value) {
+    return executeCommand(getCommandObjects().psetex(key, milliseconds, value));
+  }
+
+  @Override
+  public String psetex(byte[] key, long milliseconds, byte[] value) {
+    return executeCommand(getCommandObjects().psetex(key, milliseconds, value));
+  }
+
+  @Override
+  public long incr(String key) {
+    return executeCommand(getCommandObjects().incr(key));
+  }
+
+  @Override
+  public long incrBy(String key, long increment) {
+    return executeCommand(getCommandObjects().incrBy(key, increment));
+  }
+
+  @Override
+  public double incrByFloat(String key, double increment) {
+    return executeCommand(getCommandObjects().incrByFloat(key, increment));
+  }
+
+  @Override
+  public long decr(String key) {
+    return executeCommand(getCommandObjects().decr(key));
+  }
+
+  @Override
+  public long decrBy(String key, long decrement) {
+    return executeCommand(getCommandObjects().decrBy(key, decrement));
+  }
+
+  @Override
+  public long incr(byte[] key) {
+    return executeCommand(getCommandObjects().incr(key));
+  }
+
+  @Override
+  public long incrBy(byte[] key, long increment) {
+    return executeCommand(getCommandObjects().incrBy(key, increment));
+  }
+
+  @Override
+  public double incrByFloat(byte[] key, double increment) {
+    return executeCommand(getCommandObjects().incrByFloat(key, increment));
+  }
+
+  @Override
+  public long decr(byte[] key) {
+    return executeCommand(getCommandObjects().decr(key));
+  }
+
+  @Override
+  public long decrBy(byte[] key, long decrement) {
+    return executeCommand(getCommandObjects().decrBy(key, decrement));
+  }
+
+  @Override
+  public String set(String key, String value) {
+    return executeCommand(getCommandObjects().set(key, value));
+  }
+
+  @Override
+  public String set(String key, String value, SetParams params) {
+    return executeCommand(getCommandObjects().set(key, value, params));
+  }
+
+  @Override
+  public String get(String key) {
+    return executeCommand(getCommandObjects().get(key));
+  }
+
+  @Override
+  public String setGet(String key, String value) {
+    return executeCommand(getCommandObjects().setGet(key, value));
+  }
+
+  @Override
+  public String setGet(String key, String value, SetParams params) {
+    return executeCommand(getCommandObjects().setGet(key, value, params));
+  }
+
+  @Override
+  public String getDel(String key) {
+    return executeCommand(getCommandObjects().getDel(key));
+  }
+
+  @Override
+  public String getEx(String key, GetExParams params) {
+    return executeCommand(getCommandObjects().getEx(key, params));
+  }
+
+  @Override
+  public String set(byte[] key, byte[] value) {
+    return executeCommand(getCommandObjects().set(key, value));
+  }
+
+  @Override
+  public String set(byte[] key, byte[] value, SetParams params) {
+    return executeCommand(getCommandObjects().set(key, value, params));
+  }
+
+  @Override
+  public byte[] get(byte[] key) {
+    return executeCommand(getCommandObjects().get(key));
+  }
+
+  @Override
+  public byte[] setGet(byte[] key, byte[] value) {
+    return executeCommand(getCommandObjects().setGet(key, value));
+  }
+
+  @Override
+  public byte[] setGet(byte[] key, byte[] value, SetParams params) {
+    return executeCommand(getCommandObjects().setGet(key, value, params));
+  }
+
+  @Override
+  public byte[] getDel(byte[] key) {
+    return executeCommand(getCommandObjects().getDel(key));
+  }
+
+  @Override
+  public byte[] getEx(byte[] key, GetExParams params) {
+    return executeCommand(getCommandObjects().getEx(key, params));
+  }
+
+  @Override
+  public boolean setbit(String key, long offset, boolean value) {
+    return executeCommand(getCommandObjects().setbit(key, offset, value));
+  }
+
+  @Override
+  public boolean getbit(String key, long offset) {
+    return executeCommand(getCommandObjects().getbit(key, offset));
+  }
+
+  @Override
+  public long setrange(String key, long offset, String value) {
+    return executeCommand(getCommandObjects().setrange(key, offset, value));
+  }
+
+  @Override
+  public String getrange(String key, long startOffset, long endOffset) {
+    return executeCommand(getCommandObjects().getrange(key, startOffset, endOffset));
+  }
+
+  @Override
+  public boolean setbit(byte[] key, long offset, boolean value) {
+    return executeCommand(getCommandObjects().setbit(key, offset, value));
+  }
+
+  @Override
+  public boolean getbit(byte[] key, long offset) {
+    return executeCommand(getCommandObjects().getbit(key, offset));
+  }
+
+  @Override
+  public long setnx(String key, String value) {
+    return executeCommand(getCommandObjects().setnx(key, value));
+  }
+
+  @Override
+  public String setex(String key, long seconds, String value) {
+    return executeCommand(getCommandObjects().setex(key, seconds, value));
+  }
+
+  @Override
+  public long setnx(byte[] key, byte[] value) {
+    return executeCommand(getCommandObjects().setnx(key, value));
+  }
+
+  @Override
+  public String setex(byte[] key, long seconds, byte[] value) {
+    return executeCommand(getCommandObjects().setex(key, seconds, value));
+  }
+
+  @Override
+  public long setrange(byte[] key, long offset, byte[] value) {
+    return executeCommand(getCommandObjects().setrange(key, offset, value));
+  }
+
+  @Override
+  public byte[] getrange(byte[] key, long startOffset, long endOffset) {
+    return executeCommand(getCommandObjects().getrange(key, startOffset, endOffset));
+  }
+
+  @Override
+  public List<String> mget(String... keys) {
+    return executeCommand(getCommandObjects().mget(keys));
+  }
+
+  @Override
+  public String mset(String... keysvalues) {
+    return executeCommand(getCommandObjects().mset(keysvalues));
+  }
+
+  @Override
+  public long msetnx(String... keysvalues) {
+    return executeCommand(getCommandObjects().msetnx(keysvalues));
+  }
+
+  @Override
+  public List<byte[]> mget(byte[]... keys) {
+    return executeCommand(getCommandObjects().mget(keys));
+  }
+
+  @Override
+  public String mset(byte[]... keysvalues) {
+    return executeCommand(getCommandObjects().mset(keysvalues));
+  }
+
+  @Override
+  public long msetnx(byte[]... keysvalues) {
+    return executeCommand(getCommandObjects().msetnx(keysvalues));
+  }
+
+  @Override
+  public long append(String key, String value) {
+    return executeCommand(getCommandObjects().append(key, value));
+  }
+
+  @Override
+  public String substr(String key, int start, int end) {
+    return executeCommand(getCommandObjects().substr(key, start, end));
+  }
+
+  @Override
+  public long strlen(String key) {
+    return executeCommand(getCommandObjects().strlen(key));
+  }
+
+  @Override
+  public long append(byte[] key, byte[] value) {
+    return executeCommand(getCommandObjects().append(key, value));
+  }
+
+  @Override
+  public byte[] substr(byte[] key, int start, int end) {
+    return executeCommand(getCommandObjects().substr(key, start, end));
+  }
+
+  @Override
+  public long strlen(byte[] key) {
+    return executeCommand(getCommandObjects().strlen(key));
+  }
+
+  @Override
+  public long bitcount(String key) {
+    return executeCommand(getCommandObjects().bitcount(key));
+  }
+
+  @Override
+  public long bitcount(String key, long start, long end) {
+    return executeCommand(getCommandObjects().bitcount(key, start, end));
+  }
+
+  @Override
+  public long bitcount(String key, long start, long end, BitCountOption option) {
+    return executeCommand(getCommandObjects().bitcount(key, start, end, option));
+  }
+
+  @Override
+  public long bitpos(String key, boolean value) {
+    return executeCommand(getCommandObjects().bitpos(key, value));
+  }
+
+  @Override
+  public long bitpos(String key, boolean value, BitPosParams params) {
+    return executeCommand(getCommandObjects().bitpos(key, value, params));
+  }
+
+  @Override
+  public long bitcount(byte[] key) {
+    return executeCommand(getCommandObjects().bitcount(key));
+  }
+
+  @Override
+  public long bitcount(byte[] key, long start, long end) {
+    return executeCommand(getCommandObjects().bitcount(key, start, end));
+  }
+
+  @Override
+  public long bitcount(byte[] key, long start, long end, BitCountOption option) {
+    return executeCommand(getCommandObjects().bitcount(key, start, end, option));
+  }
+
+  @Override
+  public long bitpos(byte[] key, boolean value) {
+    return executeCommand(getCommandObjects().bitpos(key, value));
+  }
+
+  @Override
+  public long bitpos(byte[] key, boolean value, BitPosParams params) {
+    return executeCommand(getCommandObjects().bitpos(key, value, params));
+  }
+
+  @Override
+  public List<Long> bitfield(String key, String... arguments) {
+    return executeCommand(getCommandObjects().bitfield(key, arguments));
+  }
+
+  @Override
+  public List<Long> bitfieldReadonly(String key, String... arguments) {
+    return executeCommand(getCommandObjects().bitfieldReadonly(key, arguments));
+  }
+
+  @Override
+  public List<Long> bitfield(byte[] key, byte[]... arguments) {
+    return executeCommand(getCommandObjects().bitfield(key, arguments));
+  }
+
+  @Override
+  public List<Long> bitfieldReadonly(byte[] key, byte[]... arguments) {
+    return executeCommand(getCommandObjects().bitfieldReadonly(key, arguments));
+  }
+
+  @Override
+  public long bitop(BitOP op, String destKey, String... srcKeys) {
+    return executeCommand(getCommandObjects().bitop(op, destKey, srcKeys));
+  }
+
+  @Override
+  public long bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
+    return executeCommand(getCommandObjects().bitop(op, destKey, srcKeys));
+  }
+
+  @Override
+  public LCSMatchResult lcs(String keyA, String keyB, LCSParams params) {
+    return executeCommand(getCommandObjects().lcs(keyA, keyB, params));
+  }
+
+  @Override
+  public LCSMatchResult lcs(byte[] keyA, byte[] keyB, LCSParams params) {
+    return executeCommand(getCommandObjects().lcs(keyA, keyB, params));
+  }
+
+  // List commands
+  @Override
+  public long rpush(String key, String... string) {
+    return executeCommand(getCommandObjects().rpush(key, string));
+  }
+
+  @Override
+  public long lpush(String key, String... string) {
+    return executeCommand(getCommandObjects().lpush(key, string));
+  }
+
+  @Override
+  public long llen(String key) {
+    return executeCommand(getCommandObjects().llen(key));
+  }
+
+  @Override
+  public List<String> lrange(String key, long start, long stop) {
+    return executeCommand(getCommandObjects().lrange(key, start, stop));
+  }
+
+  @Override
+  public String ltrim(String key, long start, long stop) {
+    return executeCommand(getCommandObjects().ltrim(key, start, stop));
+  }
+
+  @Override
+  public String lindex(String key, long index) {
+    return executeCommand(getCommandObjects().lindex(key, index));
+  }
+
+  @Override
+  public long rpush(byte[] key, byte[]... args) {
+    return executeCommand(getCommandObjects().rpush(key, args));
+  }
+
+  @Override
+  public long lpush(byte[] key, byte[]... args) {
+    return executeCommand(getCommandObjects().lpush(key, args));
+  }
+
+  @Override
+  public long llen(byte[] key) {
+    return executeCommand(getCommandObjects().llen(key));
+  }
+
+  @Override
+  public List<byte[]> lrange(byte[] key, long start, long stop) {
+    return executeCommand(getCommandObjects().lrange(key, start, stop));
+  }
+
+  @Override
+  public String ltrim(byte[] key, long start, long stop) {
+    return executeCommand(getCommandObjects().ltrim(key, start, stop));
+  }
+
+  @Override
+  public byte[] lindex(byte[] key, long index) {
+    return executeCommand(getCommandObjects().lindex(key, index));
+  }
+
+  @Override
+  public String lset(String key, long index, String value) {
+    return executeCommand(getCommandObjects().lset(key, index, value));
+  }
+
+  @Override
+  public long lrem(String key, long count, String value) {
+    return executeCommand(getCommandObjects().lrem(key, count, value));
+  }
+
+  @Override
+  public String lpop(String key) {
+    return executeCommand(getCommandObjects().lpop(key));
+  }
+
+  @Override
+  public List<String> lpop(String key, int count) {
+    return executeCommand(getCommandObjects().lpop(key, count));
+  }
+
+  @Override
+  public String lset(byte[] key, long index, byte[] value) {
+    return executeCommand(getCommandObjects().lset(key, index, value));
+  }
+
+  @Override
+  public long lrem(byte[] key, long count, byte[] value) {
+    return executeCommand(getCommandObjects().lrem(key, count, value));
+  }
+
+  @Override
+  public byte[] lpop(byte[] key) {
+    return executeCommand(getCommandObjects().lpop(key));
+  }
+
+  @Override
+  public List<byte[]> lpop(byte[] key, int count) {
+    return executeCommand(getCommandObjects().lpop(key, count));
+  }
+
+  @Override
+  public Long lpos(String key, String element) {
+    return executeCommand(getCommandObjects().lpos(key, element));
+  }
+
+  @Override
+  public Long lpos(String key, String element, LPosParams params) {
+    return executeCommand(getCommandObjects().lpos(key, element, params));
+  }
+
+  @Override
+  public List<Long> lpos(String key, String element, LPosParams params, long count) {
+    return executeCommand(getCommandObjects().lpos(key, element, params, count));
+  }
+
+  @Override
+  public Long lpos(byte[] key, byte[] element) {
+    return executeCommand(getCommandObjects().lpos(key, element));
+  }
+
+  @Override
+  public Long lpos(byte[] key, byte[] element, LPosParams params) {
+    return executeCommand(getCommandObjects().lpos(key, element, params));
+  }
+
+  @Override
+  public List<Long> lpos(byte[] key, byte[] element, LPosParams params, long count) {
+    return executeCommand(getCommandObjects().lpos(key, element, params, count));
+  }
+
+  @Override
+  public String rpop(String key) {
+    return executeCommand(getCommandObjects().rpop(key));
+  }
+
+  @Override
+  public List<String> rpop(String key, int count) {
+    return executeCommand(getCommandObjects().rpop(key, count));
+  }
+
+  @Override
+  public byte[] rpop(byte[] key) {
+    return executeCommand(getCommandObjects().rpop(key));
+  }
+
+  @Override
+  public List<byte[]> rpop(byte[] key, int count) {
+    return executeCommand(getCommandObjects().rpop(key, count));
+  }
+
+  @Override
+  public long linsert(String key, ListPosition where, String pivot, String value) {
+    return executeCommand(getCommandObjects().linsert(key, where, pivot, value));
+  }
+
+  @Override
+  public long lpushx(String key, String... strings) {
+    return executeCommand(getCommandObjects().lpushx(key, strings));
+  }
+
+  @Override
+  public long rpushx(String key, String... strings) {
+    return executeCommand(getCommandObjects().rpushx(key, strings));
+  }
+
+  @Override
+  public long linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value) {
+    return executeCommand(getCommandObjects().linsert(key, where, pivot, value));
+  }
+
+  @Override
+  public long lpushx(byte[] key, byte[]... args) {
+    return executeCommand(getCommandObjects().lpushx(key, args));
+  }
+
+  @Override
+  public long rpushx(byte[] key, byte[]... args) {
+    return executeCommand(getCommandObjects().rpushx(key, args));
+  }
+
+  @Override
+  public List<String> blpop(int timeout, String key) {
+    return executeCommand(getCommandObjects().blpop(timeout, key));
+  }
+
+  @Override
+  public KeyValue<String, String> blpop(double timeout, String key) {
+    return executeCommand(getCommandObjects().blpop(timeout, key));
+  }
+
+  @Override
+  public List<String> brpop(int timeout, String key) {
+    return executeCommand(getCommandObjects().brpop(timeout, key));
+  }
+
+  @Override
+  public KeyValue<String, String> brpop(double timeout, String key) {
+    return executeCommand(getCommandObjects().brpop(timeout, key));
+  }
+
+  @Override
+  public List<String> blpop(int timeout, String... keys) {
+    return executeCommand(getCommandObjects().blpop(timeout, keys));
+  }
+
+  @Override
+  public KeyValue<String, String> blpop(double timeout, String... keys) {
+    return executeCommand(getCommandObjects().blpop(timeout, keys));
+  }
+
+  @Override
+  public List<String> brpop(int timeout, String... keys) {
+    return executeCommand(getCommandObjects().brpop(timeout, keys));
+  }
+
+  @Override
+  public KeyValue<String, String> brpop(double timeout, String... keys) {
+    return executeCommand(getCommandObjects().brpop(timeout, keys));
+  }
+
+  @Override
+  public List<byte[]> blpop(int timeout, byte[]... keys) {
+    return executeCommand(getCommandObjects().blpop(timeout, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], byte[]> blpop(double timeout, byte[]... keys) {
+    return executeCommand(getCommandObjects().blpop(timeout, keys));
+  }
+
+  @Override
+  public List<byte[]> brpop(int timeout, byte[]... keys) {
+    return executeCommand(getCommandObjects().brpop(timeout, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], byte[]> brpop(double timeout, byte[]... keys) {
+    return executeCommand(getCommandObjects().brpop(timeout, keys));
+  }
+
+  @Override
+  public String rpoplpush(String srckey, String dstkey) {
+    return executeCommand(getCommandObjects().rpoplpush(srckey, dstkey));
+  }
+
+  @Override
+  public String brpoplpush(String source, String destination, int timeout) {
+    return executeCommand(getCommandObjects().brpoplpush(source, destination, timeout));
+  }
+
+  @Override
+  public byte[] rpoplpush(byte[] srckey, byte[] dstkey) {
+    return executeCommand(getCommandObjects().rpoplpush(srckey, dstkey));
+  }
+
+  @Override
+  public byte[] brpoplpush(byte[] source, byte[] destination, int timeout) {
+    return executeCommand(getCommandObjects().brpoplpush(source, destination, timeout));
+  }
+
+  @Override
+  public String lmove(String srcKey, String dstKey, ListDirection from, ListDirection to) {
+    return executeCommand(getCommandObjects().lmove(srcKey, dstKey, from, to));
+  }
+
+  @Override
+  public String blmove(String srcKey, String dstKey, ListDirection from, ListDirection to,
+      double timeout) {
+    return executeCommand(getCommandObjects().blmove(srcKey, dstKey, from, to, timeout));
+  }
+
+  @Override
+  public byte[] lmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to) {
+    return executeCommand(getCommandObjects().lmove(srcKey, dstKey, from, to));
+  }
+
+  @Override
+  public byte[] blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to,
+      double timeout) {
+    return executeCommand(getCommandObjects().blmove(srcKey, dstKey, from, to, timeout));
+  }
+
+  @Override
+  public KeyValue<String, List<String>> lmpop(ListDirection direction, String... keys) {
+    return executeCommand(getCommandObjects().lmpop(direction, keys));
+  }
+
+  @Override
+  public KeyValue<String, List<String>> lmpop(ListDirection direction, int count, String... keys) {
+    return executeCommand(getCommandObjects().lmpop(direction, count, keys));
+  }
+
+  @Override
+  public KeyValue<String, List<String>> blmpop(double timeout, ListDirection direction,
+      String... keys) {
+    return executeCommand(getCommandObjects().blmpop(timeout, direction, keys));
+  }
+
+  @Override
+  public KeyValue<String, List<String>> blmpop(double timeout, ListDirection direction, int count,
+      String... keys) {
+    return executeCommand(getCommandObjects().blmpop(timeout, direction, count, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], List<byte[]>> lmpop(ListDirection direction, byte[]... keys) {
+    return executeCommand(getCommandObjects().lmpop(direction, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], List<byte[]>> lmpop(ListDirection direction, int count, byte[]... keys) {
+    return executeCommand(getCommandObjects().lmpop(direction, count, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], List<byte[]>> blmpop(double timeout, ListDirection direction,
+      byte[]... keys) {
+    return executeCommand(getCommandObjects().blmpop(timeout, direction, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], List<byte[]>> blmpop(double timeout, ListDirection direction, int count,
+      byte[]... keys) {
+    return executeCommand(getCommandObjects().blmpop(timeout, direction, count, keys));
+  }
+
+  // Hash commands
+  @Override
+  public long hset(String key, String field, String value) {
+    return executeCommand(getCommandObjects().hset(key, field, value));
+  }
+
+  @Override
+  public long hset(String key, Map<String, String> hash) {
+    return executeCommand(getCommandObjects().hset(key, hash));
+  }
+
+  @Override
+  public long hsetex(String key, HSetExParams params, String field, String value) {
+    return executeCommand(getCommandObjects().hsetex(key, params, field, value));
+  }
+
+  @Override
+  public long hsetex(String key, HSetExParams params, Map<String, String> hash) {
+    return executeCommand(getCommandObjects().hsetex(key, params, hash));
+  }
+
+  @Override
+  public String hget(String key, String field) {
+    return executeCommand(getCommandObjects().hget(key, field));
+  }
+
+  @Override
+  public List<String> hgetex(String key, HGetExParams params, String... fields) {
+    return executeCommand(getCommandObjects().hgetex(key, params, fields));
+  }
+
+  @Override
+  public List<String> hgetdel(String key, String... fields) {
+    return executeCommand(getCommandObjects().hgetdel(key, fields));
+  }
+
+  @Override
+  public long hsetnx(String key, String field, String value) {
+    return executeCommand(getCommandObjects().hsetnx(key, field, value));
+  }
+
+  @Override
+  public String hmset(String key, Map<String, String> hash) {
+    return executeCommand(getCommandObjects().hmset(key, hash));
+  }
+
+  @Override
+  public List<String> hmget(String key, String... fields) {
+    return executeCommand(getCommandObjects().hmget(key, fields));
+  }
+
+  @Override
+  public long hset(byte[] key, byte[] field, byte[] value) {
+    return executeCommand(getCommandObjects().hset(key, field, value));
+  }
+
+  @Override
+  public long hset(byte[] key, Map<byte[], byte[]> hash) {
+    return executeCommand(getCommandObjects().hset(key, hash));
+  }
+
+  @Override
+  public long hsetex(byte[] key, HSetExParams params, byte[] field, byte[] value) {
+    return executeCommand(getCommandObjects().hsetex(key, params, field, value));
+  }
+
+  @Override
+  public long hsetex(byte[] key, HSetExParams params, Map<byte[], byte[]> hash) {
+    return executeCommand(getCommandObjects().hsetex(key, params, hash));
+  }
+
+  @Override
+  public byte[] hget(byte[] key, byte[] field) {
+    return executeCommand(getCommandObjects().hget(key, field));
+  }
+
+  @Override
+  public List<byte[]> hgetex(byte[] key, HGetExParams params, byte[]... fields) {
+    return executeCommand(getCommandObjects().hgetex(key, params, fields));
+  }
+
+  @Override
+  public List<byte[]> hgetdel(byte[] key, byte[]... fields) {
+    return executeCommand(getCommandObjects().hgetdel(key, fields));
+  }
+
+  @Override
+  public long hsetnx(byte[] key, byte[] field, byte[] value) {
+    return executeCommand(getCommandObjects().hsetnx(key, field, value));
+  }
+
+  @Override
+  public String hmset(byte[] key, Map<byte[], byte[]> hash) {
+    return executeCommand(getCommandObjects().hmset(key, hash));
+  }
+
+  @Override
+  public List<byte[]> hmget(byte[] key, byte[]... fields) {
+    return executeCommand(getCommandObjects().hmget(key, fields));
+  }
+
+  @Override
+  public long hincrBy(String key, String field, long value) {
+    return executeCommand(getCommandObjects().hincrBy(key, field, value));
+  }
+
+  @Override
+  public double hincrByFloat(String key, String field, double value) {
+    return executeCommand(getCommandObjects().hincrByFloat(key, field, value));
+  }
+
+  @Override
+  public boolean hexists(String key, String field) {
+    return executeCommand(getCommandObjects().hexists(key, field));
+  }
+
+  @Override
+  public long hdel(String key, String... field) {
+    return executeCommand(getCommandObjects().hdel(key, field));
+  }
+
+  @Override
+  public long hlen(String key) {
+    return executeCommand(getCommandObjects().hlen(key));
+  }
+
+  @Override
+  public long hincrBy(byte[] key, byte[] field, long value) {
+    return executeCommand(getCommandObjects().hincrBy(key, field, value));
+  }
+
+  @Override
+  public double hincrByFloat(byte[] key, byte[] field, double value) {
+    return executeCommand(getCommandObjects().hincrByFloat(key, field, value));
+  }
+
+  @Override
+  public boolean hexists(byte[] key, byte[] field) {
+    return executeCommand(getCommandObjects().hexists(key, field));
+  }
+
+  @Override
+  public long hdel(byte[] key, byte[]... field) {
+    return executeCommand(getCommandObjects().hdel(key, field));
+  }
+
+  @Override
+  public long hlen(byte[] key) {
+    return executeCommand(getCommandObjects().hlen(key));
+  }
+
+  @Override
+  public Set<String> hkeys(String key) {
+    return executeCommand(getCommandObjects().hkeys(key));
+  }
+
+  @Override
+  public List<String> hvals(String key) {
+    return executeCommand(getCommandObjects().hvals(key));
+  }
+
+  @Override
+  public Map<String, String> hgetAll(String key) {
+    return executeCommand(getCommandObjects().hgetAll(key));
+  }
+
+  @Override
+  public Set<byte[]> hkeys(byte[] key) {
+    return executeCommand(getCommandObjects().hkeys(key));
+  }
+
+  @Override
+  public List<byte[]> hvals(byte[] key) {
+    return executeCommand(getCommandObjects().hvals(key));
+  }
+
+  @Override
+  public Map<byte[], byte[]> hgetAll(byte[] key) {
+    return executeCommand(getCommandObjects().hgetAll(key));
+  }
+
+  @Override
+  public String hrandfield(String key) {
+    return executeCommand(getCommandObjects().hrandfield(key));
+  }
+
+  @Override
+  public List<String> hrandfield(String key, long count) {
+    return executeCommand(getCommandObjects().hrandfield(key, count));
+  }
+
+  @Override
+  public List<Map.Entry<String, String>> hrandfieldWithValues(String key, long count) {
+    return executeCommand(getCommandObjects().hrandfieldWithValues(key, count));
+  }
+
+  @Override
+  public ScanResult<Map.Entry<String, String>> hscan(String key, String cursor, ScanParams params) {
+    return executeCommand(getCommandObjects().hscan(key, cursor, params));
+  }
+
+  @Override
+  public ScanResult<String> hscanNoValues(String key, String cursor, ScanParams params) {
+    return executeCommand(getCommandObjects().hscanNoValues(key, cursor, params));
+  }
+
+  @Override
+  public long hstrlen(String key, String field) {
+    return executeCommand(getCommandObjects().hstrlen(key, field));
+  }
+
+  @Override
+  public byte[] hrandfield(byte[] key) {
+    return executeCommand(getCommandObjects().hrandfield(key));
+  }
+
+  @Override
+  public List<byte[]> hrandfield(byte[] key, long count) {
+    return executeCommand(getCommandObjects().hrandfield(key, count));
+  }
+
+  @Override
+  public List<Map.Entry<byte[], byte[]>> hrandfieldWithValues(byte[] key, long count) {
+    return executeCommand(getCommandObjects().hrandfieldWithValues(key, count));
+  }
+
+  @Override
+  public ScanResult<Map.Entry<byte[], byte[]>> hscan(byte[] key, byte[] cursor, ScanParams params) {
+    return executeCommand(getCommandObjects().hscan(key, cursor, params));
+  }
+
+  @Override
+  public ScanResult<byte[]> hscanNoValues(byte[] key, byte[] cursor, ScanParams params) {
+    return executeCommand(getCommandObjects().hscanNoValues(key, cursor, params));
+  }
+
+  @Override
+  public long hstrlen(byte[] key, byte[] field) {
+    return executeCommand(getCommandObjects().hstrlen(key, field));
+  }
+
+  @Override
+  public List<Long> hexpire(String key, long seconds, String... fields) {
+    return executeCommand(getCommandObjects().hexpire(key, seconds, fields));
+  }
+
+  @Override
+  public List<Long> hexpire(String key, long seconds, ExpiryOption condition, String... fields) {
+    return executeCommand(getCommandObjects().hexpire(key, seconds, condition, fields));
+  }
+
+  @Override
+  public List<Long> hpexpire(String key, long milliseconds, String... fields) {
+    return executeCommand(getCommandObjects().hpexpire(key, milliseconds, fields));
+  }
+
+  @Override
+  public List<Long> hpexpire(String key, long milliseconds, ExpiryOption condition,
+      String... fields) {
+    return executeCommand(getCommandObjects().hpexpire(key, milliseconds, condition, fields));
+  }
+
+  @Override
+  public List<Long> hexpireAt(String key, long unixTimeSeconds, String... fields) {
+    return executeCommand(getCommandObjects().hexpireAt(key, unixTimeSeconds, fields));
+  }
+
+  @Override
+  public List<Long> hexpireAt(String key, long unixTimeSeconds, ExpiryOption condition,
+      String... fields) {
+    return executeCommand(getCommandObjects().hexpireAt(key, unixTimeSeconds, condition, fields));
+  }
+
+  @Override
+  public List<Long> hpexpireAt(String key, long unixTimeMillis, String... fields) {
+    return executeCommand(getCommandObjects().hpexpireAt(key, unixTimeMillis, fields));
+  }
+
+  @Override
+  public List<Long> hpexpireAt(String key, long unixTimeMillis, ExpiryOption condition,
+      String... fields) {
+    return executeCommand(getCommandObjects().hpexpireAt(key, unixTimeMillis, condition, fields));
+  }
+
+  @Override
+  public List<Long> hexpire(byte[] key, long seconds, byte[]... fields) {
+    return executeCommand(getCommandObjects().hexpire(key, seconds, fields));
+  }
+
+  @Override
+  public List<Long> hexpire(byte[] key, long seconds, ExpiryOption condition, byte[]... fields) {
+    return executeCommand(getCommandObjects().hexpire(key, seconds, condition, fields));
+  }
+
+  @Override
+  public List<Long> hpexpire(byte[] key, long milliseconds, byte[]... fields) {
+    return executeCommand(getCommandObjects().hpexpire(key, milliseconds, fields));
+  }
+
+  @Override
+  public List<Long> hpexpire(byte[] key, long milliseconds, ExpiryOption condition,
+      byte[]... fields) {
+    return executeCommand(getCommandObjects().hpexpire(key, milliseconds, condition, fields));
+  }
+
+  @Override
+  public List<Long> hexpireAt(byte[] key, long unixTimeSeconds, byte[]... fields) {
+    return executeCommand(getCommandObjects().hexpireAt(key, unixTimeSeconds, fields));
+  }
+
+  @Override
+  public List<Long> hexpireAt(byte[] key, long unixTimeSeconds, ExpiryOption condition,
+      byte[]... fields) {
+    return executeCommand(getCommandObjects().hexpireAt(key, unixTimeSeconds, condition, fields));
+  }
+
+  @Override
+  public List<Long> hpexpireAt(byte[] key, long unixTimeMillis, byte[]... fields) {
+    return executeCommand(getCommandObjects().hpexpireAt(key, unixTimeMillis, fields));
+  }
+
+  @Override
+  public List<Long> hpexpireAt(byte[] key, long unixTimeMillis, ExpiryOption condition,
+      byte[]... fields) {
+    return executeCommand(getCommandObjects().hpexpireAt(key, unixTimeMillis, condition, fields));
+  }
+
+  @Override
+  public List<Long> hexpireTime(String key, String... fields) {
+    return executeCommand(getCommandObjects().hexpireTime(key, fields));
+  }
+
+  @Override
+  public List<Long> hpexpireTime(String key, String... fields) {
+    return executeCommand(getCommandObjects().hpexpireTime(key, fields));
+  }
+
+  @Override
+  public List<Long> httl(String key, String... fields) {
+    return executeCommand(getCommandObjects().httl(key, fields));
+  }
+
+  @Override
+  public List<Long> hpttl(String key, String... fields) {
+    return executeCommand(getCommandObjects().hpttl(key, fields));
+  }
+
+  @Override
+  public List<Long> hexpireTime(byte[] key, byte[]... fields) {
+    return executeCommand(getCommandObjects().hexpireTime(key, fields));
+  }
+
+  @Override
+  public List<Long> hpexpireTime(byte[] key, byte[]... fields) {
+    return executeCommand(getCommandObjects().hpexpireTime(key, fields));
+  }
+
+  @Override
+  public List<Long> httl(byte[] key, byte[]... fields) {
+    return executeCommand(getCommandObjects().httl(key, fields));
+  }
+
+  @Override
+  public List<Long> hpttl(byte[] key, byte[]... fields) {
+    return executeCommand(getCommandObjects().hpttl(key, fields));
+  }
+
+  @Override
+  public List<Long> hpersist(String key, String... fields) {
+    return executeCommand(getCommandObjects().hpersist(key, fields));
+  }
+
+  @Override
+  public List<Long> hpersist(byte[] key, byte[]... fields) {
+    return executeCommand(getCommandObjects().hpersist(key, fields));
+  }
+
+  // Set commands
+  @Override
+  public long sadd(String key, String... members) {
+    return executeCommand(getCommandObjects().sadd(key, members));
+  }
+
+  @Override
+  public Set<String> smembers(String key) {
+    return executeCommand(getCommandObjects().smembers(key));
+  }
+
+  @Override
+  public long srem(String key, String... members) {
+    return executeCommand(getCommandObjects().srem(key, members));
+  }
+
+  @Override
+  public String spop(String key) {
+    return executeCommand(getCommandObjects().spop(key));
+  }
+
+  @Override
+  public Set<String> spop(String key, long count) {
+    return executeCommand(getCommandObjects().spop(key, count));
+  }
+
+  @Override
+  public long scard(String key) {
+    return executeCommand(getCommandObjects().scard(key));
+  }
+
+  @Override
+  public boolean sismember(String key, String member) {
+    return executeCommand(getCommandObjects().sismember(key, member));
+  }
+
+  @Override
+  public List<Boolean> smismember(String key, String... members) {
+    return executeCommand(getCommandObjects().smismember(key, members));
+  }
+
+  @Override
+  public long sadd(byte[] key, byte[]... members) {
+    return executeCommand(getCommandObjects().sadd(key, members));
+  }
+
+  @Override
+  public Set<byte[]> smembers(byte[] key) {
+    return executeCommand(getCommandObjects().smembers(key));
+  }
+
+  @Override
+  public long srem(byte[] key, byte[]... members) {
+    return executeCommand(getCommandObjects().srem(key, members));
+  }
+
+  @Override
+  public byte[] spop(byte[] key) {
+    return executeCommand(getCommandObjects().spop(key));
+  }
+
+  @Override
+  public Set<byte[]> spop(byte[] key, long count) {
+    return executeCommand(getCommandObjects().spop(key, count));
+  }
+
+  @Override
+  public long scard(byte[] key) {
+    return executeCommand(getCommandObjects().scard(key));
+  }
+
+  @Override
+  public boolean sismember(byte[] key, byte[] member) {
+    return executeCommand(getCommandObjects().sismember(key, member));
+  }
+
+  @Override
+  public List<Boolean> smismember(byte[] key, byte[]... members) {
+    return executeCommand(getCommandObjects().smismember(key, members));
+  }
+
+  @Override
+  public String srandmember(String key) {
+    return executeCommand(getCommandObjects().srandmember(key));
+  }
+
+  @Override
+  public List<String> srandmember(String key, int count) {
+    return executeCommand(getCommandObjects().srandmember(key, count));
+  }
+
+  @Override
+  public ScanResult<String> sscan(String key, String cursor, ScanParams params) {
+    return executeCommand(getCommandObjects().sscan(key, cursor, params));
+  }
+
+  @Override
+  public byte[] srandmember(byte[] key) {
+    return executeCommand(getCommandObjects().srandmember(key));
+  }
+
+  @Override
+  public List<byte[]> srandmember(byte[] key, int count) {
+    return executeCommand(getCommandObjects().srandmember(key, count));
+  }
+
+  @Override
+  public ScanResult<byte[]> sscan(byte[] key, byte[] cursor, ScanParams params) {
+    return executeCommand(getCommandObjects().sscan(key, cursor, params));
+  }
+
+  @Override
+  public Set<String> sdiff(String... keys) {
+    return executeCommand(getCommandObjects().sdiff(keys));
+  }
+
+  @Override
+  public long sdiffstore(String dstkey, String... keys) {
+    return executeCommand(getCommandObjects().sdiffstore(dstkey, keys));
+  }
+
+  @Override
+  public Set<String> sinter(String... keys) {
+    return executeCommand(getCommandObjects().sinter(keys));
+  }
+
+  @Override
+  public long sinterstore(String dstkey, String... keys) {
+    return executeCommand(getCommandObjects().sinterstore(dstkey, keys));
+  }
+
+  @Override
+  public long sintercard(String... keys) {
+    return executeCommand(getCommandObjects().sintercard(keys));
+  }
+
+  @Override
+  public long sintercard(int limit, String... keys) {
+    return executeCommand(getCommandObjects().sintercard(limit, keys));
+  }
+
+  @Override
+  public Set<String> sunion(String... keys) {
+    return executeCommand(getCommandObjects().sunion(keys));
+  }
+
+  @Override
+  public long sunionstore(String dstkey, String... keys) {
+    return executeCommand(getCommandObjects().sunionstore(dstkey, keys));
+  }
+
+  @Override
+  public long smove(String srckey, String dstkey, String member) {
+    return executeCommand(getCommandObjects().smove(srckey, dstkey, member));
+  }
+
+  @Override
+  public Set<byte[]> sdiff(byte[]... keys) {
+    return executeCommand(getCommandObjects().sdiff(keys));
+  }
+
+  @Override
+  public long sdiffstore(byte[] dstkey, byte[]... keys) {
+    return executeCommand(getCommandObjects().sdiffstore(dstkey, keys));
+  }
+
+  @Override
+  public Set<byte[]> sinter(byte[]... keys) {
+    return executeCommand(getCommandObjects().sinter(keys));
+  }
+
+  @Override
+  public long sinterstore(byte[] dstkey, byte[]... keys) {
+    return executeCommand(getCommandObjects().sinterstore(dstkey, keys));
+  }
+
+  @Override
+  public long sintercard(byte[]... keys) {
+    return executeCommand(getCommandObjects().sintercard(keys));
+  }
+
+  @Override
+  public long sintercard(int limit, byte[]... keys) {
+    return executeCommand(getCommandObjects().sintercard(limit, keys));
+  }
+
+  @Override
+  public Set<byte[]> sunion(byte[]... keys) {
+    return executeCommand(getCommandObjects().sunion(keys));
+  }
+
+  @Override
+  public long sunionstore(byte[] dstkey, byte[]... keys) {
+    return executeCommand(getCommandObjects().sunionstore(dstkey, keys));
+  }
+
+  @Override
+  public long smove(byte[] srckey, byte[] dstkey, byte[] member) {
+    return executeCommand(getCommandObjects().smove(srckey, dstkey, member));
+  }
+
+  // Sorted Set commands
+  @Override
+  public long zadd(String key, double score, String member) {
+    return executeCommand(getCommandObjects().zadd(key, score, member));
+  }
+
+  @Override
+  public long zadd(String key, double score, String member, ZAddParams params) {
+    return executeCommand(getCommandObjects().zadd(key, score, member, params));
+  }
+
+  @Override
+  public long zadd(String key, Map<String, Double> scoreMembers) {
+    return executeCommand(getCommandObjects().zadd(key, scoreMembers));
+  }
+
+  @Override
+  public long zadd(String key, Map<String, Double> scoreMembers, ZAddParams params) {
+    return executeCommand(getCommandObjects().zadd(key, scoreMembers, params));
+  }
+
+  @Override
+  public Double zaddIncr(String key, double score, String member, ZAddParams params) {
+    return executeCommand(getCommandObjects().zaddIncr(key, score, member, params));
+  }
+
+  @Override
+  public long zadd(byte[] key, double score, byte[] member) {
+    return executeCommand(getCommandObjects().zadd(key, score, member));
+  }
+
+  @Override
+  public long zadd(byte[] key, double score, byte[] member, ZAddParams params) {
+    return executeCommand(getCommandObjects().zadd(key, score, member, params));
+  }
+
+  @Override
+  public long zadd(byte[] key, Map<byte[], Double> scoreMembers) {
+    return executeCommand(getCommandObjects().zadd(key, scoreMembers));
+  }
+
+  @Override
+  public long zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params) {
+    return executeCommand(getCommandObjects().zadd(key, scoreMembers, params));
+  }
+
+  @Override
+  public Double zaddIncr(byte[] key, double score, byte[] member, ZAddParams params) {
+    return executeCommand(getCommandObjects().zaddIncr(key, score, member, params));
+  }
+
+  @Override
+  public long zrem(String key, String... members) {
+    return executeCommand(getCommandObjects().zrem(key, members));
+  }
+
+  @Override
+  public double zincrby(String key, double increment, String member) {
+    return executeCommand(getCommandObjects().zincrby(key, increment, member));
+  }
+
+  @Override
+  public Double zincrby(String key, double increment, String member, ZIncrByParams params) {
+    return executeCommand(getCommandObjects().zincrby(key, increment, member, params));
+  }
+
+  @Override
+  public Long zrank(String key, String member) {
+    return executeCommand(getCommandObjects().zrank(key, member));
+  }
+
+  @Override
+  public Long zrevrank(String key, String member) {
+    return executeCommand(getCommandObjects().zrevrank(key, member));
+  }
+
+  @Override
+  public KeyValue<Long, Double> zrankWithScore(String key, String member) {
+    return executeCommand(getCommandObjects().zrankWithScore(key, member));
+  }
+
+  @Override
+  public KeyValue<Long, Double> zrevrankWithScore(String key, String member) {
+    return executeCommand(getCommandObjects().zrevrankWithScore(key, member));
+  }
+
+  @Override
+  public long zrem(byte[] key, byte[]... members) {
+    return executeCommand(getCommandObjects().zrem(key, members));
+  }
+
+  @Override
+  public double zincrby(byte[] key, double increment, byte[] member) {
+    return executeCommand(getCommandObjects().zincrby(key, increment, member));
+  }
+
+  @Override
+  public Double zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params) {
+    return executeCommand(getCommandObjects().zincrby(key, increment, member, params));
+  }
+
+  @Override
+  public Long zrank(byte[] key, byte[] member) {
+    return executeCommand(getCommandObjects().zrank(key, member));
+  }
+
+  @Override
+  public Long zrevrank(byte[] key, byte[] member) {
+    return executeCommand(getCommandObjects().zrevrank(key, member));
+  }
+
+  @Override
+  public KeyValue<Long, Double> zrankWithScore(byte[] key, byte[] member) {
+    return executeCommand(getCommandObjects().zrankWithScore(key, member));
+  }
+
+  @Override
+  public KeyValue<Long, Double> zrevrankWithScore(byte[] key, byte[] member) {
+    return executeCommand(getCommandObjects().zrevrankWithScore(key, member));
+  }
+
+  @Override
+  public String zrandmember(String key) {
+    return executeCommand(getCommandObjects().zrandmember(key));
+  }
+
+  @Override
+  public List<String> zrandmember(String key, long count) {
+    return executeCommand(getCommandObjects().zrandmember(key, count));
+  }
+
+  @Override
+  public List<Tuple> zrandmemberWithScores(String key, long count) {
+    return executeCommand(getCommandObjects().zrandmemberWithScores(key, count));
+  }
+
+  @Override
+  public long zcard(String key) {
+    return executeCommand(getCommandObjects().zcard(key));
+  }
+
+  @Override
+  public Double zscore(String key, String member) {
+    return executeCommand(getCommandObjects().zscore(key, member));
+  }
+
+  @Override
+  public List<Double> zmscore(String key, String... members) {
+    return executeCommand(getCommandObjects().zmscore(key, members));
+  }
+
+  @Override
+  public byte[] zrandmember(byte[] key) {
+    return executeCommand(getCommandObjects().zrandmember(key));
+  }
+
+  @Override
+  public List<byte[]> zrandmember(byte[] key, long count) {
+    return executeCommand(getCommandObjects().zrandmember(key, count));
+  }
+
+  @Override
+  public List<Tuple> zrandmemberWithScores(byte[] key, long count) {
+    return executeCommand(getCommandObjects().zrandmemberWithScores(key, count));
+  }
+
+  @Override
+  public long zcard(byte[] key) {
+    return executeCommand(getCommandObjects().zcard(key));
+  }
+
+  @Override
+  public Double zscore(byte[] key, byte[] member) {
+    return executeCommand(getCommandObjects().zscore(key, member));
+  }
+
+  @Override
+  public List<Double> zmscore(byte[] key, byte[]... members) {
+    return executeCommand(getCommandObjects().zmscore(key, members));
+  }
+
+  @Override
+  public Tuple zpopmax(String key) {
+    return executeCommand(getCommandObjects().zpopmax(key));
+  }
+
+  @Override
+  public List<Tuple> zpopmax(String key, int count) {
+    return executeCommand(getCommandObjects().zpopmax(key, count));
+  }
+
+  @Override
+  public Tuple zpopmin(String key) {
+    return executeCommand(getCommandObjects().zpopmin(key));
+  }
+
+  @Override
+  public List<Tuple> zpopmin(String key, int count) {
+    return executeCommand(getCommandObjects().zpopmin(key, count));
+  }
+
+  @Override
+  public long zcount(String key, double min, double max) {
+    return executeCommand(getCommandObjects().zcount(key, min, max));
+  }
+
+  @Override
+  public long zcount(String key, String min, String max) {
+    return executeCommand(getCommandObjects().zcount(key, min, max));
+  }
+
+  @Override
+  public Tuple zpopmax(byte[] key) {
+    return executeCommand(getCommandObjects().zpopmax(key));
+  }
+
+  @Override
+  public List<Tuple> zpopmax(byte[] key, int count) {
+    return executeCommand(getCommandObjects().zpopmax(key, count));
+  }
+
+  @Override
+  public Tuple zpopmin(byte[] key) {
+    return executeCommand(getCommandObjects().zpopmin(key));
+  }
+
+  @Override
+  public List<Tuple> zpopmin(byte[] key, int count) {
+    return executeCommand(getCommandObjects().zpopmin(key, count));
+  }
+
+  @Override
+  public long zcount(byte[] key, double min, double max) {
+    return executeCommand(getCommandObjects().zcount(key, min, max));
+  }
+
+  @Override
+  public long zcount(byte[] key, byte[] min, byte[] max) {
+    return executeCommand(getCommandObjects().zcount(key, min, max));
+  }
+
+  @Override
+  public List<String> zrange(String key, long start, long stop) {
+    return executeCommand(getCommandObjects().zrange(key, start, stop));
+  }
+
+  @Override
+  public List<String> zrevrange(String key, long start, long stop) {
+    return executeCommand(getCommandObjects().zrevrange(key, start, stop));
+  }
+
+  @Override
+  public List<Tuple> zrangeWithScores(String key, long start, long stop) {
+    return executeCommand(getCommandObjects().zrangeWithScores(key, start, stop));
+  }
+
+  @Override
+  public List<Tuple> zrevrangeWithScores(String key, long start, long stop) {
+    return executeCommand(getCommandObjects().zrevrangeWithScores(key, start, stop));
+  }
+
+  @Override
+  public List<String> zrange(String key, ZRangeParams zRangeParams) {
+    return executeCommand(getCommandObjects().zrange(key, zRangeParams));
+  }
+
+  @Override
+  public List<Tuple> zrangeWithScores(String key, ZRangeParams zRangeParams) {
+    return executeCommand(getCommandObjects().zrangeWithScores(key, zRangeParams));
+  }
+
+  @Override
+  public long zrangestore(String dest, String src, ZRangeParams zRangeParams) {
+    return executeCommand(getCommandObjects().zrangestore(dest, src, zRangeParams));
+  }
+
+  @Override
+  public List<String> zrangeByScore(String key, double min, double max) {
+    return executeCommand(getCommandObjects().zrangeByScore(key, min, max));
+  }
+
+  @Override
+  public List<String> zrangeByScore(String key, String min, String max) {
+    return executeCommand(getCommandObjects().zrangeByScore(key, min, max));
+  }
+
+  @Override
+  public List<String> zrevrangeByScore(String key, double max, double min) {
+    return executeCommand(getCommandObjects().zrevrangeByScore(key, max, min));
+  }
+
+  @Override
+  public List<String> zrangeByScore(String key, double min, double max, int offset, int count) {
+    return executeCommand(getCommandObjects().zrangeByScore(key, min, max, offset, count));
+  }
+
+  @Override
+  public List<String> zrevrangeByScore(String key, String max, String min) {
+    return executeCommand(getCommandObjects().zrevrangeByScore(key, max, min));
+  }
+
+  @Override
+  public List<String> zrangeByScore(String key, String min, String max, int offset, int count) {
+    return executeCommand(getCommandObjects().zrangeByScore(key, min, max, offset, count));
+  }
+
+  @Override
+  public List<String> zrevrangeByScore(String key, double max, double min, int offset, int count) {
+    return executeCommand(getCommandObjects().zrevrangeByScore(key, max, min, offset, count));
+  }
+
+  @Override
+  public List<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
+    return executeCommand(getCommandObjects().zrangeByScoreWithScores(key, min, max));
+  }
+
+  @Override
+  public List<Tuple> zrevrangeByScoreWithScores(String key, double max, double min) {
+    return executeCommand(getCommandObjects().zrevrangeByScoreWithScores(key, max, min));
+  }
+
+  @Override
+  public List<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset,
+      int count) {
+    return executeCommand(
+      getCommandObjects().zrangeByScoreWithScores(key, min, max, offset, count));
+  }
+
+  @Override
+  public List<String> zrevrangeByScore(String key, String max, String min, int offset, int count) {
+    return executeCommand(getCommandObjects().zrevrangeByScore(key, max, min, offset, count));
+  }
+
+  @Override
+  public List<Tuple> zrangeByScoreWithScores(String key, String min, String max) {
+    return executeCommand(getCommandObjects().zrangeByScoreWithScores(key, min, max));
+  }
+
+  @Override
+  public List<Tuple> zrevrangeByScoreWithScores(String key, String max, String min) {
+    return executeCommand(getCommandObjects().zrevrangeByScoreWithScores(key, max, min));
+  }
+
+  @Override
+  public List<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset,
+      int count) {
+    return executeCommand(
+      getCommandObjects().zrangeByScoreWithScores(key, min, max, offset, count));
+  }
+
+  @Override
+  public List<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset,
+      int count) {
+    return executeCommand(
+      getCommandObjects().zrevrangeByScoreWithScores(key, max, min, offset, count));
+  }
+
+  @Override
+  public List<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, int offset,
+      int count) {
+    return executeCommand(
+      getCommandObjects().zrevrangeByScoreWithScores(key, max, min, offset, count));
+  }
+
+  @Override
+  public List<byte[]> zrange(byte[] key, long start, long stop) {
+    return executeCommand(getCommandObjects().zrange(key, start, stop));
+  }
+
+  @Override
+  public List<byte[]> zrevrange(byte[] key, long start, long stop) {
+    return executeCommand(getCommandObjects().zrevrange(key, start, stop));
+  }
+
+  @Override
+  public List<Tuple> zrangeWithScores(byte[] key, long start, long stop) {
+    return executeCommand(getCommandObjects().zrangeWithScores(key, start, stop));
+  }
+
+  @Override
+  public List<Tuple> zrevrangeWithScores(byte[] key, long start, long stop) {
+    return executeCommand(getCommandObjects().zrevrangeWithScores(key, start, stop));
+  }
+
+  @Override
+  public List<byte[]> zrange(byte[] key, ZRangeParams zRangeParams) {
+    return executeCommand(getCommandObjects().zrange(key, zRangeParams));
+  }
+
+  @Override
+  public List<Tuple> zrangeWithScores(byte[] key, ZRangeParams zRangeParams) {
+    return executeCommand(getCommandObjects().zrangeWithScores(key, zRangeParams));
+  }
+
+  @Override
+  public long zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams) {
+    return executeCommand(getCommandObjects().zrangestore(dest, src, zRangeParams));
+  }
+
+  @Override
+  public List<byte[]> zrangeByScore(byte[] key, double min, double max) {
+    return executeCommand(getCommandObjects().zrangeByScore(key, min, max));
+  }
+
+  @Override
+  public List<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max) {
+    return executeCommand(getCommandObjects().zrangeByScore(key, min, max));
+  }
+
+  @Override
+  public List<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
+    return executeCommand(getCommandObjects().zrevrangeByScore(key, max, min));
+  }
+
+  @Override
+  public List<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
+    return executeCommand(getCommandObjects().zrangeByScore(key, min, max, offset, count));
+  }
+
+  @Override
+  public List<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
+    return executeCommand(getCommandObjects().zrevrangeByScore(key, max, min));
+  }
+
+  @Override
+  public List<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count) {
+    return executeCommand(getCommandObjects().zrangeByScore(key, min, max, offset, count));
+  }
+
+  @Override
+  public List<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
+    return executeCommand(getCommandObjects().zrevrangeByScore(key, max, min, offset, count));
+  }
+
+  @Override
+  public List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max) {
+    return executeCommand(getCommandObjects().zrangeByScoreWithScores(key, min, max));
+  }
+
+  @Override
+  public List<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
+    return executeCommand(getCommandObjects().zrevrangeByScoreWithScores(key, max, min));
+  }
+
+  @Override
+  public List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset,
+      int count) {
+    return executeCommand(
+      getCommandObjects().zrangeByScoreWithScores(key, min, max, offset, count));
+  }
+
+  @Override
+  public List<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
+    return executeCommand(getCommandObjects().zrevrangeByScore(key, max, min, offset, count));
+  }
+
+  @Override
+  public List<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
+    return executeCommand(getCommandObjects().zrangeByScoreWithScores(key, min, max));
+  }
+
+  @Override
+  public List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min) {
+    return executeCommand(getCommandObjects().zrevrangeByScoreWithScores(key, max, min));
+  }
+
+  @Override
+  public List<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset,
+      int count) {
+    return executeCommand(
+      getCommandObjects().zrangeByScoreWithScores(key, min, max, offset, count));
+  }
+
+  @Override
+  public List<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset,
+      int count) {
+    return executeCommand(
+      getCommandObjects().zrevrangeByScoreWithScores(key, max, min, offset, count));
+  }
+
+  @Override
+  public List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset,
+      int count) {
+    return executeCommand(
+      getCommandObjects().zrevrangeByScoreWithScores(key, max, min, offset, count));
+  }
+
+  @Override
+  public long zremrangeByRank(String key, long start, long stop) {
+    return executeCommand(getCommandObjects().zremrangeByRank(key, start, stop));
+  }
+
+  @Override
+  public long zremrangeByScore(String key, double min, double max) {
+    return executeCommand(getCommandObjects().zremrangeByScore(key, min, max));
+  }
+
+  @Override
+  public long zremrangeByScore(String key, String min, String max) {
+    return executeCommand(getCommandObjects().zremrangeByScore(key, min, max));
+  }
+
+  @Override
+  public long zremrangeByRank(byte[] key, long start, long stop) {
+    return executeCommand(getCommandObjects().zremrangeByRank(key, start, stop));
+  }
+
+  @Override
+  public long zremrangeByScore(byte[] key, double min, double max) {
+    return executeCommand(getCommandObjects().zremrangeByScore(key, min, max));
+  }
+
+  @Override
+  public long zremrangeByScore(byte[] key, byte[] min, byte[] max) {
+    return executeCommand(getCommandObjects().zremrangeByScore(key, min, max));
+  }
+
+  @Override
+  public long zlexcount(String key, String min, String max) {
+    return executeCommand(getCommandObjects().zlexcount(key, min, max));
+  }
+
+  @Override
+  public List<String> zrangeByLex(String key, String min, String max) {
+    return executeCommand(getCommandObjects().zrangeByLex(key, min, max));
+  }
+
+  @Override
+  public List<String> zrangeByLex(String key, String min, String max, int offset, int count) {
+    return executeCommand(getCommandObjects().zrangeByLex(key, min, max, offset, count));
+  }
+
+  @Override
+  public List<String> zrevrangeByLex(String key, String max, String min) {
+    return executeCommand(getCommandObjects().zrevrangeByLex(key, max, min));
+  }
+
+  @Override
+  public List<String> zrevrangeByLex(String key, String max, String min, int offset, int count) {
+    return executeCommand(getCommandObjects().zrevrangeByLex(key, max, min, offset, count));
+  }
+
+  @Override
+  public long zremrangeByLex(String key, String min, String max) {
+    return executeCommand(getCommandObjects().zremrangeByLex(key, min, max));
+  }
+
+  @Override
+  public long zlexcount(byte[] key, byte[] min, byte[] max) {
+    return executeCommand(getCommandObjects().zlexcount(key, min, max));
+  }
+
+  @Override
+  public List<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max) {
+    return executeCommand(getCommandObjects().zrangeByLex(key, min, max));
+  }
+
+  @Override
+  public List<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count) {
+    return executeCommand(getCommandObjects().zrangeByLex(key, min, max, offset, count));
+  }
+
+  @Override
+  public List<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min) {
+    return executeCommand(getCommandObjects().zrevrangeByLex(key, max, min));
+  }
+
+  @Override
+  public List<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count) {
+    return executeCommand(getCommandObjects().zrevrangeByLex(key, max, min, offset, count));
+  }
+
+  @Override
+  public long zremrangeByLex(byte[] key, byte[] min, byte[] max) {
+    return executeCommand(getCommandObjects().zremrangeByLex(key, min, max));
+  }
+
+  @Override
+  public ScanResult<Tuple> zscan(String key, String cursor, ScanParams params) {
+    return executeCommand(getCommandObjects().zscan(key, cursor, params));
+  }
+
+  @Override
+  public ScanResult<Tuple> zscan(byte[] key, byte[] cursor, ScanParams params) {
+    return executeCommand(getCommandObjects().zscan(key, cursor, params));
+  }
+
+  @Override
+  public KeyValue<String, Tuple> bzpopmax(double timeout, String... keys) {
+    return executeCommand(getCommandObjects().bzpopmax(timeout, keys));
+  }
+
+  @Override
+  public KeyValue<String, Tuple> bzpopmin(double timeout, String... keys) {
+    return executeCommand(getCommandObjects().bzpopmin(timeout, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], Tuple> bzpopmax(double timeout, byte[]... keys) {
+    return executeCommand(getCommandObjects().bzpopmax(timeout, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], Tuple> bzpopmin(double timeout, byte[]... keys) {
+    return executeCommand(getCommandObjects().bzpopmin(timeout, keys));
+  }
+
+  @Override
+  public List<String> zdiff(String... keys) {
+    return executeCommand(getCommandObjects().zdiff(keys));
+  }
+
+  @Override
+  public List<Tuple> zdiffWithScores(String... keys) {
+    return executeCommand(getCommandObjects().zdiffWithScores(keys));
+  }
+
+  @Override
+  public long zdiffstore(String dstkey, String... keys) {
+    return executeCommand(getCommandObjects().zdiffstore(dstkey, keys));
+  }
+
+  @Override
+  public List<byte[]> zdiff(byte[]... keys) {
+    return executeCommand(getCommandObjects().zdiff(keys));
+  }
+
+  @Override
+  public List<Tuple> zdiffWithScores(byte[]... keys) {
+    return executeCommand(getCommandObjects().zdiffWithScores(keys));
+  }
+
+  @Override
+  public long zdiffstore(byte[] dstkey, byte[]... keys) {
+    return executeCommand(getCommandObjects().zdiffstore(dstkey, keys));
+  }
+
+  @Override
+  public long zinterstore(String dstkey, String... sets) {
+    return executeCommand(getCommandObjects().zinterstore(dstkey, sets));
+  }
+
+  @Override
+  public long zinterstore(String dstkey, ZParams params, String... sets) {
+    return executeCommand(getCommandObjects().zinterstore(dstkey, params, sets));
+  }
+
+  @Override
+  public List<String> zinter(ZParams params, String... keys) {
+    return executeCommand(getCommandObjects().zinter(params, keys));
+  }
+
+  @Override
+  public List<Tuple> zinterWithScores(ZParams params, String... keys) {
+    return executeCommand(getCommandObjects().zinterWithScores(params, keys));
+  }
+
+  @Override
+  public long zinterstore(byte[] dstkey, byte[]... sets) {
+    return executeCommand(getCommandObjects().zinterstore(dstkey, sets));
+  }
+
+  @Override
+  public long zinterstore(byte[] dstkey, ZParams params, byte[]... sets) {
+    return executeCommand(getCommandObjects().zinterstore(dstkey, params, sets));
+  }
+
+  @Override
+  public long zintercard(byte[]... keys) {
+    return executeCommand(getCommandObjects().zintercard(keys));
+  }
+
+  @Override
+  public long zintercard(long limit, byte[]... keys) {
+    return executeCommand(getCommandObjects().zintercard(limit, keys));
+  }
+
+  @Override
+  public long zintercard(String... keys) {
+    return executeCommand(getCommandObjects().zintercard(keys));
+  }
+
+  @Override
+  public long zintercard(long limit, String... keys) {
+    return executeCommand(getCommandObjects().zintercard(limit, keys));
+  }
+
+  @Override
+  public List<byte[]> zinter(ZParams params, byte[]... keys) {
+    return executeCommand(getCommandObjects().zinter(params, keys));
+  }
+
+  @Override
+  public List<Tuple> zinterWithScores(ZParams params, byte[]... keys) {
+    return executeCommand(getCommandObjects().zinterWithScores(params, keys));
+  }
+
+  @Override
+  public List<String> zunion(ZParams params, String... keys) {
+    return executeCommand(getCommandObjects().zunion(params, keys));
+  }
+
+  @Override
+  public List<Tuple> zunionWithScores(ZParams params, String... keys) {
+    return executeCommand(getCommandObjects().zunionWithScores(params, keys));
+  }
+
+  @Override
+  public long zunionstore(String dstkey, String... sets) {
+    return executeCommand(getCommandObjects().zunionstore(dstkey, sets));
+  }
+
+  @Override
+  public long zunionstore(String dstkey, ZParams params, String... sets) {
+    return executeCommand(getCommandObjects().zunionstore(dstkey, params, sets));
+  }
+
+  @Override
+  public List<byte[]> zunion(ZParams params, byte[]... keys) {
+    return executeCommand(getCommandObjects().zunion(params, keys));
+  }
+
+  @Override
+  public List<Tuple> zunionWithScores(ZParams params, byte[]... keys) {
+    return executeCommand(getCommandObjects().zunionWithScores(params, keys));
+  }
+
+  @Override
+  public long zunionstore(byte[] dstkey, byte[]... sets) {
+    return executeCommand(getCommandObjects().zunionstore(dstkey, sets));
+  }
+
+  @Override
+  public long zunionstore(byte[] dstkey, ZParams params, byte[]... sets) {
+    return executeCommand(getCommandObjects().zunionstore(dstkey, params, sets));
+  }
+
+  @Override
+  public KeyValue<String, List<Tuple>> zmpop(SortedSetOption option, String... keys) {
+    return executeCommand(getCommandObjects().zmpop(option, keys));
+  }
+
+  @Override
+  public KeyValue<String, List<Tuple>> zmpop(SortedSetOption option, int count, String... keys) {
+    return executeCommand(getCommandObjects().zmpop(option, count, keys));
+  }
+
+  @Override
+  public KeyValue<String, List<Tuple>> bzmpop(double timeout, SortedSetOption option,
+      String... keys) {
+    return executeCommand(getCommandObjects().bzmpop(timeout, option, keys));
+  }
+
+  @Override
+  public KeyValue<String, List<Tuple>> bzmpop(double timeout, SortedSetOption option, int count,
+      String... keys) {
+    return executeCommand(getCommandObjects().bzmpop(timeout, option, count, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], List<Tuple>> zmpop(SortedSetOption option, byte[]... keys) {
+    return executeCommand(getCommandObjects().zmpop(option, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], List<Tuple>> zmpop(SortedSetOption option, int count, byte[]... keys) {
+    return executeCommand(getCommandObjects().zmpop(option, count, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], List<Tuple>> bzmpop(double timeout, SortedSetOption option,
+      byte[]... keys) {
+    return executeCommand(getCommandObjects().bzmpop(timeout, option, keys));
+  }
+
+  @Override
+  public KeyValue<byte[], List<Tuple>> bzmpop(double timeout, SortedSetOption option, int count,
+      byte[]... keys) {
+    return executeCommand(getCommandObjects().bzmpop(timeout, option, count, keys));
+  }
+
+  // Geo commands
+  @Override
+  public long geoadd(String key, double longitude, double latitude, String member) {
+    return executeCommand(getCommandObjects().geoadd(key, longitude, latitude, member));
+  }
+
+  @Override
+  public long geoadd(String key, Map<String, GeoCoordinate> memberCoordinateMap) {
+    return executeCommand(getCommandObjects().geoadd(key, memberCoordinateMap));
+  }
+
+  @Override
+  public long geoadd(String key, GeoAddParams params,
+      Map<String, GeoCoordinate> memberCoordinateMap) {
+    return executeCommand(getCommandObjects().geoadd(key, params, memberCoordinateMap));
+  }
+
+  @Override
+  public Double geodist(String key, String member1, String member2) {
+    return executeCommand(getCommandObjects().geodist(key, member1, member2));
+  }
+
+  @Override
+  public Double geodist(String key, String member1, String member2, GeoUnit unit) {
+    return executeCommand(getCommandObjects().geodist(key, member1, member2, unit));
+  }
+
+  @Override
+  public List<String> geohash(String key, String... members) {
+    return executeCommand(getCommandObjects().geohash(key, members));
+  }
+
+  @Override
+  public List<GeoCoordinate> geopos(String key, String... members) {
+    return executeCommand(getCommandObjects().geopos(key, members));
+  }
+
+  @Override
+  public long geoadd(byte[] key, double longitude, double latitude, byte[] member) {
+    return executeCommand(getCommandObjects().geoadd(key, longitude, latitude, member));
+  }
+
+  @Override
+  public long geoadd(byte[] key, Map<byte[], GeoCoordinate> memberCoordinateMap) {
+    return executeCommand(getCommandObjects().geoadd(key, memberCoordinateMap));
+  }
+
+  @Override
+  public long geoadd(byte[] key, GeoAddParams params,
+      Map<byte[], GeoCoordinate> memberCoordinateMap) {
+    return executeCommand(getCommandObjects().geoadd(key, params, memberCoordinateMap));
+  }
+
+  @Override
+  public Double geodist(byte[] key, byte[] member1, byte[] member2) {
+    return executeCommand(getCommandObjects().geodist(key, member1, member2));
+  }
+
+  @Override
+  public Double geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit) {
+    return executeCommand(getCommandObjects().geodist(key, member1, member2, unit));
+  }
+
+  @Override
+  public List<byte[]> geohash(byte[] key, byte[]... members) {
+    return executeCommand(getCommandObjects().geohash(key, members));
+  }
+
+  @Override
+  public List<GeoCoordinate> geopos(byte[] key, byte[]... members) {
+    return executeCommand(getCommandObjects().geopos(key, members));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadius(String key, double longitude, double latitude,
+      double radius, GeoUnit unit) {
+    return executeCommand(getCommandObjects().georadius(key, longitude, latitude, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusReadonly(String key, double longitude, double latitude,
+      double radius, GeoUnit unit) {
+    return executeCommand(
+      getCommandObjects().georadiusReadonly(key, longitude, latitude, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadius(String key, double longitude, double latitude,
+      double radius, GeoUnit unit, GeoRadiusParam param) {
+    return executeCommand(
+      getCommandObjects().georadius(key, longitude, latitude, radius, unit, param));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusReadonly(String key, double longitude, double latitude,
+      double radius, GeoUnit unit, GeoRadiusParam param) {
+    return executeCommand(
+      getCommandObjects().georadiusReadonly(key, longitude, latitude, radius, unit, param));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusByMember(String key, String member, double radius,
+      GeoUnit unit) {
+    return executeCommand(getCommandObjects().georadiusByMember(key, member, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusByMemberReadonly(String key, String member, double radius,
+      GeoUnit unit) {
+    return executeCommand(getCommandObjects().georadiusByMemberReadonly(key, member, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusByMember(String key, String member, double radius,
+      GeoUnit unit, GeoRadiusParam param) {
+    return executeCommand(getCommandObjects().georadiusByMember(key, member, radius, unit, param));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusByMemberReadonly(String key, String member, double radius,
+      GeoUnit unit, GeoRadiusParam param) {
+    return executeCommand(
+      getCommandObjects().georadiusByMemberReadonly(key, member, radius, unit, param));
+  }
+
+  @Override
+  public long georadiusStore(String key, double longitude, double latitude, double radius,
+      GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
+    return executeCommand(getCommandObjects().georadiusStore(key, longitude, latitude, radius, unit,
+      param, storeParam));
+  }
+
+  @Override
+  public long georadiusByMemberStore(String key, String member, double radius, GeoUnit unit,
+      GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
+    return executeCommand(
+      getCommandObjects().georadiusByMemberStore(key, member, radius, unit, param, storeParam));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> geosearch(String key, String member, double radius, GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearch(key, member, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> geosearch(String key, GeoCoordinate coord, double radius,
+      GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearch(key, coord, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> geosearch(String key, String member, double width, double height,
+      GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearch(key, member, width, height, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> geosearch(String key, GeoCoordinate coord, double width,
+      double height, GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearch(key, coord, width, height, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> geosearch(String key, GeoSearchParam params) {
+    return executeCommand(getCommandObjects().geosearch(key, params));
+  }
+
+  @Override
+  public long geosearchStore(String dest, String src, String member, double radius, GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearchStore(dest, src, member, radius, unit));
+  }
+
+  @Override
+  public long geosearchStore(String dest, String src, GeoCoordinate coord, double radius,
+      GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearchStore(dest, src, coord, radius, unit));
+  }
+
+  @Override
+  public long geosearchStore(String dest, String src, String member, double width, double height,
+      GeoUnit unit) {
+    return executeCommand(
+      getCommandObjects().geosearchStore(dest, src, member, width, height, unit));
+  }
+
+  @Override
+  public long geosearchStore(String dest, String src, GeoCoordinate coord, double width,
+      double height, GeoUnit unit) {
+    return executeCommand(
+      getCommandObjects().geosearchStore(dest, src, coord, width, height, unit));
+  }
+
+  @Override
+  public long geosearchStore(String dest, String src, GeoSearchParam params) {
+    return executeCommand(getCommandObjects().geosearchStore(dest, src, params));
+  }
+
+  @Override
+  public long geosearchStoreStoreDist(String dest, String src, GeoSearchParam params) {
+    return executeCommand(getCommandObjects().geosearchStoreStoreDist(dest, src, params));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude,
+      double radius, GeoUnit unit) {
+    return executeCommand(getCommandObjects().georadius(key, longitude, latitude, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusReadonly(byte[] key, double longitude, double latitude,
+      double radius, GeoUnit unit) {
+    return executeCommand(
+      getCommandObjects().georadiusReadonly(key, longitude, latitude, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude,
+      double radius, GeoUnit unit, GeoRadiusParam param) {
+    return executeCommand(
+      getCommandObjects().georadius(key, longitude, latitude, radius, unit, param));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusReadonly(byte[] key, double longitude, double latitude,
+      double radius, GeoUnit unit, GeoRadiusParam param) {
+    return executeCommand(
+      getCommandObjects().georadiusReadonly(key, longitude, latitude, radius, unit, param));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius,
+      GeoUnit unit) {
+    return executeCommand(getCommandObjects().georadiusByMember(key, member, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusByMemberReadonly(byte[] key, byte[] member, double radius,
+      GeoUnit unit) {
+    return executeCommand(getCommandObjects().georadiusByMemberReadonly(key, member, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius,
+      GeoUnit unit, GeoRadiusParam param) {
+    return executeCommand(getCommandObjects().georadiusByMember(key, member, radius, unit, param));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> georadiusByMemberReadonly(byte[] key, byte[] member, double radius,
+      GeoUnit unit, GeoRadiusParam param) {
+    return executeCommand(
+      getCommandObjects().georadiusByMemberReadonly(key, member, radius, unit, param));
+  }
+
+  @Override
+  public long georadiusStore(byte[] key, double longitude, double latitude, double radius,
+      GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
+    return executeCommand(getCommandObjects().georadiusStore(key, longitude, latitude, radius, unit,
+      param, storeParam));
+  }
+
+  @Override
+  public long georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit,
+      GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
+    return executeCommand(
+      getCommandObjects().georadiusByMemberStore(key, member, radius, unit, param, storeParam));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> geosearch(byte[] key, byte[] member, double radius, GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearch(key, member, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double radius,
+      GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearch(key, coord, radius, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> geosearch(byte[] key, byte[] member, double width, double height,
+      GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearch(key, member, width, height, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double width,
+      double height, GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearch(key, coord, width, height, unit));
+  }
+
+  @Override
+  public List<GeoRadiusResponse> geosearch(byte[] key, GeoSearchParam params) {
+    return executeCommand(getCommandObjects().geosearch(key, params));
+  }
+
+  @Override
+  public long geosearchStore(byte[] dest, byte[] src, byte[] member, double radius, GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearchStore(dest, src, member, radius, unit));
+  }
+
+  @Override
+  public long geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double radius,
+      GeoUnit unit) {
+    return executeCommand(getCommandObjects().geosearchStore(dest, src, coord, radius, unit));
+  }
+
+  @Override
+  public long geosearchStore(byte[] dest, byte[] src, byte[] member, double width, double height,
+      GeoUnit unit) {
+    return executeCommand(
+      getCommandObjects().geosearchStore(dest, src, member, width, height, unit));
+  }
+
+  @Override
+  public long geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double width,
+      double height, GeoUnit unit) {
+    return executeCommand(
+      getCommandObjects().geosearchStore(dest, src, coord, width, height, unit));
+  }
+
+  @Override
+  public long geosearchStore(byte[] dest, byte[] src, GeoSearchParam params) {
+    return executeCommand(getCommandObjects().geosearchStore(dest, src, params));
+  }
+
+  @Override
+  public long geosearchStoreStoreDist(byte[] dest, byte[] src, GeoSearchParam params) {
+    return executeCommand(getCommandObjects().geosearchStoreStoreDist(dest, src, params));
+  }
+
+  // Hyper Log Log commands
+  @Override
+  public long pfadd(String key, String... elements) {
+    return executeCommand(getCommandObjects().pfadd(key, elements));
+  }
+
+  @Override
+  public String pfmerge(String destkey, String... sourcekeys) {
+    return executeCommand(getCommandObjects().pfmerge(destkey, sourcekeys));
+  }
+
+  @Override
+  public long pfcount(String key) {
+    return executeCommand(getCommandObjects().pfcount(key));
+  }
+
+  @Override
+  public long pfcount(String... keys) {
+    return executeCommand(getCommandObjects().pfcount(keys));
+  }
+
+  @Override
+  public long pfadd(byte[] key, byte[]... elements) {
+    return executeCommand(getCommandObjects().pfadd(key, elements));
+  }
+
+  @Override
+  public String pfmerge(byte[] destkey, byte[]... sourcekeys) {
+    return executeCommand(getCommandObjects().pfmerge(destkey, sourcekeys));
+  }
+
+  @Override
+  public long pfcount(byte[] key) {
+    return executeCommand(getCommandObjects().pfcount(key));
+  }
+
+  @Override
+  public long pfcount(byte[]... keys) {
+    return executeCommand(getCommandObjects().pfcount(keys));
+  }
+
+  // Stream commands
+  @Override
+  public StreamEntryID xadd(String key, StreamEntryID id, Map<String, String> hash) {
+    return executeCommand(getCommandObjects().xadd(key, id, hash));
+  }
+
+  @Override
+  public StreamEntryID xadd(String key, XAddParams params, Map<String, String> hash) {
+    return executeCommand(getCommandObjects().xadd(key, params, hash));
+  }
+
+  @Override
+  public long xlen(String key) {
+    return executeCommand(getCommandObjects().xlen(key));
+  }
+
+  @Override
+  public List<StreamEntry> xrange(String key, StreamEntryID start, StreamEntryID end) {
+    return executeCommand(getCommandObjects().xrange(key, start, end));
+  }
+
+  @Override
+  public List<StreamEntry> xrange(String key, StreamEntryID start, StreamEntryID end, int count) {
+    return executeCommand(getCommandObjects().xrange(key, start, end, count));
+  }
+
+  @Override
+  public List<StreamEntry> xrevrange(String key, StreamEntryID end, StreamEntryID start) {
+    return executeCommand(getCommandObjects().xrevrange(key, end, start));
+  }
+
+  @Override
+  public List<StreamEntry> xrevrange(String key, StreamEntryID end, StreamEntryID start,
+      int count) {
+    return executeCommand(getCommandObjects().xrevrange(key, end, start, count));
+  }
+
+  @Override
+  public List<StreamEntry> xrange(String key, String start, String end) {
+    return executeCommand(getCommandObjects().xrange(key, start, end));
+  }
+
+  @Override
+  public List<StreamEntry> xrange(String key, String start, String end, int count) {
+    return executeCommand(getCommandObjects().xrange(key, start, end, count));
+  }
+
+  @Override
+  public List<StreamEntry> xrevrange(String key, String end, String start) {
+    return executeCommand(getCommandObjects().xrevrange(key, end, start));
+  }
+
+  @Override
+  public List<StreamEntry> xrevrange(String key, String end, String start, int count) {
+    return executeCommand(getCommandObjects().xrevrange(key, end, start, count));
+  }
+
+  @Override
+  public long xack(String key, String group, StreamEntryID... ids) {
+    return executeCommand(getCommandObjects().xack(key, group, ids));
+  }
+
+  @Override
+  public String xgroupCreate(String key, String groupName, StreamEntryID id, boolean makeStream) {
+    return executeCommand(getCommandObjects().xgroupCreate(key, groupName, id, makeStream));
+  }
+
+  @Override
+  public String xgroupSetID(String key, String groupName, StreamEntryID id) {
+    return executeCommand(getCommandObjects().xgroupSetID(key, groupName, id));
+  }
+
+  @Override
+  public long xgroupDestroy(String key, String groupName) {
+    return executeCommand(getCommandObjects().xgroupDestroy(key, groupName));
+  }
+
+  @Override
+  public boolean xgroupCreateConsumer(String key, String groupName, String consumerName) {
+    return executeCommand(getCommandObjects().xgroupCreateConsumer(key, groupName, consumerName));
+  }
+
+  @Override
+  public long xgroupDelConsumer(String key, String groupName, String consumerName) {
+    return executeCommand(getCommandObjects().xgroupDelConsumer(key, groupName, consumerName));
+  }
+
+  @Override
+  public StreamPendingSummary xpending(String key, String groupName) {
+    return executeCommand(getCommandObjects().xpending(key, groupName));
+  }
+
+  @Override
+  public List<StreamPendingEntry> xpending(String key, String groupName, XPendingParams params) {
+    return executeCommand(getCommandObjects().xpending(key, groupName, params));
+  }
+
+  @Override
+  public long xdel(String key, StreamEntryID... ids) {
+    return executeCommand(getCommandObjects().xdel(key, ids));
+  }
+
+  @Override
+  public long xtrim(String key, long maxLen, boolean approximate) {
+    return executeCommand(getCommandObjects().xtrim(key, maxLen, approximate));
+  }
+
+  @Override
+  public long xtrim(String key, XTrimParams params) {
+    return executeCommand(getCommandObjects().xtrim(key, params));
+  }
+
+  @Override
+  public List<StreamEntry> xclaim(String key, String group, String consumerName, long minIdleTime,
+      XClaimParams params, StreamEntryID... ids) {
+    return executeCommand(
+      getCommandObjects().xclaim(key, group, consumerName, minIdleTime, params, ids));
+  }
+
+  @Override
+  public List<StreamEntryID> xclaimJustId(String key, String group, String consumerName,
+      long minIdleTime, XClaimParams params, StreamEntryID... ids) {
+    return executeCommand(
+      getCommandObjects().xclaimJustId(key, group, consumerName, minIdleTime, params, ids));
+  }
+
+  @Override
+  public Map.Entry<StreamEntryID, List<StreamEntry>> xautoclaim(String key, String group,
+      String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params) {
+    return executeCommand(
+      getCommandObjects().xautoclaim(key, group, consumerName, minIdleTime, start, params));
+  }
+
+  @Override
+  public Map.Entry<StreamEntryID, List<StreamEntryID>> xautoclaimJustId(String key, String group,
+      String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params) {
+    return executeCommand(
+      getCommandObjects().xautoclaimJustId(key, group, consumerName, minIdleTime, start, params));
+  }
+
+  @Override
+  public StreamInfo xinfoStream(String key) {
+    return executeCommand(getCommandObjects().xinfoStream(key));
+  }
+
+  @Override
+  public StreamFullInfo xinfoStreamFull(String key) {
+    return executeCommand(getCommandObjects().xinfoStreamFull(key));
+  }
+
+  @Override
+  public StreamFullInfo xinfoStreamFull(String key, int count) {
+    return executeCommand(getCommandObjects().xinfoStreamFull(key, count));
+  }
+
+  @Override
+  public List<StreamGroupInfo> xinfoGroups(String key) {
+    return executeCommand(getCommandObjects().xinfoGroups(key));
+  }
+
+  @Override
+  public List<StreamConsumersInfo> xinfoConsumers(String key, String group) {
+    return executeCommand(getCommandObjects().xinfoConsumers(key, group));
+  }
+
+  @Override
+  public List<StreamConsumerInfo> xinfoConsumers2(String key, String group) {
+    return executeCommand(getCommandObjects().xinfoConsumers2(key, group));
+  }
+
+  @Override
+  public List<Map.Entry<String, List<StreamEntry>>> xread(XReadParams xReadParams,
+      Map<String, StreamEntryID> streams) {
+    return executeCommand(getCommandObjects().xread(xReadParams, streams));
+  }
+
+  @Override
+  public Map<String, List<StreamEntry>> xreadAsMap(XReadParams xReadParams,
+      Map<String, StreamEntryID> streams) {
+    return executeCommand(getCommandObjects().xreadAsMap(xReadParams, streams));
+  }
+
+  @Override
+  public List<Map.Entry<String, List<StreamEntry>>> xreadGroup(String groupName, String consumer,
+      XReadGroupParams xReadGroupParams, Map<String, StreamEntryID> streams) {
+    return executeCommand(
+      getCommandObjects().xreadGroup(groupName, consumer, xReadGroupParams, streams));
+  }
+
+  @Override
+  public Map<String, List<StreamEntry>> xreadGroupAsMap(String groupName, String consumer,
+      XReadGroupParams xReadGroupParams, Map<String, StreamEntryID> streams) {
+    return executeCommand(
+      getCommandObjects().xreadGroupAsMap(groupName, consumer, xReadGroupParams, streams));
+  }
+
+  @Override
+  public byte[] xadd(byte[] key, XAddParams params, Map<byte[], byte[]> hash) {
+    return executeCommand(getCommandObjects().xadd(key, params, hash));
+  }
+
+  @Override
+  public long xlen(byte[] key) {
+    return executeCommand(getCommandObjects().xlen(key));
+  }
+
+  @Override
+  public List<Object> xrange(byte[] key, byte[] start, byte[] end) {
+    return executeCommand(getCommandObjects().xrange(key, start, end));
+  }
+
+  @Override
+  public List<Object> xrange(byte[] key, byte[] start, byte[] end, int count) {
+    return executeCommand(getCommandObjects().xrange(key, start, end, count));
+  }
+
+  @Override
+  public List<Object> xrevrange(byte[] key, byte[] end, byte[] start) {
+    return executeCommand(getCommandObjects().xrevrange(key, end, start));
+  }
+
+  @Override
+  public List<Object> xrevrange(byte[] key, byte[] end, byte[] start, int count) {
+    return executeCommand(getCommandObjects().xrevrange(key, end, start, count));
+  }
+
+  @Override
+  public long xack(byte[] key, byte[] group, byte[]... ids) {
+    return executeCommand(getCommandObjects().xack(key, group, ids));
+  }
+
+  @Override
+  public String xgroupCreate(byte[] key, byte[] groupName, byte[] id, boolean makeStream) {
+    return executeCommand(getCommandObjects().xgroupCreate(key, groupName, id, makeStream));
+  }
+
+  @Override
+  public String xgroupSetID(byte[] key, byte[] groupName, byte[] id) {
+    return executeCommand(getCommandObjects().xgroupSetID(key, groupName, id));
+  }
+
+  @Override
+  public long xgroupDestroy(byte[] key, byte[] groupName) {
+    return executeCommand(getCommandObjects().xgroupDestroy(key, groupName));
+  }
+
+  @Override
+  public boolean xgroupCreateConsumer(byte[] key, byte[] groupName, byte[] consumerName) {
+    return executeCommand(getCommandObjects().xgroupCreateConsumer(key, groupName, consumerName));
+  }
+
+  @Override
+  public long xgroupDelConsumer(byte[] key, byte[] groupName, byte[] consumerName) {
+    return executeCommand(getCommandObjects().xgroupDelConsumer(key, groupName, consumerName));
+  }
+
+  @Override
+  public long xdel(byte[] key, byte[]... ids) {
+    return executeCommand(getCommandObjects().xdel(key, ids));
+  }
+
+  @Override
+  public long xtrim(byte[] key, long maxLen, boolean approximateLength) {
+    return executeCommand(getCommandObjects().xtrim(key, maxLen, approximateLength));
+  }
+
+  @Override
+  public long xtrim(byte[] key, XTrimParams params) {
+    return executeCommand(getCommandObjects().xtrim(key, params));
+  }
+
+  @Override
+  public Object xpending(byte[] key, byte[] groupName) {
+    return executeCommand(getCommandObjects().xpending(key, groupName));
+  }
+
+  @Override
+  public List<Object> xpending(byte[] key, byte[] groupName, XPendingParams params) {
+    return executeCommand(getCommandObjects().xpending(key, groupName, params));
+  }
+
+  @Override
+  public List<byte[]> xclaim(byte[] key, byte[] group, byte[] consumerName, long minIdleTime,
+      XClaimParams params, byte[]... ids) {
+    return executeCommand(
+      getCommandObjects().xclaim(key, group, consumerName, minIdleTime, params, ids));
+  }
+
+  @Override
+  public List<byte[]> xclaimJustId(byte[] key, byte[] group, byte[] consumerName, long minIdleTime,
+      XClaimParams params, byte[]... ids) {
+    return executeCommand(
+      getCommandObjects().xclaimJustId(key, group, consumerName, minIdleTime, params, ids));
+  }
+
+  @Override
+  public List<Object> xautoclaim(byte[] key, byte[] groupName, byte[] consumerName,
+      long minIdleTime, byte[] start, XAutoClaimParams params) {
+    return executeCommand(
+      getCommandObjects().xautoclaim(key, groupName, consumerName, minIdleTime, start, params));
+  }
+
+  @Override
+  public List<Object> xautoclaimJustId(byte[] key, byte[] groupName, byte[] consumerName,
+      long minIdleTime, byte[] start, XAutoClaimParams params) {
+    return executeCommand(getCommandObjects().xautoclaimJustId(key, groupName, consumerName,
+      minIdleTime, start, params));
+  }
+
+  @Override
+  public Object xinfoStream(byte[] key) {
+    return executeCommand(getCommandObjects().xinfoStream(key));
+  }
+
+  @Override
+  public Object xinfoStreamFull(byte[] key) {
+    return executeCommand(getCommandObjects().xinfoStreamFull(key));
+  }
+
+  @Override
+  public Object xinfoStreamFull(byte[] key, int count) {
+    return executeCommand(getCommandObjects().xinfoStreamFull(key, count));
+  }
+
+  @Override
+  public List<Object> xinfoGroups(byte[] key) {
+    return executeCommand(getCommandObjects().xinfoGroups(key));
+  }
+
+  @Override
+  public List<Object> xinfoConsumers(byte[] key, byte[] group) {
+    return executeCommand(getCommandObjects().xinfoConsumers(key, group));
+  }
+
+  @Override
+  public List<Map.Entry<byte[], List<StreamEntryBinary>>> xreadBinary(XReadParams xReadParams,
+      Map<byte[], StreamEntryID> streams) {
+    return executeCommand(getCommandObjects().xreadBinary(xReadParams, streams));
+  }
+
+  @Override
+  public Map<byte[], List<StreamEntryBinary>> xreadBinaryAsMap(XReadParams xReadParams,
+      Map<byte[], StreamEntryID> streams) {
+    return executeCommand(getCommandObjects().xreadBinaryAsMap(xReadParams, streams));
+  }
+
+  @Override
+  public List<Map.Entry<byte[], List<StreamEntryBinary>>> xreadGroupBinary(byte[] groupName,
+      byte[] consumer, XReadGroupParams xReadGroupParams, Map<byte[], StreamEntryID> streams) {
+    return executeCommand(
+      getCommandObjects().xreadGroupBinary(groupName, consumer, xReadGroupParams, streams));
+  }
+
+  @Override
+  public Map<byte[], List<StreamEntryBinary>> xreadGroupBinaryAsMap(byte[] groupName,
+      byte[] consumer, XReadGroupParams xReadGroupParams, Map<byte[], StreamEntryID> streams) {
+    return executeCommand(
+      getCommandObjects().xreadGroupBinaryAsMap(groupName, consumer, xReadGroupParams, streams));
+  }
+
+  // Scripting commands
+  @Override
+  public Object eval(String script) {
+    return executeCommand(getCommandObjects().eval(script));
+  }
+
+  @Override
+  public Object eval(String script, int keyCount, String... params) {
+    return executeCommand(getCommandObjects().eval(script, keyCount, params));
+  }
+
+  @Override
+  public Object eval(String script, List<String> keys, List<String> args) {
+    return executeCommand(getCommandObjects().eval(script, keys, args));
+  }
+
+  @Override
+  public Object evalReadonly(String script, List<String> keys, List<String> args) {
+    return executeCommand(getCommandObjects().evalReadonly(script, keys, args));
+  }
+
+  @Override
+  public Object evalsha(String sha1) {
+    return executeCommand(getCommandObjects().evalsha(sha1));
+  }
+
+  @Override
+  public Object evalsha(String sha1, int keyCount, String... params) {
+    return executeCommand(getCommandObjects().evalsha(sha1, keyCount, params));
+  }
+
+  @Override
+  public Object evalsha(String sha1, List<String> keys, List<String> args) {
+    return executeCommand(getCommandObjects().evalsha(sha1, keys, args));
+  }
+
+  @Override
+  public Object evalshaReadonly(String sha1, List<String> keys, List<String> args) {
+    return executeCommand(getCommandObjects().evalshaReadonly(sha1, keys, args));
+  }
+
+  @Override
+  public Object eval(byte[] script) {
+    return executeCommand(getCommandObjects().eval(script));
+  }
+
+  @Override
+  public Object eval(byte[] script, int keyCount, byte[]... params) {
+    return executeCommand(getCommandObjects().eval(script, keyCount, params));
+  }
+
+  @Override
+  public Object eval(byte[] script, List<byte[]> keys, List<byte[]> args) {
+    return executeCommand(getCommandObjects().eval(script, keys, args));
+  }
+
+  @Override
+  public Object evalReadonly(byte[] script, List<byte[]> keys, List<byte[]> args) {
+    return executeCommand(getCommandObjects().evalReadonly(script, keys, args));
+  }
+
+  @Override
+  public Object evalsha(byte[] sha1) {
+    return executeCommand(getCommandObjects().evalsha(sha1));
+  }
+
+  @Override
+  public Object evalsha(byte[] sha1, int keyCount, byte[]... params) {
+    return executeCommand(getCommandObjects().evalsha(sha1, keyCount, params));
+  }
+
+  @Override
+  public Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args) {
+    return executeCommand(getCommandObjects().evalsha(sha1, keys, args));
+  }
+
+  @Override
+  public Object evalshaReadonly(byte[] sha1, List<byte[]> keys, List<byte[]> args) {
+    return executeCommand(getCommandObjects().evalshaReadonly(sha1, keys, args));
+  }
+
+  @Override
+  public Object fcall(String name, List<String> keys, List<String> args) {
+    return executeCommand(getCommandObjects().fcall(name, keys, args));
+  }
+
+  @Override
+  public Object fcallReadonly(String name, List<String> keys, List<String> args) {
+    return executeCommand(getCommandObjects().fcallReadonly(name, keys, args));
+  }
+
+  @Override
+  public String functionDelete(String libraryName) {
+    return checkAndBroadcastCommand(getCommandObjects().functionDelete(libraryName));
+  }
+
+  @Override
+  public String functionFlush() {
+    return checkAndBroadcastCommand(getCommandObjects().functionFlush());
+  }
+
+  @Override
+  public String functionFlush(FlushMode mode) {
+    return checkAndBroadcastCommand(getCommandObjects().functionFlush(mode));
+  }
+
+  @Override
+  public String functionKill() {
+    return checkAndBroadcastCommand(getCommandObjects().functionKill());
+  }
+
+  @Override
+  public List<LibraryInfo> functionList() {
+    return executeCommand(getCommandObjects().functionList());
+  }
+
+  @Override
+  public List<LibraryInfo> functionList(String libraryNamePattern) {
+    return executeCommand(getCommandObjects().functionList(libraryNamePattern));
+  }
+
+  @Override
+  public List<LibraryInfo> functionListWithCode() {
+    return executeCommand(getCommandObjects().functionListWithCode());
+  }
+
+  @Override
+  public List<LibraryInfo> functionListWithCode(String libraryNamePattern) {
+    return executeCommand(getCommandObjects().functionListWithCode(libraryNamePattern));
+  }
+
+  @Override
+  public String functionLoad(String functionCode) {
+    return checkAndBroadcastCommand(getCommandObjects().functionLoad(functionCode));
+  }
+
+  @Override
+  public String functionLoadReplace(String functionCode) {
+    return checkAndBroadcastCommand(getCommandObjects().functionLoadReplace(functionCode));
+  }
+
+  @Override
+  public FunctionStats functionStats() {
+    return executeCommand(getCommandObjects().functionStats());
+  }
+
+  @Override
+  public Object fcall(byte[] name, List<byte[]> keys, List<byte[]> args) {
+    return executeCommand(getCommandObjects().fcall(name, keys, args));
+  }
+
+  @Override
+  public Object fcallReadonly(byte[] name, List<byte[]> keys, List<byte[]> args) {
+    return executeCommand(getCommandObjects().fcallReadonly(name, keys, args));
+  }
+
+  @Override
+  public String functionDelete(byte[] libraryName) {
+    return checkAndBroadcastCommand(getCommandObjects().functionDelete(libraryName));
+  }
+
+  @Override
+  public byte[] functionDump() {
+    return executeCommand(getCommandObjects().functionDump());
+  }
+
+  @Override
+  public List<Object> functionListBinary() {
+    return executeCommand(getCommandObjects().functionListBinary());
+  }
+
+  @Override
+  public List<Object> functionList(final byte[] libraryNamePattern) {
+    return executeCommand(getCommandObjects().functionList(libraryNamePattern));
+  }
+
+  @Override
+  public List<Object> functionListWithCodeBinary() {
+    return executeCommand(getCommandObjects().functionListWithCodeBinary());
+  }
+
+  @Override
+  public List<Object> functionListWithCode(final byte[] libraryNamePattern) {
+    return executeCommand(getCommandObjects().functionListWithCode(libraryNamePattern));
+  }
+
+  @Override
+  public String functionLoad(byte[] functionCode) {
+    return checkAndBroadcastCommand(getCommandObjects().functionLoad(functionCode));
+  }
+
+  @Override
+  public String functionLoadReplace(byte[] functionCode) {
+    return checkAndBroadcastCommand(getCommandObjects().functionLoadReplace(functionCode));
+  }
+
+  @Override
+  public String functionRestore(byte[] serializedValue) {
+    return checkAndBroadcastCommand(getCommandObjects().functionRestore(serializedValue));
+  }
+
+  @Override
+  public String functionRestore(byte[] serializedValue, FunctionRestorePolicy policy) {
+    return checkAndBroadcastCommand(getCommandObjects().functionRestore(serializedValue, policy));
+  }
+
+  @Override
+  public Object functionStatsBinary() {
+    return executeCommand(getCommandObjects().functionStatsBinary());
+  }
+
+  // Other key commands
+  @Override
+  public Long objectRefcount(String key) {
+    return executeCommand(getCommandObjects().objectRefcount(key));
+  }
+
+  @Override
+  public String objectEncoding(String key) {
+    return executeCommand(getCommandObjects().objectEncoding(key));
+  }
+
+  @Override
+  public Long objectIdletime(String key) {
+    return executeCommand(getCommandObjects().objectIdletime(key));
+  }
+
+  @Override
+  public Long objectFreq(String key) {
+    return executeCommand(getCommandObjects().objectFreq(key));
+  }
+
+  @Override
+  public Long objectRefcount(byte[] key) {
+    return executeCommand(getCommandObjects().objectRefcount(key));
+  }
+
+  @Override
+  public byte[] objectEncoding(byte[] key) {
+    return executeCommand(getCommandObjects().objectEncoding(key));
+  }
+
+  @Override
+  public Long objectIdletime(byte[] key) {
+    return executeCommand(getCommandObjects().objectIdletime(key));
+  }
+
+  @Override
+  public Long objectFreq(byte[] key) {
+    return executeCommand(getCommandObjects().objectFreq(key));
+  }
+
+  @Override
+  public String migrate(String host, int port, String key, int timeout) {
+    return executeCommand(getCommandObjects().migrate(host, port, key, timeout));
+  }
+
+  @Override
+  public String migrate(String host, int port, int timeout, MigrateParams params, String... keys) {
+    return executeCommand(getCommandObjects().migrate(host, port, timeout, params, keys));
+  }
+
+  @Override
+  public String migrate(String host, int port, byte[] key, int timeout) {
+    return executeCommand(getCommandObjects().migrate(host, port, key, timeout));
+  }
+
+  @Override
+  public String migrate(String host, int port, int timeout, MigrateParams params, byte[]... keys) {
+    return executeCommand(getCommandObjects().migrate(host, port, timeout, params, keys));
+  }
+
+  // Sample key commands
+  @Override
+  public long waitReplicas(String sampleKey, int replicas, long timeout) {
+    return executeCommand(getCommandObjects().waitReplicas(sampleKey, replicas, timeout));
+  }
+
+  @Override
+  public long waitReplicas(byte[] sampleKey, int replicas, long timeout) {
+    return executeCommand(getCommandObjects().waitReplicas(sampleKey, replicas, timeout));
+  }
+
+  @Override
+  public KeyValue<Long, Long> waitAOF(String sampleKey, long numLocal, long numReplicas,
+      long timeout) {
+    return executeCommand(getCommandObjects().waitAOF(sampleKey, numLocal, numReplicas, timeout));
+  }
+
+  @Override
+  public KeyValue<Long, Long> waitAOF(byte[] sampleKey, long numLocal, long numReplicas,
+      long timeout) {
+    return executeCommand(getCommandObjects().waitAOF(sampleKey, numLocal, numReplicas, timeout));
+  }
+
+  @Override
+  public Object eval(String script, String sampleKey) {
+    return executeCommand(getCommandObjects().eval(script, sampleKey));
+  }
+
+  @Override
+  public Object evalsha(String sha1, String sampleKey) {
+    return executeCommand(getCommandObjects().evalsha(sha1, sampleKey));
+  }
+
+  @Override
+  public Object eval(byte[] script, byte[] sampleKey) {
+    return executeCommand(getCommandObjects().eval(script, sampleKey));
+  }
+
+  @Override
+  public Object evalsha(byte[] sha1, byte[] sampleKey) {
+    return executeCommand(getCommandObjects().evalsha(sha1, sampleKey));
+  }
+
+  public List<Boolean> scriptExists(List<String> sha1s) {
+    return checkAndBroadcastCommand(getCommandObjects().scriptExists(sha1s));
+  }
+
+  @Override
+  public Boolean scriptExists(String sha1, String sampleKey) {
+    return scriptExists(sampleKey, new String[] { sha1 }).get(0);
+  }
+
+  @Override
+  public Boolean scriptExists(byte[] sha1, byte[] sampleKey) {
+    return scriptExists(sampleKey, new byte[][] { sha1 }).get(0);
+  }
+
+  @Override
+  public List<Boolean> scriptExists(String sampleKey, String... sha1s) {
+    return executeCommand(getCommandObjects().scriptExists(sampleKey, sha1s));
+  }
+
+  @Override
+  public List<Boolean> scriptExists(byte[] sampleKey, byte[]... sha1s) {
+    return executeCommand(getCommandObjects().scriptExists(sampleKey, sha1s));
+  }
+
+  public String scriptLoad(String script) {
+    return checkAndBroadcastCommand(getCommandObjects().scriptLoad(script));
+  }
+
+  @Override
+  public String scriptLoad(String script, String sampleKey) {
+    return executeCommand(getCommandObjects().scriptLoad(script, sampleKey));
+  }
+
+  public String scriptFlush() {
+    return checkAndBroadcastCommand(getCommandObjects().scriptFlush());
+  }
+
+  @Override
+  public String scriptFlush(String sampleKey) {
+    return executeCommand(getCommandObjects().scriptFlush(sampleKey));
+  }
+
+  @Override
+  public String scriptFlush(String sampleKey, FlushMode flushMode) {
+    return executeCommand(getCommandObjects().scriptFlush(sampleKey, flushMode));
+  }
+
+  public String scriptKill() {
+    return checkAndBroadcastCommand(getCommandObjects().scriptKill());
+  }
+
+  @Override
+  public String scriptKill(String sampleKey) {
+    return executeCommand(getCommandObjects().scriptKill(sampleKey));
+  }
+
+  @Override
+  public byte[] scriptLoad(byte[] script, byte[] sampleKey) {
+    return executeCommand(getCommandObjects().scriptLoad(script, sampleKey));
+  }
+
+  @Override
+  public String scriptFlush(byte[] sampleKey) {
+    return executeCommand(getCommandObjects().scriptFlush(sampleKey));
+  }
+
+  @Override
+  public String scriptFlush(byte[] sampleKey, FlushMode flushMode) {
+    return executeCommand(getCommandObjects().scriptFlush(sampleKey, flushMode));
+  }
+
+  @Override
+  public String scriptKill(byte[] sampleKey) {
+    return executeCommand(getCommandObjects().scriptKill(sampleKey));
+  }
+
+  public String slowlogReset() {
+    return checkAndBroadcastCommand(getCommandObjects().slowlogReset());
+  }
+
+  // Random node commands
+  public long publish(String channel, String message) {
+    return executeCommand(getCommandObjects().publish(channel, message));
+  }
+
+  public long publish(byte[] channel, byte[] message) {
+    return executeCommand(getCommandObjects().publish(channel, message));
+  }
+
+  // RediSearch commands
+  public long hsetObject(String key, String field, Object value) {
+    return executeCommand(getCommandObjects().hsetObject(key, field, value));
+  }
+
+  public long hsetObject(String key, Map<String, Object> hash) {
+    return executeCommand(getCommandObjects().hsetObject(key, hash));
+  }
+
+  @Override
+  public String ftCreate(String indexName, IndexOptions indexOptions, Schema schema) {
+    return checkAndBroadcastCommand(getCommandObjects().ftCreate(indexName, indexOptions, schema));
+  }
+
+  @Override
+  public String ftCreate(String indexName, FTCreateParams createParams,
+      Iterable<SchemaField> schemaFields) {
+    return checkAndBroadcastCommand(
+      getCommandObjects().ftCreate(indexName, createParams, schemaFields));
+  }
+
+  @Override
+  public String ftAlter(String indexName, Schema schema) {
+    return checkAndBroadcastCommand(getCommandObjects().ftAlter(indexName, schema));
+  }
+
+  @Override
+  public String ftAlter(String indexName, Iterable<SchemaField> schemaFields) {
+    return checkAndBroadcastCommand(getCommandObjects().ftAlter(indexName, schemaFields));
+  }
+
+  @Override
+  public String ftAliasAdd(String aliasName, String indexName) {
+    return checkAndBroadcastCommand(getCommandObjects().ftAliasAdd(aliasName, indexName));
+  }
+
+  @Override
+  public String ftAliasUpdate(String aliasName, String indexName) {
+    return checkAndBroadcastCommand(getCommandObjects().ftAliasUpdate(aliasName, indexName));
+  }
+
+  @Override
+  public String ftAliasDel(String aliasName) {
+    return checkAndBroadcastCommand(getCommandObjects().ftAliasDel(aliasName));
+  }
+
+  @Override
+  public String ftDropIndex(String indexName) {
+    return checkAndBroadcastCommand(getCommandObjects().ftDropIndex(indexName));
+  }
+
+  @Override
+  public String ftDropIndexDD(String indexName) {
+    return checkAndBroadcastCommand(getCommandObjects().ftDropIndexDD(indexName));
+  }
+
+  @Override
+  public SearchResult ftSearch(String indexName, String query) {
+    return executeCommand(getCommandObjects().ftSearch(indexName, query));
+  }
+
+  @Override
+  public SearchResult ftSearch(String indexName, String query, FTSearchParams params) {
+    return executeCommand(getCommandObjects().ftSearch(indexName, query, params));
+  }
+
+  @Override
+  public SearchResult ftSearch(String indexName, Query query) {
+    return executeCommand(getCommandObjects().ftSearch(indexName, query));
+  }
+
+  /**
+   * {@link FTSearchParams#limit(int, int)} will be ignored.
+   * @param batchSize batch size
+   * @param indexName index name
+   * @param query query
+   * @param params limit will be ignored
+   * @return search iteration
+   */
+  public FtSearchIteration ftSearchIteration(int batchSize, String indexName, String query,
+      FTSearchParams params) {
+    return new FtSearchIteration(getConnectionProvider(), getCommandObjects().getProtocol(),
+        batchSize, indexName, query, params);
+  }
+
+  /**
+   * {@link Query#limit(java.lang.Integer, java.lang.Integer)} will be ignored.
+   * @param batchSize batch size
+   * @param indexName index name
+   * @param query limit will be ignored
+   * @return search iteration
+   */
+  public FtSearchIteration ftSearchIteration(int batchSize, String indexName, Query query) {
+    return new FtSearchIteration(getConnectionProvider(), getCommandObjects().getProtocol(),
+        batchSize, indexName, query);
+  }
+
+  @Override
+  public String ftExplain(String indexName, Query query) {
+    return executeCommand(getCommandObjects().ftExplain(indexName, query));
+  }
+
+  @Override
+  public List<String> ftExplainCLI(String indexName, Query query) {
+    return executeCommand(getCommandObjects().ftExplainCLI(indexName, query));
+  }
+
+  @Override
+  public AggregationResult ftAggregate(String indexName, AggregationBuilder aggr) {
+    return executeCommand(getCommandObjects().ftAggregate(indexName, aggr));
+  }
+
+  /**
+   * {@link AggregationBuilder#cursor(int, long) CURSOR} must be set.
+   * @param indexName index name
+   * @param aggr cursor must be set
+   * @return aggregate iteration
+   */
+  public FtAggregateIteration ftAggregateIteration(String indexName, AggregationBuilder aggr) {
+    return new FtAggregateIteration(getConnectionProvider(), indexName, aggr);
+  }
+
+  @Override
+  public AggregationResult ftCursorRead(String indexName, long cursorId, int count) {
+    return executeCommand(getCommandObjects().ftCursorRead(indexName, cursorId, count));
+  }
+
+  @Override
+  public String ftCursorDel(String indexName, long cursorId) {
+    return executeCommand(getCommandObjects().ftCursorDel(indexName, cursorId));
+  }
+
+  @Override
+  public Map.Entry<AggregationResult, ProfilingInfo> ftProfileAggregate(String indexName,
+      FTProfileParams profileParams, AggregationBuilder aggr) {
+    return executeCommand(getCommandObjects().ftProfileAggregate(indexName, profileParams, aggr));
+  }
+
+  @Override
+  public Map.Entry<SearchResult, ProfilingInfo> ftProfileSearch(String indexName,
+      FTProfileParams profileParams, Query query) {
+    return executeCommand(getCommandObjects().ftProfileSearch(indexName, profileParams, query));
+  }
+
+  @Override
+  public Map.Entry<SearchResult, ProfilingInfo> ftProfileSearch(String indexName,
+      FTProfileParams profileParams, String query, FTSearchParams searchParams) {
+    return executeCommand(
+      getCommandObjects().ftProfileSearch(indexName, profileParams, query, searchParams));
+  }
+
+  @Override
+  public String ftSynUpdate(String indexName, String synonymGroupId, String... terms) {
+    return executeCommand(getCommandObjects().ftSynUpdate(indexName, synonymGroupId, terms));
+  }
+
+  @Override
+  public Map<String, List<String>> ftSynDump(String indexName) {
+    return executeCommand(getCommandObjects().ftSynDump(indexName));
+  }
+
+  @Override
+  public long ftDictAdd(String dictionary, String... terms) {
+    return executeCommand(getCommandObjects().ftDictAdd(dictionary, terms));
+  }
+
+  @Override
+  public long ftDictDel(String dictionary, String... terms) {
+    return executeCommand(getCommandObjects().ftDictDel(dictionary, terms));
+  }
+
+  @Override
+  public Set<String> ftDictDump(String dictionary) {
+    return executeCommand(getCommandObjects().ftDictDump(dictionary));
+  }
+
+  @Override
+  public long ftDictAddBySampleKey(String indexName, String dictionary, String... terms) {
+    return executeCommand(getCommandObjects().ftDictAddBySampleKey(indexName, dictionary, terms));
+  }
+
+  @Override
+  public long ftDictDelBySampleKey(String indexName, String dictionary, String... terms) {
+    return executeCommand(getCommandObjects().ftDictDelBySampleKey(indexName, dictionary, terms));
+  }
+
+  @Override
+  public Set<String> ftDictDumpBySampleKey(String indexName, String dictionary) {
+    return executeCommand(getCommandObjects().ftDictDumpBySampleKey(indexName, dictionary));
+  }
+
+  @Override
+  public Map<String, Map<String, Double>> ftSpellCheck(String index, String query) {
+    return executeCommand(getCommandObjects().ftSpellCheck(index, query));
+  }
+
+  @Override
+  public Map<String, Map<String, Double>> ftSpellCheck(String index, String query,
+      FTSpellCheckParams spellCheckParams) {
+    return executeCommand(getCommandObjects().ftSpellCheck(index, query, spellCheckParams));
+  }
+
+  @Override
+  public Map<String, Object> ftInfo(String indexName) {
+    return executeCommand(getCommandObjects().ftInfo(indexName));
+  }
+
+  @Override
+  public Set<String> ftTagVals(String indexName, String fieldName) {
+    return executeCommand(getCommandObjects().ftTagVals(indexName, fieldName));
+  }
+
+  @Override
+  public long ftSugAdd(String key, String string, double score) {
+    return executeCommand(getCommandObjects().ftSugAdd(key, string, score));
+  }
+
+  @Override
+  public long ftSugAddIncr(String key, String string, double score) {
+    return executeCommand(getCommandObjects().ftSugAddIncr(key, string, score));
+  }
+
+  @Override
+  public List<String> ftSugGet(String key, String prefix) {
+    return executeCommand(getCommandObjects().ftSugGet(key, prefix));
+  }
+
+  @Override
+  public List<String> ftSugGet(String key, String prefix, boolean fuzzy, int max) {
+    return executeCommand(getCommandObjects().ftSugGet(key, prefix, fuzzy, max));
+  }
+
+  @Override
+  public List<Tuple> ftSugGetWithScores(String key, String prefix) {
+    return executeCommand(getCommandObjects().ftSugGetWithScores(key, prefix));
+  }
+
+  @Override
+  public List<Tuple> ftSugGetWithScores(String key, String prefix, boolean fuzzy, int max) {
+    return executeCommand(getCommandObjects().ftSugGetWithScores(key, prefix, fuzzy, max));
+  }
+
+  @Override
+  public boolean ftSugDel(String key, String string) {
+    return executeCommand(getCommandObjects().ftSugDel(key, string));
+  }
+
+  @Override
+  public long ftSugLen(String key) {
+    return executeCommand(getCommandObjects().ftSugLen(key));
+  }
+
+  @Override
+  public Set<String> ftList() {
+    return executeCommand(getCommandObjects().ftList());
+  }
+
+  // RedisJSON commands
+  @Override
+  public String jsonSet(String key, Path2 path, Object object) {
+    return executeCommand(getCommandObjects().jsonSet(key, path, object));
+  }
+
+  @Override
+  public String jsonSetWithEscape(String key, Path2 path, Object object) {
+    return executeCommand(getCommandObjects().jsonSetWithEscape(key, path, object));
+  }
+
+  @Override
+  public String jsonSet(String key, Path2 path, Object pojo, JsonSetParams params) {
+    return executeCommand(getCommandObjects().jsonSet(key, path, pojo, params));
+  }
+
+  @Override
+  public String jsonSetWithEscape(String key, Path2 path, Object pojo, JsonSetParams params) {
+    return executeCommand(getCommandObjects().jsonSetWithEscape(key, path, pojo, params));
+  }
+
+  @Override
+  public String jsonMerge(String key, Path2 path, Object object) {
+    return executeCommand(getCommandObjects().jsonMerge(key, path, object));
+  }
+
+  @Override
+  public Object jsonGet(String key) {
+    return executeCommand(getCommandObjects().jsonGet(key));
+  }
+
+  @Override
+  public Object jsonGet(String key, Path2... paths) {
+    return executeCommand(getCommandObjects().jsonGet(key, paths));
+  }
+
+  @Override
+  public List<JSONArray> jsonMGet(Path2 path, String... keys) {
+    return executeCommand(getCommandObjects().jsonMGet(path, keys));
+  }
+
+  @Override
+  public long jsonDel(String key) {
+    return executeCommand(getCommandObjects().jsonDel(key));
+  }
+
+  @Override
+  public long jsonDel(String key, Path2 path) {
+    return executeCommand(getCommandObjects().jsonDel(key, path));
+  }
+
+  @Override
+  public long jsonClear(String key) {
+    return executeCommand(getCommandObjects().jsonClear(key));
+  }
+
+  @Override
+  public long jsonClear(String key, Path2 path) {
+    return executeCommand(getCommandObjects().jsonClear(key, path));
+  }
+
+  @Override
+  public List<Boolean> jsonToggle(String key, Path2 path) {
+    return executeCommand(getCommandObjects().jsonToggle(key, path));
+  }
+
+  @Override
+  public List<Class<?>> jsonType(String key, Path2 path) {
+    return executeCommand(getCommandObjects().jsonType(key, path));
+  }
+
+  @Override
+  public List<Long> jsonStrAppend(String key, Path2 path, Object string) {
+    return executeCommand(getCommandObjects().jsonStrAppend(key, path, string));
+  }
+
+  @Override
+  public List<Long> jsonStrLen(String key, Path2 path) {
+    return executeCommand(getCommandObjects().jsonStrLen(key, path));
+  }
+
+  @Override
+  public Object jsonNumIncrBy(String key, Path2 path, double value) {
+    return executeCommand(getCommandObjects().jsonNumIncrBy(key, path, value));
+  }
+
+  @Override
+  public List<Long> jsonArrAppend(String key, Path2 path, Object... objects) {
+    return executeCommand(getCommandObjects().jsonArrAppend(key, path, objects));
+  }
+
+  @Override
+  public List<Long> jsonArrAppendWithEscape(String key, Path2 path, Object... objects) {
+    return executeCommand(getCommandObjects().jsonArrAppendWithEscape(key, path, objects));
+  }
+
+  @Override
+  public List<Long> jsonArrIndex(String key, Path2 path, Object scalar) {
+    return executeCommand(getCommandObjects().jsonArrIndex(key, path, scalar));
+  }
+
+  @Override
+  public List<Long> jsonArrIndexWithEscape(String key, Path2 path, Object scalar) {
+    return executeCommand(getCommandObjects().jsonArrIndexWithEscape(key, path, scalar));
+  }
+
+  @Override
+  public List<Long> jsonArrInsert(String key, Path2 path, int index, Object... objects) {
+    return executeCommand(getCommandObjects().jsonArrInsert(key, path, index, objects));
+  }
+
+  @Override
+  public List<Long> jsonArrInsertWithEscape(String key, Path2 path, int index, Object... objects) {
+    return executeCommand(getCommandObjects().jsonArrInsertWithEscape(key, path, index, objects));
+  }
+
+  @Override
+  public List<Object> jsonArrPop(String key, Path2 path) {
+    return executeCommand(getCommandObjects().jsonArrPop(key, path));
+  }
+
+  @Override
+  public List<Object> jsonArrPop(String key, Path2 path, int index) {
+    return executeCommand(getCommandObjects().jsonArrPop(key, path, index));
+  }
+
+  @Override
+  public List<Long> jsonArrLen(String key, Path2 path) {
+    return executeCommand(getCommandObjects().jsonArrLen(key, path));
+  }
+
+  @Override
+  public List<Long> jsonArrTrim(String key, Path2 path, int start, int stop) {
+    return executeCommand(getCommandObjects().jsonArrTrim(key, path, start, stop));
+  }
+
+  @Override
+  public List<Long> jsonObjLen(String key, Path2 path) {
+    return executeCommand(getCommandObjects().jsonObjLen(key, path));
+  }
+
+  @Override
+  public List<List<String>> jsonObjKeys(String key, Path2 path) {
+    return executeCommand(getCommandObjects().jsonObjKeys(key, path));
+  }
+
+  @Override
+  public List<Long> jsonDebugMemory(String key, Path2 path) {
+    return executeCommand(getCommandObjects().jsonDebugMemory(key, path));
+  }
+
+  // RedisTimeSeries commands
+  @Override
+  public String tsCreate(String key) {
+    return executeCommand(getCommandObjects().tsCreate(key));
+  }
+
+  @Override
+  public String tsCreate(String key, TSCreateParams createParams) {
+    return executeCommand(getCommandObjects().tsCreate(key, createParams));
+  }
+
+  @Override
+  public long tsDel(String key, long fromTimestamp, long toTimestamp) {
+    return executeCommand(getCommandObjects().tsDel(key, fromTimestamp, toTimestamp));
+  }
+
+  @Override
+  public String tsAlter(String key, TSAlterParams alterParams) {
+    return executeCommand(getCommandObjects().tsAlter(key, alterParams));
+  }
+
+  @Override
+  public long tsAdd(String key, double value) {
+    return executeCommand(getCommandObjects().tsAdd(key, value));
+  }
+
+  @Override
+  public long tsAdd(String key, long timestamp, double value) {
+    return executeCommand(getCommandObjects().tsAdd(key, timestamp, value));
+  }
+
+  @Override
+  public long tsAdd(String key, long timestamp, double value, TSCreateParams createParams) {
+    return executeCommand(getCommandObjects().tsAdd(key, timestamp, value, createParams));
+  }
+
+  @Override
+  public long tsAdd(String key, long timestamp, double value, TSAddParams addParams) {
+    return executeCommand(getCommandObjects().tsAdd(key, timestamp, value, addParams));
+  }
+
+  @Override
+  public List<Long> tsMAdd(Map.Entry<String, TSElement>... entries) {
+    return executeCommand(getCommandObjects().tsMAdd(entries));
+  }
+
+  @Override
+  public long tsIncrBy(String key, double value) {
+    return executeCommand(getCommandObjects().tsIncrBy(key, value));
+  }
+
+  @Override
+  public long tsIncrBy(String key, double value, long timestamp) {
+    return executeCommand(getCommandObjects().tsIncrBy(key, value, timestamp));
+  }
+
+  @Override
+  public long tsIncrBy(String key, double addend, TSIncrByParams incrByParams) {
+    return executeCommand(getCommandObjects().tsIncrBy(key, addend, incrByParams));
+  }
+
+  @Override
+  public long tsDecrBy(String key, double value) {
+    return executeCommand(getCommandObjects().tsDecrBy(key, value));
+  }
+
+  @Override
+  public long tsDecrBy(String key, double value, long timestamp) {
+    return executeCommand(getCommandObjects().tsDecrBy(key, value, timestamp));
+  }
+
+  @Override
+  public long tsDecrBy(String key, double subtrahend, TSDecrByParams decrByParams) {
+    return executeCommand(getCommandObjects().tsDecrBy(key, subtrahend, decrByParams));
+  }
+
+  @Override
+  public List<TSElement> tsRange(String key, long fromTimestamp, long toTimestamp) {
+    return executeCommand(getCommandObjects().tsRange(key, fromTimestamp, toTimestamp));
+  }
+
+  @Override
+  public List<TSElement> tsRange(String key, TSRangeParams rangeParams) {
+    return executeCommand(getCommandObjects().tsRange(key, rangeParams));
+  }
+
+  @Override
+  public List<TSElement> tsRevRange(String key, long fromTimestamp, long toTimestamp) {
+    return executeCommand(getCommandObjects().tsRevRange(key, fromTimestamp, toTimestamp));
+  }
+
+  @Override
+  public List<TSElement> tsRevRange(String key, TSRangeParams rangeParams) {
+    return executeCommand(getCommandObjects().tsRevRange(key, rangeParams));
+  }
+
+  @Override
+  public Map<String, TSMRangeElements> tsMRange(long fromTimestamp, long toTimestamp,
+      String... filters) {
+    return executeCommand(getCommandObjects().tsMRange(fromTimestamp, toTimestamp, filters));
+  }
+
+  @Override
+  public Map<String, TSMRangeElements> tsMRange(TSMRangeParams multiRangeParams) {
+    return executeCommand(getCommandObjects().tsMRange(multiRangeParams));
+  }
+
+  @Override
+  public Map<String, TSMRangeElements> tsMRevRange(long fromTimestamp, long toTimestamp,
+      String... filters) {
+    return executeCommand(getCommandObjects().tsMRevRange(fromTimestamp, toTimestamp, filters));
+  }
+
+  @Override
+  public Map<String, TSMRangeElements> tsMRevRange(TSMRangeParams multiRangeParams) {
+    return executeCommand(getCommandObjects().tsMRevRange(multiRangeParams));
+  }
+
+  @Override
+  public TSElement tsGet(String key) {
+    return executeCommand(getCommandObjects().tsGet(key));
+  }
+
+  @Override
+  public TSElement tsGet(String key, TSGetParams getParams) {
+    return executeCommand(getCommandObjects().tsGet(key, getParams));
+  }
+
+  @Override
+  public Map<String, TSMGetElement> tsMGet(TSMGetParams multiGetParams, String... filters) {
+    return executeCommand(getCommandObjects().tsMGet(multiGetParams, filters));
+  }
+
+  @Override
+  public String tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType,
+      long timeBucket) {
+    return executeCommand(
+      getCommandObjects().tsCreateRule(sourceKey, destKey, aggregationType, timeBucket));
+  }
+
+  @Override
+  public String tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType,
+      long bucketDuration, long alignTimestamp) {
+    return executeCommand(getCommandObjects().tsCreateRule(sourceKey, destKey, aggregationType,
+      bucketDuration, alignTimestamp));
+  }
+
+  @Override
+  public String tsDeleteRule(String sourceKey, String destKey) {
+    return executeCommand(getCommandObjects().tsDeleteRule(sourceKey, destKey));
+  }
+
+  @Override
+  public List<String> tsQueryIndex(String... filters) {
+    return executeCommand(getCommandObjects().tsQueryIndex(filters));
+  }
+
+  @Override
+  public TSInfo tsInfo(String key) {
+    return executeCommand(getCommandObjects().tsInfo(key));
+  }
+
+  @Override
+  public TSInfo tsInfoDebug(String key) {
+    return executeCommand(getCommandObjects().tsInfoDebug(key));
+  }
+
+  // RedisBloom commands
+  @Override
+  public String bfReserve(String key, double errorRate, long capacity) {
+    return executeCommand(getCommandObjects().bfReserve(key, errorRate, capacity));
+  }
+
+  @Override
+  public String bfReserve(String key, double errorRate, long capacity,
+      BFReserveParams reserveParams) {
+    return executeCommand(getCommandObjects().bfReserve(key, errorRate, capacity, reserveParams));
+  }
+
+  @Override
+  public boolean bfAdd(String key, String item) {
+    return executeCommand(getCommandObjects().bfAdd(key, item));
+  }
+
+  @Override
+  public List<Boolean> bfMAdd(String key, String... items) {
+    return executeCommand(getCommandObjects().bfMAdd(key, items));
+  }
+
+  @Override
+  public List<Boolean> bfInsert(String key, String... items) {
+    return executeCommand(getCommandObjects().bfInsert(key, items));
+  }
+
+  @Override
+  public List<Boolean> bfInsert(String key, BFInsertParams insertParams, String... items) {
+    return executeCommand(getCommandObjects().bfInsert(key, insertParams, items));
+  }
+
+  @Override
+  public boolean bfExists(String key, String item) {
+    return executeCommand(getCommandObjects().bfExists(key, item));
+  }
+
+  @Override
+  public List<Boolean> bfMExists(String key, String... items) {
+    return executeCommand(getCommandObjects().bfMExists(key, items));
+  }
+
+  @Override
+  public Map.Entry<Long, byte[]> bfScanDump(String key, long iterator) {
+    return executeCommand(getCommandObjects().bfScanDump(key, iterator));
+  }
+
+  @Override
+  public String bfLoadChunk(String key, long iterator, byte[] data) {
+    return executeCommand(getCommandObjects().bfLoadChunk(key, iterator, data));
+  }
+
+  @Override
+  public long bfCard(String key) {
+    return executeCommand(getCommandObjects().bfCard(key));
+  }
+
+  @Override
+  public Map<String, Object> bfInfo(String key) {
+    return executeCommand(getCommandObjects().bfInfo(key));
+  }
+
+  @Override
+  public String cfReserve(String key, long capacity) {
+    return executeCommand(getCommandObjects().cfReserve(key, capacity));
+  }
+
+  @Override
+  public String cfReserve(String key, long capacity, CFReserveParams reserveParams) {
+    return executeCommand(getCommandObjects().cfReserve(key, capacity, reserveParams));
+  }
+
+  @Override
+  public boolean cfAdd(String key, String item) {
+    return executeCommand(getCommandObjects().cfAdd(key, item));
+  }
+
+  @Override
+  public boolean cfAddNx(String key, String item) {
+    return executeCommand(getCommandObjects().cfAddNx(key, item));
+  }
+
+  @Override
+  public List<Boolean> cfInsert(String key, String... items) {
+    return executeCommand(getCommandObjects().cfInsert(key, items));
+  }
+
+  @Override
+  public List<Boolean> cfInsert(String key, CFInsertParams insertParams, String... items) {
+    return executeCommand(getCommandObjects().cfInsert(key, insertParams, items));
+  }
+
+  @Override
+  public List<Boolean> cfInsertNx(String key, String... items) {
+    return executeCommand(getCommandObjects().cfInsertNx(key, items));
+  }
+
+  @Override
+  public List<Boolean> cfInsertNx(String key, CFInsertParams insertParams, String... items) {
+    return executeCommand(getCommandObjects().cfInsertNx(key, insertParams, items));
+  }
+
+  @Override
+  public boolean cfExists(String key, String item) {
+    return executeCommand(getCommandObjects().cfExists(key, item));
+  }
+
+  @Override
+  public List<Boolean> cfMExists(String key, String... items) {
+    return executeCommand(getCommandObjects().cfMExists(key, items));
+  }
+
+  @Override
+  public boolean cfDel(String key, String item) {
+    return executeCommand(getCommandObjects().cfDel(key, item));
+  }
+
+  @Override
+  public long cfCount(String key, String item) {
+    return executeCommand(getCommandObjects().cfCount(key, item));
+  }
+
+  @Override
+  public Map.Entry<Long, byte[]> cfScanDump(String key, long iterator) {
+    return executeCommand(getCommandObjects().cfScanDump(key, iterator));
+  }
+
+  @Override
+  public String cfLoadChunk(String key, long iterator, byte[] data) {
+    return executeCommand(getCommandObjects().cfLoadChunk(key, iterator, data));
+  }
+
+  @Override
+  public Map<String, Object> cfInfo(String key) {
+    return executeCommand(getCommandObjects().cfInfo(key));
+  }
+
+  @Override
+  public String cmsInitByDim(String key, long width, long depth) {
+    return executeCommand(getCommandObjects().cmsInitByDim(key, width, depth));
+  }
+
+  @Override
+  public String cmsInitByProb(String key, double error, double probability) {
+    return executeCommand(getCommandObjects().cmsInitByProb(key, error, probability));
+  }
+
+  @Override
+  public List<Long> cmsIncrBy(String key, Map<String, Long> itemIncrements) {
+    return executeCommand(getCommandObjects().cmsIncrBy(key, itemIncrements));
+  }
+
+  @Override
+  public List<Long> cmsQuery(String key, String... items) {
+    return executeCommand(getCommandObjects().cmsQuery(key, items));
+  }
+
+  @Override
+  public String cmsMerge(String destKey, String... keys) {
+    return executeCommand(getCommandObjects().cmsMerge(destKey, keys));
+  }
+
+  @Override
+  public String cmsMerge(String destKey, Map<String, Long> keysAndWeights) {
+    return executeCommand(getCommandObjects().cmsMerge(destKey, keysAndWeights));
+  }
+
+  @Override
+  public Map<String, Object> cmsInfo(String key) {
+    return executeCommand(getCommandObjects().cmsInfo(key));
+  }
+
+  @Override
+  public String topkReserve(String key, long topk) {
+    return executeCommand(getCommandObjects().topkReserve(key, topk));
+  }
+
+  @Override
+  public String topkReserve(String key, long topk, long width, long depth, double decay) {
+    return executeCommand(getCommandObjects().topkReserve(key, topk, width, depth, decay));
+  }
+
+  @Override
+  public List<String> topkAdd(String key, String... items) {
+    return executeCommand(getCommandObjects().topkAdd(key, items));
+  }
+
+  @Override
+  public List<String> topkIncrBy(String key, Map<String, Long> itemIncrements) {
+    return executeCommand(getCommandObjects().topkIncrBy(key, itemIncrements));
+  }
+
+  @Override
+  public List<Boolean> topkQuery(String key, String... items) {
+    return executeCommand(getCommandObjects().topkQuery(key, items));
+  }
+
+  @Override
+  public List<String> topkList(String key) {
+    return executeCommand(getCommandObjects().topkList(key));
+  }
+
+  @Override
+  public Map<String, Long> topkListWithCount(String key) {
+    return executeCommand(getCommandObjects().topkListWithCount(key));
+  }
+
+  @Override
+  public Map<String, Object> topkInfo(String key) {
+    return executeCommand(getCommandObjects().topkInfo(key));
+  }
+
+  @Override
+  public String tdigestCreate(String key) {
+    return executeCommand(getCommandObjects().tdigestCreate(key));
+  }
+
+  @Override
+  public String tdigestCreate(String key, int compression) {
+    return executeCommand(getCommandObjects().tdigestCreate(key, compression));
+  }
+
+  @Override
+  public String tdigestReset(String key) {
+    return executeCommand(getCommandObjects().tdigestReset(key));
+  }
+
+  @Override
+  public String tdigestMerge(String destinationKey, String... sourceKeys) {
+    return executeCommand(getCommandObjects().tdigestMerge(destinationKey, sourceKeys));
+  }
+
+  @Override
+  public String tdigestMerge(TDigestMergeParams mergeParams, String destinationKey,
+      String... sourceKeys) {
+    return executeCommand(
+      getCommandObjects().tdigestMerge(mergeParams, destinationKey, sourceKeys));
+  }
+
+  @Override
+  public Map<String, Object> tdigestInfo(String key) {
+    return executeCommand(getCommandObjects().tdigestInfo(key));
+  }
+
+  @Override
+  public String tdigestAdd(String key, double... values) {
+    return executeCommand(getCommandObjects().tdigestAdd(key, values));
+  }
+
+  @Override
+  public List<Double> tdigestCDF(String key, double... values) {
+    return executeCommand(getCommandObjects().tdigestCDF(key, values));
+  }
+
+  @Override
+  public List<Double> tdigestQuantile(String key, double... quantiles) {
+    return executeCommand(getCommandObjects().tdigestQuantile(key, quantiles));
+  }
+
+  @Override
+  public double tdigestMin(String key) {
+    return executeCommand(getCommandObjects().tdigestMin(key));
+  }
+
+  @Override
+  public double tdigestMax(String key) {
+    return executeCommand(getCommandObjects().tdigestMax(key));
+  }
+
+  @Override
+  public double tdigestTrimmedMean(String key, double lowCutQuantile, double highCutQuantile) {
+    return executeCommand(
+      getCommandObjects().tdigestTrimmedMean(key, lowCutQuantile, highCutQuantile));
+  }
+
+  @Override
+  public List<Long> tdigestRank(String key, double... values) {
+    return executeCommand(getCommandObjects().tdigestRank(key, values));
+  }
+
+  @Override
+  public List<Long> tdigestRevRank(String key, double... values) {
+    return executeCommand(getCommandObjects().tdigestRevRank(key, values));
+  }
+
+  @Override
+  public List<Double> tdigestByRank(String key, long... ranks) {
+    return executeCommand(getCommandObjects().tdigestByRank(key, ranks));
+  }
+
+  @Override
+  public List<Double> tdigestByRevRank(String key, long... ranks) {
+    return executeCommand(getCommandObjects().tdigestByRevRank(key, ranks));
+  }
+}
diff --git a/src/main/java/redis/clients/jedis/CommandObjects.java b/src/main/java/redis/clients/jedis/CommandObjects.java
index ea4930f894..861fe961cb 100644
--- a/src/main/java/redis/clients/jedis/CommandObjects.java
+++ b/src/main/java/redis/clients/jedis/CommandObjects.java
@@ -51,7 +51,7 @@ protected RedisProtocol getProtocol() {
   private JedisBroadcastAndRoundRobinConfig broadcastAndRoundRobinConfig = null;
   private Lock mapperLock = new ReentrantLock(true);    
   private volatile JsonObjectMapper jsonObjectMapper;
-  private final AtomicInteger searchDialect = new AtomicInteger(2); // DEFAULT_SEARCH_DIALECT = 2;
+  private final AtomicInteger searchDialect = new AtomicInteger(SearchProtocol.DEFAULT_DIALECT);
 
   @Experimental
   void setKeyArgumentPreProcessor(CommandKeyArgumentPreProcessor keyPreProcessor) {
diff --git a/src/main/java/redis/clients/jedis/Jedis.java b/src/main/java/redis/clients/jedis/Jedis.java
index e19a4fa619..d3f1fc4447 100644
--- a/src/main/java/redis/clients/jedis/Jedis.java
+++ b/src/main/java/redis/clients/jedis/Jedis.java
@@ -886,7 +886,6 @@ public long move(final byte[] key, final int dbIndex) {
    * @deprecated Use {@link Jedis#setGet(byte[], byte[])}.
    */
   @Deprecated
-  @Override
   public byte[] getSet(final byte[] key, final byte[] value) {
     checkIsInMultiOrPipeline();
     return connection.executeCommand(commandObjects.getSet(key, value));
@@ -2738,7 +2737,6 @@ public List<Tuple> zdiffWithScores(final byte[]... keys) {
     return connection.executeCommand(commandObjects.zdiffWithScores(keys));
   }
 
-  @Override
   @Deprecated
   public long zdiffStore(final byte[] dstkey, final byte[]... keys) {
     checkIsInMultiOrPipeline();
@@ -4777,7 +4775,6 @@ public List<Long> hpersist(byte[] key, byte[]... fields) {
    *     parsing.
    */
   @Deprecated
-  @Override
   public List<Object> xread(XReadParams xReadParams, Entry<byte[], byte[]>... streams) {
     checkIsInMultiOrPipeline();
     return connection.executeCommand(commandObjects.xread(xReadParams, streams));
@@ -4789,7 +4786,6 @@ public List<Object> xread(XReadParams xReadParams, Entry<byte[], byte[]>... stre
    *     {@link #xreadGroupBinaryAsMap(byte[], byte[], XReadGroupParams, Map)} instead.
    */
   @Deprecated
-  @Override
   public List<Object> xreadGroup(byte[] groupName, byte[] consumer,
       XReadGroupParams xReadGroupParams, Entry<byte[], byte[]>... streams) {
     checkIsInMultiOrPipeline();
@@ -5476,7 +5472,6 @@ public long move(final String key, final int dbIndex) {
    * @deprecated Use {@link Jedis#setGet(java.lang.String, java.lang.String)}.
    */
   @Deprecated
-  @Override
   public String getSet(final String key, final String value) {
     checkIsInMultiOrPipeline();
     return connection.executeCommand(commandObjects.getSet(key, value));
@@ -6646,7 +6641,6 @@ public List<Tuple> zdiffWithScores(String... keys) {
     return connection.executeCommand(commandObjects.zdiffWithScores(keys));
   }
 
-  @Override
   @Deprecated
   public long zdiffStore(final String dstkey, final String... keys) {
     checkIsInMultiOrPipeline();
@@ -9008,7 +9002,6 @@ public String clusterReplicate(final String nodeId) {
     return connection.getStatusCodeReply();
   }
 
-  @Override
   @Deprecated
   public List<String> clusterSlaves(final String nodeId) {
     checkIsInMultiOrPipeline();
@@ -9037,7 +9030,6 @@ public String clusterFailover(ClusterFailoverOption failoverOption) {
     return connection.getStatusCodeReply();
   }
 
-  @Override
   @Deprecated
   public List<Object> clusterSlots() {
     checkIsInMultiOrPipeline();
diff --git a/src/main/java/redis/clients/jedis/RedisClient.java b/src/main/java/redis/clients/jedis/RedisClient.java
new file mode 100644
index 0000000000..fbdc7b8ed0
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/RedisClient.java
@@ -0,0 +1,343 @@
+package redis.clients.jedis;
+
+import java.net.URI;
+
+import redis.clients.jedis.csc.Cache;
+import redis.clients.jedis.executors.CommandExecutor;
+import redis.clients.jedis.executors.DefaultCommandExecutor;
+import redis.clients.jedis.providers.ConnectionProvider;
+import redis.clients.jedis.providers.PooledConnectionProvider;
+import redis.clients.jedis.util.IOUtils;
+import redis.clients.jedis.util.JedisURIHelper;
+
+/**
+ * Redis client that provides a clean, developer-friendly API for Redis operations.
+ * <p>
+ * This client extends {@link BaseRedisClient} to inherit all Redis command implementations and
+ * provides a Builder pattern for configuration instead of multiple constructors.
+ * <p>
+ * Key features:
+ * <ul>
+ * <li>Clean API with minimal constructors</li>
+ * <li>Builder pattern for complex configuration</li>
+ * <li>Automatic connection pooling and resource management</li>
+ * <li>Full Redis command support including modules</li>
+ * <li>Pipeline and transaction support</li>
+ * <li>No deprecated features (Sharding/Sharded)</li>
+ * </ul>
+ * <p>
+ * Basic usage:
+ *
+ * <pre>{@code
+ * // Simple connection
+ * try (RedisClient client = new RedisClient("localhost", 6379)) {
+ *   client.set("key", "value");
+ *   String value = client.get("key");
+ * }
+ *
+ * // With configuration
+ * JedisClientConfig config = DefaultJedisClientConfig.builder().password("secret").database(1)
+ *     .build();
+ * try (RedisClient client = RedisClient.builder().host("localhost").port(6379).config(config)
+ *     .build()) {
+ *   client.set("key", "value");
+ * }
+ * }</pre>
+ *
+ * @see BaseRedisClient
+ * @see Builder
+ */
+public class RedisClient extends BaseRedisClient {
+
+  private final CommandExecutor executor;
+  private final ConnectionProvider provider;
+  private final CommandObjects commandObjects;
+  private final Cache cache;
+
+  /**
+   * Creates a Redis client with default configuration connecting to localhost:6379.
+   */
+  public RedisClient() {
+    this(Protocol.DEFAULT_HOST, Protocol.DEFAULT_PORT);
+  }
+
+  /**
+   * Creates a Redis client connecting to the specified host and port.
+   * @param host the Redis server host
+   * @param port the Redis server port
+   */
+  public RedisClient(String host, int port) {
+    this(new HostAndPort(host, port));
+  }
+
+  /**
+   * Creates a Redis client connecting to the specified host and port.
+   * @param hostAndPort the Redis server host and port
+   */
+  public RedisClient(HostAndPort hostAndPort) {
+    this(builder().host(hostAndPort.getHost()).port(hostAndPort.getPort()));
+  }
+
+  /**
+   * Creates a Redis client from a URI.
+   * @param uri the Redis URI (e.g., "redis://localhost:6379")
+   */
+  public RedisClient(final URI uri) {
+    this(builder().fromURI(uri));
+  }
+
+  /**
+   * Package-private constructor for builder.
+   */
+  RedisClient(Builder builder) {
+    // Use custom connection provider if provided, otherwise create default pooled provider
+    if (builder.connectionProvider != null) {
+      this.provider = builder.connectionProvider;
+    } else {
+      this.provider = new PooledConnectionProvider(new HostAndPort(builder.host, builder.port),
+          builder.clientConfig, builder.poolConfig);
+    }
+
+    this.executor = new DefaultCommandExecutor(provider);
+    this.commandObjects = new CommandObjects();
+
+    if (builder.clientConfig.getRedisProtocol() != null) {
+      this.commandObjects.setProtocol(builder.clientConfig.getRedisProtocol());
+    }
+
+    if (builder.cache != null) {
+      this.cache = builder.cache;
+    } else {
+      this.cache = null;
+    }
+
+    // Apply common configuration from the abstract base class
+    builder.applyCommonConfiguration(this.commandObjects);
+  }
+
+  // Abstract method implementations from BaseRedisClient
+
+  @Override
+  protected CommandObjects getCommandObjects() {
+    return commandObjects;
+  }
+
+  @Override
+  protected ConnectionProvider getConnectionProvider() {
+    return provider;
+  }
+
+  public Cache getCache() {
+    return cache;
+  }
+
+  @Override
+  public <T> T executeCommand(CommandObject<T> commandObject) {
+    return executor.executeCommand(commandObject);
+  }
+
+  @Override
+  public <T> T broadcastCommand(CommandObject<T> commandObject) {
+    return executor.broadcastCommand(commandObject);
+  }
+
+  @Override
+  protected <T> T checkAndBroadcastCommand(CommandObject<T> commandObject) {
+    // For standalone Redis, broadcast and execute are the same
+    return executeCommand(commandObject);
+  }
+
+  // Client-specific methods
+
+  /**
+   * Creates a new pipeline for batching commands.
+   * @return a new Pipeline instance
+   */
+  public Pipeline pipelined() {
+    return new Pipeline(provider.getConnection(), true, commandObjects);
+  }
+
+  /**
+   * Creates a new transaction (MULTI/EXEC block).
+   * @return a new Transaction instance
+   */
+  public Transaction multi() {
+    return new Transaction(provider.getConnection(), true, true, commandObjects);
+  }
+
+  /**
+   * Creates a new transaction with optional MULTI command.
+   * @param doMulti whether to execute MULTI command
+   * @return a new Transaction instance
+   */
+  public Transaction transaction(boolean doMulti) {
+    return new Transaction(provider.getConnection(), doMulti, true, commandObjects);
+  }
+
+  @Override
+  public void close() {
+    IOUtils.closeQuietly(this.executor);
+  }
+
+  /**
+   * Creates a new builder for configuring a RedisClient.
+   * @return a new Builder instance
+   */
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  /**
+   * Builder for configuring RedisClient instances.
+   * <p>
+   * Provides a fluent API for setting connection parameters and advanced Redis client features. For
+   * detailed client configuration (authentication, SSL, timeouts, etc.), use
+   * {@link DefaultJedisClientConfig.Builder} and pass the result to
+   * {@link #config(JedisClientConfig)}.
+   * <p>
+   * Example usage:
+   *
+   * <pre>{@code
+   * // Simple configuration
+   * RedisClient client = RedisClient.builder().host("redis.example.com").port(6379).build();
+   *
+   * // Advanced configuration with custom client config
+   * JedisClientConfig clientConfig = DefaultJedisClientConfig.builder().password("secret")
+   *     .database(1).ssl(true).connectionTimeoutMillis(5000).socketTimeoutMillis(10000).build();
+   *
+   * // Advanced configuration with custom pool config
+   * ConnectionPoolConfig poolConfig = new ConnectionPoolConfig();
+   * poolConfig.setMaxTotal(20);
+   * poolConfig.setMaxIdle(10);
+   *
+   * RedisClient client = RedisClient.builder().host("redis.example.com").port(6379)
+   *     .config(clientConfig).poolConfig(poolConfig).cache(cache).build();
+   *
+   * // Custom connection provider
+   * ConnectionProvider customProvider = new MyCustomConnectionProvider();
+   * RedisClient client = RedisClient.builder().connectionProvider(customProvider).build();
+   *
+   * // Advanced configuration with custom processors and mappers
+   * CommandKeyArgumentPreProcessor keyProcessor = new PrefixedKeyArgumentPreProcessor("myapp:");
+   * JsonObjectMapper jsonMapper = new MyCustomJsonMapper();
+   * RedisClient client = RedisClient.builder().host("redis.example.com").port(6379)
+   *     .keyPreProcessor(keyProcessor).jsonObjectMapper(jsonMapper).searchDialect(3).build();
+   * }</pre>
+   */
+  public static class Builder extends AbstractRedisClientBuilder<Builder, RedisClient> {
+    // Connection details (not part of JedisClientConfig)
+    private String host = "localhost";
+    private int port = Protocol.DEFAULT_PORT;
+
+    // Client configuration
+    private JedisClientConfig clientConfig = DefaultJedisClientConfig.builder().build();
+
+    private Builder() {
+    }
+
+    @Override
+    protected Builder self() {
+      return this;
+    }
+
+    /**
+     * Sets the Redis server host.
+     * @param host the host name or IP address
+     * @return this builder
+     */
+    public Builder host(String host) {
+      this.host = host;
+      return this;
+    }
+
+    /**
+     * Sets the Redis server port.
+     * @param port the port number
+     * @return this builder
+     */
+    public Builder port(int port) {
+      this.port = port;
+      return this;
+    }
+
+    /**
+     * Sets the Redis server host and port.
+     * @param hostAndPort the host and port
+     * @return this builder
+     */
+    public Builder hostAndPort(HostAndPort hostAndPort) {
+      this.host = hostAndPort.getHost();
+      this.port = hostAndPort.getPort();
+      return this;
+    }
+
+    /**
+     * Sets the complete client configuration.
+     * <p>
+     * Use {@link DefaultJedisClientConfig.Builder} to create advanced configurations with
+     * authentication, SSL, timeouts, and other Redis client settings.
+     * @param clientConfig the client configuration
+     * @return this builder
+     */
+    public Builder config(JedisClientConfig clientConfig) {
+      this.clientConfig = clientConfig;
+      return this;
+    }
+
+    /**
+     * Builds the RedisClient with the configured parameters.
+     * @return a new RedisClient instance
+     * @throws IllegalArgumentException if the configuration is invalid
+     */
+    public RedisClient build() {
+      validateConfiguration();
+      return new RedisClient(this);
+    }
+
+    /**
+     * Validates the builder configuration.
+     */
+    private void validateConfiguration() {
+      // Validate common configuration
+      validateCommonConfiguration();
+
+      // If custom connection provider is set, skip host/port/config validation
+      if (connectionProvider != null) {
+        return;
+      }
+
+      if (host == null || host.trim().isEmpty()) {
+        throw new IllegalArgumentException("Host cannot be null or empty");
+      }
+      if (port <= 0 || port > 65535) {
+        throw new IllegalArgumentException("Port must be between 1 and 65535");
+      }
+      if (clientConfig == null) {
+        throw new IllegalArgumentException("Client configuration cannot be null");
+      }
+    }
+
+    /**
+     * Configures the builder from a Redis URI.
+     * <p>
+     * Parses the URI to extract connection parameters including host, port, authentication
+     * credentials, database, protocol, and SSL settings.
+     * <p>
+     * Supported URI formats:
+     * <ul>
+     * <li>{@code redis://[user:password@]host[:port][/database][?protocol=3]}</li>
+     * <li>{@code rediss://[user:password@]host[:port][/database][?protocol=3]} (SSL)</li>
+     * </ul>
+     * @param uri the Redis URI to parse
+     * @return this builder
+     * @throws IllegalArgumentException if the URI is invalid
+     */
+    public Builder fromURI(URI uri) {
+      this.clientConfig = DefaultJedisClientConfig.builder().user(JedisURIHelper.getUser(uri))
+          .password(JedisURIHelper.getPassword(uri)).database(JedisURIHelper.getDBIndex(uri))
+          .protocol(JedisURIHelper.getRedisProtocol(uri)).ssl(JedisURIHelper.isRedisSSLScheme(uri))
+          .build();
+      return hostAndPort(JedisURIHelper.getHostAndPort(uri));
+    }
+  }
+}
diff --git a/src/main/java/redis/clients/jedis/RedisClusterClient.java b/src/main/java/redis/clients/jedis/RedisClusterClient.java
new file mode 100644
index 0000000000..b3f5d4837e
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/RedisClusterClient.java
@@ -0,0 +1,698 @@
+package redis.clients.jedis;
+
+import java.net.URI;
+import java.time.Duration;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
+import redis.clients.jedis.annots.Experimental;
+import redis.clients.jedis.commands.ClusterCommands;
+import redis.clients.jedis.csc.Cache;
+import redis.clients.jedis.executors.ClusterCommandExecutor;
+import redis.clients.jedis.executors.CommandExecutor;
+import redis.clients.jedis.json.JsonObjectMapper;
+import redis.clients.jedis.providers.ClusterConnectionProvider;
+import redis.clients.jedis.providers.ConnectionProvider;
+import redis.clients.jedis.search.SearchProtocol;
+import redis.clients.jedis.util.IOUtils;
+import redis.clients.jedis.util.JedisClusterCRC16;
+import redis.clients.jedis.util.JedisURIHelper;
+
+/**
+ * Redis Cluster client that provides a clean, developer-friendly API for Redis Cluster operations.
+ * <p>
+ * This client extends {@link BaseRedisClient} to inherit all Redis command implementations and
+ * provides a Builder pattern for configuration. It uses {@link ClusterConnectionProvider} for
+ * cluster topology management and automatic slot-based routing.
+ * <p>
+ * Key features:
+ * <ul>
+ * <li>Automatic cluster topology discovery and management</li>
+ * <li>Slot-based command routing with automatic retries</li>
+ * <li>Builder pattern for complex configuration</li>
+ * <li>Automatic connection pooling and resource management</li>
+ * <li>Full Redis command support including modules</li>
+ * <li>Cluster-specific operations (CLUSTER commands)</li>
+ * <li>Pipeline support with cluster awareness</li>
+ * </ul>
+ * <p>
+ * Basic usage:
+ *
+ * <pre>{@code
+ * // Simple cluster connection
+ * Set<HostAndPort> nodes = Set.of(new HostAndPort("node1", 7000), new HostAndPort("node2", 7001),
+ *   new HostAndPort("node3", 7002));
+ * try (RedisClusterClient client = new RedisClusterClient(nodes)) {
+ *   client.set("key", "value");
+ *   String value = client.get("key");
+ * }
+ *
+ * // With configuration
+ * JedisClientConfig config = DefaultJedisClientConfig.builder().password("secret").build();
+ * try (RedisClusterClient client = RedisClusterClient.builder().nodes(nodes).clientConfig(config)
+ *     .maxAttempts(5).maxTotalRetriesDuration(Duration.ofSeconds(10)).build()) {
+ *   client.set("key", "value");
+ * }
+ * }</pre>
+ *
+ * @see BaseRedisClient
+ * @see ClusterConnectionProvider
+ * @see ClusterCommands
+ * @see Builder
+ */
+public class RedisClusterClient extends BaseRedisClient implements ClusterCommands {
+
+  private final ClusterCommandExecutor executor;
+  private final ClusterConnectionProvider provider;
+  private final ClusterCommandObjects commandObjects;
+  private final Cache cache;
+
+  /**
+   * Creates a RedisClusterClient with default configuration.
+   * @param node
+   */
+  public RedisClusterClient(HostAndPort node) {
+    this(builder().node(node));
+  }
+
+  /**
+   * Creates a RedisClusterClient with default configuration.
+   * @param uri
+   */
+  public RedisClusterClient(URI uri) {
+    this(builder().fromURI(uri));
+  }
+
+  /**
+   * Creates a RedisClusterClient with default configuration.
+   * @param nodes the cluster nodes to connect to
+   */
+  public RedisClusterClient(Set<HostAndPort> nodes) {
+    this(builder().nodes(nodes));
+  }
+
+  /**
+   * Creates a RedisClusterClient with custom client configuration.
+   * @param nodes the cluster nodes to connect to
+   * @param clientConfig the client configuration
+   */
+  public RedisClusterClient(Set<HostAndPort> nodes, JedisClientConfig clientConfig) {
+    this(builder().nodes(nodes).clientConfig(clientConfig));
+  }
+
+  /**
+   * Package-private constructor for builder.
+   */
+  RedisClusterClient(Builder builder) {
+    // Use custom connection provider if provided, otherwise create default cluster provider
+    if (builder.connectionProvider != null) {
+      if (!(builder.connectionProvider instanceof ClusterConnectionProvider)) {
+        throw new IllegalArgumentException(
+            "ConnectionProvider must be a ClusterConnectionProvider");
+      }
+      this.provider = (ClusterConnectionProvider) builder.connectionProvider;
+    } else {
+      if (builder.cache != null) {
+        if (builder.topologyRefreshPeriod != null) {
+          this.provider = new ClusterConnectionProvider(builder.nodes, builder.clientConfig,
+              builder.cache, builder.poolConfig, builder.topologyRefreshPeriod);
+        } else {
+          this.provider = new ClusterConnectionProvider(builder.nodes, builder.clientConfig,
+              builder.cache, builder.poolConfig);
+        }
+      } else {
+        if (builder.topologyRefreshPeriod != null) {
+          this.provider = new ClusterConnectionProvider(builder.nodes, builder.clientConfig,
+              builder.poolConfig, builder.topologyRefreshPeriod);
+        } else {
+          this.provider = new ClusterConnectionProvider(builder.nodes, builder.clientConfig,
+              builder.poolConfig);
+        }
+      }
+    }
+
+    this.executor = new ClusterCommandExecutor(provider, builder.maxAttempts,
+        builder.maxTotalRetriesDuration);
+    this.commandObjects = new ClusterCommandObjects();
+
+    if (builder.clientConfig.getRedisProtocol() != null) {
+      this.commandObjects.setProtocol(builder.clientConfig.getRedisProtocol());
+    }
+
+    if (builder.cache != null) {
+      this.cache = builder.cache;
+    } else {
+      this.cache = null;
+    }
+
+    // Apply common configuration from AbstractRedisClientBuilder
+    builder.applyCommonConfiguration(this.commandObjects);
+  }
+
+  // Abstract method implementations from BaseRedisClient
+
+  @Override
+  protected CommandObjects getCommandObjects() {
+    return commandObjects;
+  }
+
+  @Override
+  protected ConnectionProvider getConnectionProvider() {
+    return provider;
+  }
+
+  @Override
+  public Cache getCache() {
+    return cache;
+  }
+
+  @Override
+  public <T> T executeCommand(CommandObject<T> commandObject) {
+    return executor.executeCommand(commandObject);
+  }
+
+  @Override
+  public <T> T broadcastCommand(CommandObject<T> commandObject) {
+    return executor.broadcastCommand(commandObject);
+  }
+
+  @Override
+  protected <T> T checkAndBroadcastCommand(CommandObject<T> commandObject) {
+    // For cluster, we need to broadcast to all nodes
+    return broadcastCommand(commandObject);
+  }
+
+  // Cluster-specific methods
+
+  /**
+   * Executes a command on a replica node if available.
+   * @param commandObject the command to execute
+   * @param <T> the return type
+   * @return the command result
+   */
+  public <T> T executeCommandToReplica(CommandObject<T> commandObject) {
+    return executor.executeCommandToReplica(commandObject);
+  }
+
+  /**
+   * Creates a new cluster-aware pipeline for batching commands.
+   * @return a new ClusterPipeline instance
+   */
+  public ClusterPipeline pipelined() {
+    return new ClusterPipeline(provider, commandObjects);
+  }
+
+  /**
+   * Transactions are not supported in cluster mode.
+   * @param doMulti ignored parameter
+   * @return nothing
+   * @throws UnsupportedOperationException always
+   */
+  public AbstractTransaction transaction(boolean doMulti) {
+    throw new UnsupportedOperationException("Transactions are not supported in cluster mode");
+  }
+
+  // Sharded Pub/Sub methods
+
+  /**
+   * Publishes a message to a sharded channel.
+   * @param channel the channel to publish to
+   * @param message the message to publish
+   * @return the number of clients that received the message
+   */
+  public long spublish(String channel, String message) {
+    return executeCommand(commandObjects.spublish(channel, message));
+  }
+
+  /**
+   * Publishes a message to a sharded channel.
+   * @param channel the channel to publish to
+   * @param message the message to publish
+   * @return the number of clients that received the message
+   */
+  public long spublish(byte[] channel, byte[] message) {
+    return executeCommand(commandObjects.spublish(channel, message));
+  }
+
+  /**
+   * Subscribes to sharded channels.
+   * @param jedisPubSub the pub/sub handler
+   * @param channels the channels to subscribe to
+   */
+  public void ssubscribe(final JedisShardedPubSub jedisPubSub, final String... channels) {
+    try (Connection connection = getConnectionFromSlot(JedisClusterCRC16.getSlot(channels[0]))) {
+      jedisPubSub.proceed(connection, channels);
+    }
+  }
+
+  /**
+   * Subscribes to sharded channels.
+   * @param jedisPubSub the pub/sub handler
+   * @param channels the channels to subscribe to
+   */
+  public void ssubscribe(BinaryJedisShardedPubSub jedisPubSub, final byte[]... channels) {
+    try (Connection connection = getConnectionFromSlot(JedisClusterCRC16.getSlot(channels[0]))) {
+      jedisPubSub.proceed(connection, channels);
+    }
+  }
+
+  // Cluster utility methods
+
+  /**
+   * Returns all nodes that were configured to connect to in key-value pairs ({@link Map}). Key is
+   * the HOST:PORT and the value is the connection pool.
+   * @return the map of all connections.
+   */
+  public Map<String, ConnectionPool> getClusterNodes() {
+    return provider.getNodes();
+  }
+
+  /**
+   * Returns the connection for one of the 16,384 slots.
+   * @param slot the slot to retrieve the connection for.
+   * @return connection of the provided slot. {@code close()} of this connection must be called
+   *         after use.
+   */
+  public Connection getConnectionFromSlot(int slot) {
+    return provider.getConnectionFromSlot(slot);
+  }
+
+  @Override
+  public void close() {
+    IOUtils.closeQuietly(this.executor);
+  }
+
+  // ClusterCommands interface implementation
+  // Note: These commands use sendCommand pattern since they are not available in CommandObjects
+
+  @Override
+  public String asking() {
+    return (String) sendCommand(Protocol.Command.ASKING);
+  }
+
+  @Override
+  public String readonly() {
+    return (String) sendCommand(Protocol.Command.READONLY);
+  }
+
+  @Override
+  public String readwrite() {
+    return (String) sendCommand(Protocol.Command.READWRITE);
+  }
+
+  @Override
+  public String clusterNodes() {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.NODES.name());
+  }
+
+  @Override
+  public String clusterMeet(String ip, int port) {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.MEET.name(), ip,
+      String.valueOf(port));
+  }
+
+  @Override
+  public String clusterAddSlots(int... slots) {
+    String[] args = new String[slots.length + 1];
+    args[0] = Protocol.ClusterKeyword.ADDSLOTS.name();
+    for (int i = 0; i < slots.length; i++) {
+      args[i + 1] = String.valueOf(slots[i]);
+    }
+    return (String) sendCommand(Protocol.Command.CLUSTER, args);
+  }
+
+  @Override
+  public String clusterDelSlots(int... slots) {
+    String[] args = new String[slots.length + 1];
+    args[0] = Protocol.ClusterKeyword.DELSLOTS.name();
+    for (int i = 0; i < slots.length; i++) {
+      args[i + 1] = String.valueOf(slots[i]);
+    }
+    return (String) sendCommand(Protocol.Command.CLUSTER, args);
+  }
+
+  @Override
+  public String clusterInfo() {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.INFO.name());
+  }
+
+  @Override
+  public java.util.List<String> clusterGetKeysInSlot(int slot, int count) {
+    return (java.util.List<String>) sendCommand(Protocol.Command.CLUSTER,
+      Protocol.ClusterKeyword.GETKEYSINSLOT.name(), String.valueOf(slot), String.valueOf(count));
+  }
+
+  @Override
+  public java.util.List<byte[]> clusterGetKeysInSlotBinary(int slot, int count) {
+    return (java.util.List<byte[]>) sendCommand(Protocol.Command.CLUSTER,
+      Protocol.ClusterKeyword.GETKEYSINSLOT.name(), String.valueOf(slot), String.valueOf(count));
+  }
+
+  @Override
+  public String clusterSetSlotNode(int slot, String nodeId) {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.SETSLOT.name(),
+      String.valueOf(slot), Protocol.ClusterKeyword.NODE.name(), nodeId);
+  }
+
+  @Override
+  public String clusterSetSlotMigrating(int slot, String nodeId) {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.SETSLOT.name(),
+      String.valueOf(slot), Protocol.ClusterKeyword.MIGRATING.name(), nodeId);
+  }
+
+  @Override
+  public String clusterSetSlotImporting(int slot, String nodeId) {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.SETSLOT.name(),
+      String.valueOf(slot), Protocol.ClusterKeyword.IMPORTING.name(), nodeId);
+  }
+
+  @Override
+  public String clusterSetSlotStable(int slot) {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.SETSLOT.name(),
+      String.valueOf(slot), Protocol.ClusterKeyword.STABLE.name());
+  }
+
+  @Override
+  public String clusterForget(String nodeId) {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.FORGET.name(),
+      nodeId);
+  }
+
+  @Override
+  public String clusterFlushSlots() {
+    return (String) sendCommand(Protocol.Command.CLUSTER,
+      Protocol.ClusterKeyword.FLUSHSLOTS.name());
+  }
+
+  @Override
+  public long clusterKeySlot(String key) {
+    return (Long) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.KEYSLOT.name(),
+      key);
+  }
+
+  @Override
+  public long clusterCountFailureReports(String nodeId) {
+    // Note: Using the actual keyword string since COUNT_FAILURE_REPORTS doesn't exist
+    return (Long) sendCommand(Protocol.Command.CLUSTER, "COUNT-FAILURE-REPORTS", nodeId);
+  }
+
+  @Override
+  public long clusterCountKeysInSlot(int slot) {
+    return (Long) sendCommand(Protocol.Command.CLUSTER,
+      Protocol.ClusterKeyword.COUNTKEYSINSLOT.name(), String.valueOf(slot));
+  }
+
+  @Override
+  public String clusterSaveConfig() {
+    return (String) sendCommand(Protocol.Command.CLUSTER,
+      Protocol.ClusterKeyword.SAVECONFIG.name());
+  }
+
+  @Override
+  public String clusterSetConfigEpoch(long configEpoch) {
+    // Note: Using the actual keyword string since SET_CONFIG_EPOCH doesn't exist
+    return (String) sendCommand(Protocol.Command.CLUSTER, "SET-CONFIG-EPOCH",
+      String.valueOf(configEpoch));
+  }
+
+  @Override
+  public String clusterBumpEpoch() {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.BUMPEPOCH.name());
+  }
+
+  @Override
+  public String clusterReplicate(String nodeId) {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.REPLICATE.name(),
+      nodeId);
+  }
+
+  @Override
+  public java.util.List<String> clusterReplicas(String nodeId) {
+    return (java.util.List<String>) sendCommand(Protocol.Command.CLUSTER,
+      Protocol.ClusterKeyword.REPLICAS.name(), nodeId);
+  }
+
+  @Override
+  public String clusterFailover() {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.FAILOVER.name());
+  }
+
+  @Override
+  public String clusterFailover(redis.clients.jedis.args.ClusterFailoverOption failoverOption) {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.FAILOVER.name(),
+      failoverOption.name());
+  }
+
+  @Override
+  public java.util.List<redis.clients.jedis.resps.ClusterShardInfo> clusterShards() {
+    return (java.util.List<redis.clients.jedis.resps.ClusterShardInfo>) sendCommand(
+      Protocol.Command.CLUSTER, Protocol.ClusterKeyword.SHARDS.name());
+  }
+
+  @Override
+  public String clusterReset() {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.RESET.name());
+  }
+
+  @Override
+  public String clusterReset(redis.clients.jedis.args.ClusterResetType resetType) {
+    if (resetType == null) {
+      return clusterReset();
+    }
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.RESET.name(),
+      resetType.name());
+  }
+
+  @Override
+  public String clusterMyId() {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.MYID.name());
+  }
+
+  @Override
+  public String clusterMyShardId() {
+    return (String) sendCommand(Protocol.Command.CLUSTER, Protocol.ClusterKeyword.MYSHARDID.name());
+  }
+
+  @Override
+  public java.util.List<java.util.Map<String, Object>> clusterLinks() {
+    return (java.util.List<java.util.Map<String, Object>>) sendCommand(Protocol.Command.CLUSTER,
+      Protocol.ClusterKeyword.LINKS.name());
+  }
+
+  @Override
+  public String clusterAddSlotsRange(int... ranges) {
+    String[] args = new String[ranges.length + 1];
+    args[0] = Protocol.ClusterKeyword.ADDSLOTSRANGE.name();
+    for (int i = 0; i < ranges.length; i++) {
+      args[i + 1] = String.valueOf(ranges[i]);
+    }
+    return (String) sendCommand(Protocol.Command.CLUSTER, args);
+  }
+
+  @Override
+  public String clusterDelSlotsRange(int... ranges) {
+    String[] args = new String[ranges.length + 1];
+    args[0] = Protocol.ClusterKeyword.DELSLOTSRANGE.name();
+    for (int i = 0; i < ranges.length; i++) {
+      args[i + 1] = String.valueOf(ranges[i]);
+    }
+    return (String) sendCommand(Protocol.Command.CLUSTER, args);
+  }
+
+  /**
+   * Creates a new builder for configuring RedisClusterClient instances.
+   * @return a new Builder instance
+   */
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  /**
+   * Builder for configuring RedisClusterClient instances.
+   * <p>
+   * Provides a fluent API for setting cluster configuration and advanced Redis client features. For
+   * detailed client configuration (authentication, SSL, timeouts, etc.), use
+   * {@link DefaultJedisClientConfig.Builder} and pass the result to
+   * {@link #clientConfig(JedisClientConfig)}.
+   * <p>
+   * Example usage:
+   *
+   * <pre>{@code
+   * // Simple configuration
+   * Set<HostAndPort> nodes = Set.of(new HostAndPort("node1", 7000), new HostAndPort("node2", 7001),
+   *   new HostAndPort("node3", 7002));
+   * RedisClusterClient client = RedisClusterClient.builder().nodes(nodes).build();
+   *
+   * // Advanced configuration with custom configs
+   * JedisClientConfig clientConfig = DefaultJedisClientConfig.builder().password("secret").ssl(true)
+   *     .connectionTimeoutMillis(5000).socketTimeoutMillis(10000).build();
+   *
+   * ConnectionPoolConfig poolConfig = new ConnectionPoolConfig();
+   * poolConfig.setMaxTotal(20);
+   * poolConfig.setMaxIdle(10);
+   *
+   * RedisClusterClient client = RedisClusterClient.builder().nodes(nodes).clientConfig(clientConfig)
+   *     .poolConfig(poolConfig).maxAttempts(5).maxTotalRetriesDuration(Duration.ofSeconds(10))
+   *     .topologyRefreshPeriod(Duration.ofMinutes(5)).build();
+   * }</pre>
+   */
+  public static class Builder extends AbstractRedisClientBuilder<Builder, RedisClusterClient> {
+    // Cluster-specific configuration
+    private Set<HostAndPort> nodes;
+    private JedisClientConfig clientConfig = DefaultJedisClientConfig.builder().build();
+    private int maxAttempts = JedisCluster.DEFAULT_MAX_ATTEMPTS;
+    private Duration maxTotalRetriesDuration = Duration.ofMillis(JedisCluster.DEFAULT_TIMEOUT);
+    private Duration topologyRefreshPeriod = null;
+
+    private Builder() {
+    }
+
+    @Override
+    protected Builder self() {
+      return this;
+    }
+
+    @Override
+    public RedisClusterClient build() {
+      validateConfiguration();
+      return new RedisClusterClient(this);
+    }
+
+    /**
+     * Validates the builder configuration.
+     */
+    private void validateConfiguration() {
+      // Validate common configuration
+      validateCommonConfiguration();
+
+      // If custom connection provider is set, skip cluster-specific validation
+      if (connectionProvider != null) {
+        return;
+      }
+
+      if (nodes == null || nodes.isEmpty()) {
+        throw new IllegalArgumentException("Cluster nodes must be provided");
+      }
+      if (clientConfig == null) {
+        throw new IllegalArgumentException("Client configuration cannot be null");
+      }
+      if (maxAttempts <= 0) {
+        throw new IllegalArgumentException("Max attempts must be greater than 0");
+      }
+      if (maxTotalRetriesDuration == null || maxTotalRetriesDuration.isNegative()) {
+        throw new IllegalArgumentException("Max total retries duration must be non-negative");
+      }
+    }
+
+    /**
+     * Sets the cluster nodes to connect to.
+     * <p>
+     * At least one node must be provided. The client will discover other nodes in the cluster
+     * automatically through the CLUSTER NODES command.
+     * @param nodes the cluster nodes
+     * @return this builder
+     */
+    public Builder nodes(Set<HostAndPort> nodes) {
+      this.nodes = nodes;
+      return this;
+    }
+
+    /**
+     * Sets a single cluster node to connect to.
+     * <p>
+     * The client will discover other nodes in the cluster automatically through the CLUSTER NODES
+     * command.
+     * @param node the cluster node
+     * @return this builder
+     */
+    public Builder node(HostAndPort node) {
+      this.nodes = new HashSet<>();
+      this.nodes.add(node);
+      return this;
+    }
+
+    /**
+     * Sets the client configuration for cluster connections.
+     * <p>
+     * Use {@link DefaultJedisClientConfig.Builder} to create advanced configurations with
+     * authentication, SSL, timeouts, and other Redis client settings.
+     * @param clientConfig the client configuration
+     * @return this builder
+     */
+    public Builder clientConfig(JedisClientConfig clientConfig) {
+      this.clientConfig = clientConfig;
+      return this;
+    }
+
+    /**
+     * Sets the maximum number of attempts for cluster operations.
+     * <p>
+     * When a cluster operation fails due to redirection or node failure, the client will retry up
+     * to this many times before giving up.
+     * @param maxAttempts the maximum number of attempts (must be higher than 0)
+     * @return this builder
+     */
+    public Builder maxAttempts(int maxAttempts) {
+      if (maxAttempts <= 0) {
+        throw new IllegalArgumentException("maxAttempts must be greater than 0");
+      }
+      this.maxAttempts = maxAttempts;
+      return this;
+    }
+
+    /**
+     * Sets the maximum total duration for retries.
+     * <p>
+     * The client will stop retrying cluster operations after this duration has elapsed, even if
+     * maxAttempts has not been reached.
+     * @param maxTotalRetriesDuration the maximum total retry duration
+     * @return this builder
+     */
+    public Builder maxTotalRetriesDuration(Duration maxTotalRetriesDuration) {
+      this.maxTotalRetriesDuration = maxTotalRetriesDuration;
+      return this;
+    }
+
+    /**
+     * Sets the topology refresh period.
+     * <p>
+     * The client will automatically refresh the cluster topology (node discovery and slot mapping)
+     * at this interval.
+     * @param topologyRefreshPeriod the topology refresh period
+     * @return this builder
+     */
+    public Builder topologyRefreshPeriod(Duration topologyRefreshPeriod) {
+      this.topologyRefreshPeriod = topologyRefreshPeriod;
+      return this;
+    }
+
+    /**
+     * Configures the builder from a Redis URI.
+     * <p>
+     * Parses the URI to extract connection parameters including host, port, authentication
+     * credentials, database, protocol, and SSL settings.
+     * <p>
+     * Supported URI formats:
+     * <ul>
+     * <li>{@code redis://[user:password@]host[:port][/database][?protocol=3]}</li>
+     * <li>{@code rediss://[user:password@]host[:port][/database][?protocol=3]} (SSL)</li>
+     * </ul>
+     * @param uri the Redis URI to parse
+     * @return this builder
+     * @throws IllegalArgumentException if the URI is invalid
+     */
+    public RedisClusterClient.Builder fromURI(URI uri) {
+      HostAndPort hnp = JedisURIHelper.getHostAndPort(uri);
+      this.nodes = new HashSet<>();
+      this.nodes.add(hnp);
+
+      this.clientConfig = DefaultJedisClientConfig.builder().user(JedisURIHelper.getUser(uri))
+          .password(JedisURIHelper.getPassword(uri))
+          .protocol(JedisURIHelper.getRedisProtocol(uri)).ssl(JedisURIHelper.isRedisSSLScheme(uri))
+          .build();
+      return this;
+    }
+  }
+}
diff --git a/src/main/java/redis/clients/jedis/RedisSentinelClient.java b/src/main/java/redis/clients/jedis/RedisSentinelClient.java
new file mode 100644
index 0000000000..bf637d447c
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/RedisSentinelClient.java
@@ -0,0 +1,396 @@
+package redis.clients.jedis;
+
+import java.util.Set;
+
+import redis.clients.jedis.csc.Cache;
+import redis.clients.jedis.executors.CommandExecutor;
+import redis.clients.jedis.executors.DefaultCommandExecutor;
+import redis.clients.jedis.providers.ConnectionProvider;
+import redis.clients.jedis.providers.SentineledConnectionProvider;
+import redis.clients.jedis.util.IOUtils;
+
+/**
+ * Redis Sentinel client that provides a clean, developer-friendly API for Redis operations with
+ * automatic master discovery and failover through Redis Sentinel.
+ * <p>
+ * This client extends {@link BaseRedisClient} to inherit all Redis command implementations and
+ * provides a Builder pattern for configuration. It uses {@link SentineledConnectionProvider} for
+ * automatic master discovery and failover.
+ * <p>
+ * Key features:
+ * <ul>
+ * <li>Automatic master discovery through Redis Sentinel</li>
+ * <li>Automatic failover when master becomes unavailable</li>
+ * <li>Builder pattern for complex configuration</li>
+ * <li>Automatic connection pooling and resource management</li>
+ * <li>Full Redis command support including modules</li>
+ * <li>Pipeline and transaction support</li>
+ * </ul>
+ * <p>
+ * Basic usage:
+ *
+ * <pre>{@code
+ * // Simple sentinel configuration
+ * Set<HostAndPort> sentinels = Set.of(new HostAndPort("sentinel1", 26379),
+ *   new HostAndPort("sentinel2", 26379));
+ *
+ * try (RedisSentinelClient client = RedisSentinelClient.builder().masterName("mymaster")
+ *     .sentinels(sentinels).build()) {
+ *   client.set("key", "value");
+ *   String value = client.get("key");
+ * }
+ *
+ * // Advanced configuration
+ * JedisClientConfig masterConfig = DefaultJedisClientConfig.builder().password("secret")
+ *     .database(1).build();
+ * JedisClientConfig sentinelConfig = DefaultJedisClientConfig.builder().password("sentinel-secret")
+ *     .build();
+ *
+ * try (RedisSentinelClient client = RedisSentinelClient.builder().masterName("mymaster")
+ *     .sentinels(sentinels).masterConfig(masterConfig).sentinelConfig(sentinelConfig).build()) {
+ *   client.set("key", "value");
+ * }
+ * }</pre>
+ *
+ * @see BaseRedisClient
+ * @see SentineledConnectionProvider
+ * @see Builder
+ */
+public class RedisSentinelClient extends BaseRedisClient {
+
+  private final CommandExecutor executor;
+  private final SentineledConnectionProvider provider;
+  private final CommandObjects commandObjects;
+  private final Cache cache;
+
+  /**
+   * Package-private constructor for builder.
+   * <p>
+   * Creates a new RedisSentinelClient instance using the configuration provided by the builder.
+   * This constructor initializes the connection provider, command executor, and other components
+   * needed for Redis Sentinel operations.
+   * @param builder the builder containing the configuration
+   */
+  RedisSentinelClient(Builder builder) {
+    // Use custom connection provider if provided, otherwise create default sentineled provider
+    if (builder.connectionProvider != null) {
+      if (!(builder.connectionProvider instanceof SentineledConnectionProvider)) {
+        throw new IllegalArgumentException(
+            "ConnectionProvider must be a SentineledConnectionProvider");
+      }
+      this.provider = (SentineledConnectionProvider) builder.connectionProvider;
+    } else {
+      if (builder.cache != null) {
+        this.provider = new SentineledConnectionProvider(builder.primaryName, builder.primaryConfig,
+            builder.cache, builder.poolConfig, builder.sentinels, builder.sentinelConfig,
+            builder.subscribeRetryWaitTimeMillis);
+      } else {
+        this.provider = new SentineledConnectionProvider(builder.primaryName, builder.primaryConfig,
+            builder.poolConfig, builder.sentinels, builder.sentinelConfig,
+            builder.subscribeRetryWaitTimeMillis);
+      }
+    }
+
+    this.executor = new DefaultCommandExecutor(provider);
+    this.commandObjects = new CommandObjects();
+
+    if (builder.primaryConfig.getRedisProtocol() != null) {
+      this.commandObjects.setProtocol(builder.primaryConfig.getRedisProtocol());
+    }
+
+    if (builder.cache != null) {
+      this.cache = builder.cache;
+    } else {
+      this.cache = null;
+    }
+
+    // Apply common configuration from the abstract base class
+    builder.applyCommonConfiguration(this.commandObjects);
+  }
+
+  @Override
+  protected CommandObjects getCommandObjects() {
+    return commandObjects;
+  }
+
+  @Override
+  protected ConnectionProvider getConnectionProvider() {
+    return provider;
+  }
+
+  @Override
+  public Cache getCache() {
+    return cache;
+  }
+
+  @Override
+  public <T> T executeCommand(CommandObject<T> commandObject) {
+    return executor.executeCommand(commandObject);
+  }
+
+  @Override
+  public <T> T broadcastCommand(CommandObject<T> commandObject) {
+    return executor.broadcastCommand(commandObject);
+  }
+
+  @Override
+  protected <T> T checkAndBroadcastCommand(CommandObject<T> commandObject) {
+    // For sentinel Redis, broadcast and execute are the same
+    return executeCommand(commandObject);
+  }
+
+  // Sentinel-specific methods
+
+  /**
+   * Gets the current master host and port as discovered by Redis Sentinel.
+   * <p>
+   * This method returns the current master server information as determined by the
+   * sentinel monitoring system. The master may change during failover operations.
+   * @return the current master HostAndPort, or null if no master is currently available
+   */
+  public HostAndPort getCurrentMaster() {
+    return provider.getCurrentMaster();
+  }
+
+  // Client-specific methods (same as RedisClient)
+
+  /**
+   * Creates a new pipeline for batching commands.
+   * <p>
+   * Pipelines allow you to send multiple commands to Redis without waiting for individual
+   * responses, improving performance for bulk operations. The pipeline will automatically
+   * use the current master connection as determined by Redis Sentinel.
+   * @return a new Pipeline instance for batching commands
+   */
+  public Pipeline pipelined() {
+    return new Pipeline(provider.getConnection(), true, commandObjects);
+  }
+
+  /**
+   * Creates a new transaction (MULTI/EXEC block).
+   * <p>
+   * Transactions ensure that a group of commands are executed atomically. This method
+   * automatically executes the MULTI command to start the transaction. The transaction
+   * will use the current master connection as determined by Redis Sentinel.
+   * @return a new Transaction instance for atomic command execution
+   */
+  public Transaction multi() {
+    return new Transaction(provider.getConnection(), true, true, commandObjects);
+  }
+
+  /**
+   * Creates a new transaction with optional MULTI command.
+   * <p>
+   * This method provides more control over transaction initialization. When doMulti is false,
+   * you can manually control when to start the transaction. The transaction will use the
+   * current master connection as determined by Redis Sentinel.
+   * @param doMulti whether to automatically execute the MULTI command to start the transaction
+   * @return a new Transaction instance for atomic command execution
+   */
+  public Transaction transaction(boolean doMulti) {
+    return new Transaction(provider.getConnection(), doMulti, true, commandObjects);
+  }
+
+  /**
+   * Closes the client and releases all associated resources.
+   * <p>
+   * This method closes the command executor and all underlying connections.
+   * After calling this method, the client should not be used for any operations.
+   * This method is idempotent and can be called multiple times safely.
+   */
+  @Override
+  public void close() {
+    IOUtils.closeQuietly(this.executor);
+  }
+
+  /**
+   * Creates a new builder for configuring a RedisSentinelClient.
+   * <p>
+   * The builder provides a fluent API for configuring all aspects of the Redis Sentinel client,
+   * including master name, sentinel nodes, authentication, connection pooling, and more.
+   * @return a new Builder instance for configuring the client
+   */
+  public static Builder builder() {
+    return new Builder();
+  }
+
+  /**
+   * Builder for configuring RedisSentinelClient instances.
+   * <p>
+   * Provides a fluent API for setting sentinel configuration and advanced Redis client features.
+   * For detailed client configuration (authentication, SSL, timeouts, etc.), use
+   * {@link DefaultJedisClientConfig.Builder} and pass the result to
+   * {@link #masterConfig(JedisClientConfig)} and {@link #sentinelConfig(JedisClientConfig)}.
+   * <p>
+   * Example usage:
+   *
+   * <pre>{@code
+   * // Simple configuration
+   * Set<HostAndPort> sentinels = Set.of(new HostAndPort("sentinel1", 26379),
+   *   new HostAndPort("sentinel2", 26379));
+   * RedisSentinelClient client = RedisSentinelClient.builder().masterName("mymaster")
+   *     .sentinels(sentinels).build();
+   *
+   * // Advanced configuration with custom configs
+   * JedisClientConfig masterConfig = DefaultJedisClientConfig.builder().password("secret")
+   *     .database(1).ssl(true).connectionTimeoutMillis(5000).socketTimeoutMillis(10000).build();
+   *
+   * JedisClientConfig sentinelConfig = DefaultJedisClientConfig.builder().password("sentinel-secret")
+   *     .connectionTimeoutMillis(3000).build();
+   *
+   * RedisSentinelClient client = RedisSentinelClient.builder().masterName("mymaster")
+   *     .sentinels(sentinels).masterConfig(masterConfig).sentinelConfig(sentinelConfig)
+   *     .subscribeRetryWaitTimeMillis(10000).build();
+   * }</pre>
+   */
+  public static class Builder extends AbstractRedisClientBuilder<Builder, RedisSentinelClient> {
+    // Sentinel-specific configuration
+    private String primaryName = null;
+    private Set<HostAndPort> sentinels = null;
+    private long subscribeRetryWaitTimeMillis = 5000; // DEFAULT_SUBSCRIBE_RETRY_WAIT_TIME_MILLIS
+
+    // Client configurations
+    private JedisClientConfig primaryConfig = DefaultJedisClientConfig.builder().build();
+    private JedisClientConfig sentinelConfig = DefaultJedisClientConfig.builder().build();
+
+    private Builder() {
+    }
+
+    @Override
+    protected Builder self() {
+      return this;
+    }
+
+    /**
+     * Sets the primary (master) name and client configuration.
+     * <p>
+     * Use {@link DefaultJedisClientConfig.Builder} to create advanced configurations with
+     * authentication, SSL, timeouts, and other Redis client settings for the master connection.
+     * @param primaryName the name of the master as configured in Redis Sentinel
+     * @param primaryConfig the client configuration for connecting to the master
+     * @return this builder
+     */
+    public Builder primary(String primaryName, JedisClientConfig primaryConfig) {
+      this.primaryName = primaryName;
+      this.primaryConfig = primaryConfig;
+      return this;
+    }
+
+    /**
+     * Sets the master name.
+     * <p>
+     * This is a convenience method equivalent to calling {@code primary(masterName, DefaultJedisClientConfig.builder().build())}.
+     * @param masterName the name of the master as configured in Redis Sentinel
+     * @return this builder
+     */
+    public Builder masterName(String masterName) {
+      this.primaryName = masterName;
+      return this;
+    }
+
+    /**
+     * Sets the master client configuration.
+     * <p>
+     * Use {@link DefaultJedisClientConfig.Builder} to create advanced configurations with
+     * authentication, SSL, timeouts, and other Redis client settings for the master connection.
+     * @param masterConfig the client configuration for connecting to the master
+     * @return this builder
+     */
+    public Builder masterConfig(JedisClientConfig masterConfig) {
+      this.primaryConfig = masterConfig;
+      return this;
+    }
+
+    /**
+     * Sets the set of sentinel nodes.
+     * <p>
+     * These are the Redis Sentinel instances that will be used for master discovery
+     * and failover monitoring. At least one sentinel must be provided.
+     * @param sentinels the set of sentinel host and port combinations
+     * @return this builder
+     */
+    public Builder sentinels(Set<HostAndPort> sentinels) {
+      this.sentinels = sentinels;
+      return this;
+    }
+
+    /**
+     * Sets the sentinel client configuration.
+     * <p>
+     * Use {@link DefaultJedisClientConfig.Builder} to create advanced configurations with
+     * authentication, SSL, timeouts, and other Redis client settings for sentinel connections.
+     * @param sentinelConfig the sentinel client configuration
+     * @return this builder
+     */
+    public Builder sentinelConfig(JedisClientConfig sentinelConfig) {
+      this.sentinelConfig = sentinelConfig;
+      return this;
+    }
+
+    /**
+     * Sets a custom connection provider.
+     * <p>
+     * When provided, this connection provider will be used instead of creating a new
+     * SentineledConnectionProvider. The provider must be an instance of
+     * SentineledConnectionProvider.
+     * @param connectionProvider the connection provider (must be SentineledConnectionProvider)
+     * @return this builder
+     */
+    public Builder connectionProvider(SentineledConnectionProvider connectionProvider) {
+      super.connectionProvider(connectionProvider);
+      return this;
+    }
+
+    /**
+     * Sets the subscribe retry wait time in milliseconds.
+     * <p>
+     * This controls how long to wait before retrying sentinel subscription operations
+     * when they fail. Default is 5000 milliseconds (5 seconds).
+     * @param subscribeRetryWaitTimeMillis the retry wait time in milliseconds
+     * @return this builder
+     */
+    public Builder subscribeRetryWaitTimeMillis(long subscribeRetryWaitTimeMillis) {
+      this.subscribeRetryWaitTimeMillis = subscribeRetryWaitTimeMillis;
+      return this;
+    }
+
+    /**
+     * Builds the RedisSentinelClient instance.
+     * @return a new RedisSentinelClient instance
+     * @throws IllegalArgumentException if the configuration is invalid
+     */
+    public RedisSentinelClient build() {
+      validateConfiguration();
+      return new RedisSentinelClient(this);
+    }
+
+    /**
+     * Validates the builder configuration.
+     */
+    private void validateConfiguration() {
+      // Validate common configuration
+      validateCommonConfiguration();
+
+      // If custom connection provider is set, skip sentinel-specific validation
+      if (connectionProvider != null) {
+        return;
+      }
+
+      if (primaryName == null || primaryName.trim().isEmpty()) {
+        throw new IllegalArgumentException("Primary name must be specified");
+      }
+      if (sentinels == null || sentinels.isEmpty()) {
+        throw new IllegalArgumentException("At least one sentinel must be specified");
+      }
+      if (primaryConfig == null) {
+        throw new IllegalArgumentException("Primary configuration cannot be null");
+      }
+      if (sentinelConfig == null) {
+        throw new IllegalArgumentException("Sentinel configuration cannot be null");
+      }
+      if (subscribeRetryWaitTimeMillis < 0) {
+        throw new IllegalArgumentException("Subscribe retry wait time must be non-negative");
+      }
+    }
+  }
+}
diff --git a/src/main/java/redis/clients/jedis/UnifiedJedis.java b/src/main/java/redis/clients/jedis/UnifiedJedis.java
index e3960862fa..e9a089051c 100644
--- a/src/main/java/redis/clients/jedis/UnifiedJedis.java
+++ b/src/main/java/redis/clients/jedis/UnifiedJedis.java
@@ -7,18 +7,9 @@
 import java.util.Set;
 import java.util.regex.Pattern;
 import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
-import org.json.JSONArray;
 
 import redis.clients.jedis.annots.Experimental;
 import redis.clients.jedis.annots.VisibleForTesting;
-import redis.clients.jedis.args.*;
-import redis.clients.jedis.bloom.*;
-import redis.clients.jedis.commands.JedisCommands;
-import redis.clients.jedis.commands.JedisBinaryCommands;
-import redis.clients.jedis.commands.ProtocolCommand;
-import redis.clients.jedis.commands.SampleBinaryKeyedCommands;
-import redis.clients.jedis.commands.SampleKeyedCommands;
-import redis.clients.jedis.commands.RedisModuleCommands;
 import redis.clients.jedis.csc.Cache;
 import redis.clients.jedis.csc.CacheConfig;
 import redis.clients.jedis.csc.CacheConnection;
@@ -27,27 +18,18 @@
 import redis.clients.jedis.executors.*;
 import redis.clients.jedis.json.JsonSetParams;
 import redis.clients.jedis.json.Path;
-import redis.clients.jedis.json.Path2;
 import redis.clients.jedis.json.JsonObjectMapper;
+import redis.clients.jedis.json.commands.RedisJsonV1Commands;
 import redis.clients.jedis.mcf.CircuitBreakerCommandExecutor;
 import redis.clients.jedis.mcf.MultiClusterPipeline;
 import redis.clients.jedis.mcf.MultiClusterTransaction;
 import redis.clients.jedis.params.*;
 import redis.clients.jedis.providers.*;
-import redis.clients.jedis.resps.*;
 import redis.clients.jedis.search.*;
-import redis.clients.jedis.search.aggr.AggregationBuilder;
-import redis.clients.jedis.search.aggr.AggregationResult;
-import redis.clients.jedis.search.aggr.FtAggregateIteration;
-import redis.clients.jedis.search.schemafields.SchemaField;
-import redis.clients.jedis.timeseries.*;
 import redis.clients.jedis.util.IOUtils;
 import redis.clients.jedis.util.JedisURIHelper;
-import redis.clients.jedis.util.KeyValue;
 
-public class UnifiedJedis implements JedisCommands, JedisBinaryCommands,
-    SampleKeyedCommands, SampleBinaryKeyedCommands, RedisModuleCommands,
-    AutoCloseable {
+public class UnifiedJedis extends BaseRedisClient implements RedisJsonV1Commands, AutoCloseable {
 
   @Deprecated
   protected RedisProtocol protocol = null;
@@ -307,4748 +289,364 @@ protected final void setProtocol(RedisProtocol protocol) {
     this.commandObjects.setProtocol(this.protocol);
   }
 
-  public final <T> T executeCommand(CommandObject<T> commandObject) {
-    return executor.executeCommand(commandObject);
-  }
-
-  public final <T> T broadcastCommand(CommandObject<T> commandObject) {
-    return executor.broadcastCommand(commandObject);
-  }
-
-  private <T> T checkAndBroadcastCommand(CommandObject<T> commandObject) {
-    boolean broadcast = true;
-
-    if (broadcastAndRoundRobinConfig == null) {
-    } else if (commandObject.getArguments().getCommand() instanceof SearchProtocol.SearchCommand
-        && broadcastAndRoundRobinConfig
-            .getRediSearchModeInCluster() == JedisBroadcastAndRoundRobinConfig.RediSearchMode.LIGHT) {
-      broadcast = false;
-    }
-
-    return broadcast ? broadcastCommand(commandObject) : executeCommand(commandObject);
-  }
-
-  public void setBroadcastAndRoundRobinConfig(JedisBroadcastAndRoundRobinConfig config) {
-    this.broadcastAndRoundRobinConfig = config;
-    this.commandObjects.setBroadcastAndRoundRobinConfig(this.broadcastAndRoundRobinConfig);
-  }
-
-  public Cache getCache() {
-    return cache;
-  }
-
-  public String ping() {
-    return checkAndBroadcastCommand(commandObjects.ping());
-  }
-
-  public String flushDB() {
-    return checkAndBroadcastCommand(commandObjects.flushDB());
-  }
-
-  public String flushAll() {
-    return checkAndBroadcastCommand(commandObjects.flushAll());
-  }
-
-  public String configSet(String parameter, String value) {
-    return checkAndBroadcastCommand(commandObjects.configSet(parameter, value));
-  }
-
-  public String info() {
-    return executeCommand(commandObjects.info());
-  }
-
-  public String info(String section) {
-    return executeCommand(commandObjects.info(section));
-  }
-
-  // Key commands
-  @Override
-  public boolean exists(String key) {
-    return executeCommand(commandObjects.exists(key));
-  }
-
-  @Override
-  public long exists(String... keys) {
-    return executeCommand(commandObjects.exists(keys));
-  }
-
-  @Override
-  public long persist(String key) {
-    return executeCommand(commandObjects.persist(key));
-  }
-
-  @Override
-  public String type(String key) {
-    return executeCommand(commandObjects.type(key));
-  }
-
-  @Override
-  public boolean exists(byte[] key) {
-    return executeCommand(commandObjects.exists(key));
-  }
-
-  @Override
-  public long exists(byte[]... keys) {
-    return executeCommand(commandObjects.exists(keys));
-  }
-
-  @Override
-  public long persist(byte[] key) {
-    return executeCommand(commandObjects.persist(key));
-  }
-
-  @Override
-  public String type(byte[] key) {
-    return executeCommand(commandObjects.type(key));
-  }
-
-  @Override
-  public byte[] dump(String key) {
-    return executeCommand(commandObjects.dump(key));
-  }
-
-  @Override
-  public String restore(String key, long ttl, byte[] serializedValue) {
-    return executeCommand(commandObjects.restore(key, ttl, serializedValue));
-  }
-
-  @Override
-  public String restore(String key, long ttl, byte[] serializedValue, RestoreParams params) {
-    return executeCommand(commandObjects.restore(key, ttl, serializedValue, params));
-  }
-
-  @Override
-  public byte[] dump(byte[] key) {
-    return executeCommand(commandObjects.dump(key));
-  }
-
-  @Override
-  public String restore(byte[] key, long ttl, byte[] serializedValue) {
-    return executeCommand(commandObjects.restore(key, ttl, serializedValue));
-  }
-
-  @Override
-  public String restore(byte[] key, long ttl, byte[] serializedValue, RestoreParams params) {
-    return executeCommand(commandObjects.restore(key, ttl, serializedValue, params));
-  }
-
-  @Override
-  public long expire(String key, long seconds) {
-    return executeCommand(commandObjects.expire(key, seconds));
-  }
-
-  @Override
-  public long expire(String key, long seconds, ExpiryOption expiryOption) {
-    return executeCommand(commandObjects.expire(key, seconds, expiryOption));
-  }
-
-  @Override
-  public long pexpire(String key, long milliseconds) {
-    return executeCommand(commandObjects.pexpire(key, milliseconds));
-  }
-
-  @Override
-  public long pexpire(String key, long milliseconds, ExpiryOption expiryOption) {
-    return executeCommand(commandObjects.pexpire(key, milliseconds, expiryOption));
-  }
-
-  @Override
-  public long expireTime(String key) {
-    return executeCommand(commandObjects.expireTime(key));
-  }
-
-  @Override
-  public long pexpireTime(String key) {
-    return executeCommand(commandObjects.pexpireTime(key));
-  }
-
-  @Override
-  public long expireAt(String key, long unixTime) {
-    return executeCommand(commandObjects.expireAt(key, unixTime));
-  }
-
-  @Override
-  public long expireAt(String key, long unixTime, ExpiryOption expiryOption) {
-    return executeCommand(commandObjects.expireAt(key, unixTime, expiryOption));
-  }
-
-  @Override
-  public long pexpireAt(String key, long millisecondsTimestamp) {
-    return executeCommand(commandObjects.pexpireAt(key, millisecondsTimestamp));
-  }
-
-  @Override
-  public long pexpireAt(String key, long millisecondsTimestamp, ExpiryOption expiryOption) {
-    return executeCommand(commandObjects.pexpireAt(key, millisecondsTimestamp, expiryOption));
-  }
-
-  @Override
-  public long expire(byte[] key, long seconds) {
-    return executeCommand(commandObjects.expire(key, seconds));
-  }
-
-  @Override
-  public long expire(byte[] key, long seconds, ExpiryOption expiryOption) {
-    return executeCommand(commandObjects.expire(key, seconds, expiryOption));
-  }
-
-  @Override
-  public long pexpire(byte[] key, long milliseconds) {
-    return executeCommand(commandObjects.pexpire(key, milliseconds));
-  }
-
-  @Override
-  public long pexpire(byte[] key, long milliseconds, ExpiryOption expiryOption) {
-    return executeCommand(commandObjects.pexpire(key, milliseconds, expiryOption));
-  }
-
-  @Override
-  public long expireTime(byte[] key) {
-    return executeCommand(commandObjects.expireTime(key));
-  }
-
-  @Override
-  public long pexpireTime(byte[] key) {
-    return executeCommand(commandObjects.pexpireTime(key));
-  }
-
-  @Override
-  public long expireAt(byte[] key, long unixTime) {
-    return executeCommand(commandObjects.expireAt(key, unixTime));
-  }
-
-  @Override
-  public long expireAt(byte[] key, long unixTime, ExpiryOption expiryOption) {
-    return executeCommand(commandObjects.expireAt(key, unixTime, expiryOption));
-  }
-
-  @Override
-  public long pexpireAt(byte[] key, long millisecondsTimestamp) {
-    return executeCommand(commandObjects.pexpireAt(key, millisecondsTimestamp));
-  }
-
-  @Override
-  public long pexpireAt(byte[] key, long millisecondsTimestamp, ExpiryOption expiryOption) {
-    return executeCommand(commandObjects.pexpireAt(key, millisecondsTimestamp, expiryOption));
-  }
-
-  @Override
-  public long ttl(String key) {
-    return executeCommand(commandObjects.ttl(key));
-  }
-
-  @Override
-  public long pttl(String key) {
-    return executeCommand(commandObjects.pttl(key));
-  }
-
-  @Override
-  public long touch(String key) {
-    return executeCommand(commandObjects.touch(key));
-  }
-
-  @Override
-  public long touch(String... keys) {
-    return executeCommand(commandObjects.touch(keys));
-  }
-
-  @Override
-  public long ttl(byte[] key) {
-    return executeCommand(commandObjects.ttl(key));
-  }
-
-  @Override
-  public long pttl(byte[] key) {
-    return executeCommand(commandObjects.pttl(key));
-  }
-
-  @Override
-  public long touch(byte[] key) {
-    return executeCommand(commandObjects.touch(key));
-  }
-
-  @Override
-  public long touch(byte[]... keys) {
-    return executeCommand(commandObjects.touch(keys));
-  }
-
-  @Override
-  public List<String> sort(String key) {
-    return executeCommand(commandObjects.sort(key));
-  }
-
-  @Override
-  public List<String> sort(String key, SortingParams sortingParams) {
-    return executeCommand(commandObjects.sort(key, sortingParams));
-  }
-
-  @Override
-  public long sort(String key, String dstkey) {
-    return executeCommand(commandObjects.sort(key, dstkey));
-  }
-
-  @Override
-  public long sort(String key, SortingParams sortingParams, String dstkey) {
-    return executeCommand(commandObjects.sort(key, sortingParams, dstkey));
-  }
-
-  @Override
-  public List<String> sortReadonly(String key, SortingParams sortingParams) {
-    return executeCommand(commandObjects.sortReadonly(key, sortingParams));
-  }
-
-  @Override
-  public List<byte[]> sort(byte[] key) {
-    return executeCommand(commandObjects.sort(key));
-  }
-
-  @Override
-  public List<byte[]> sort(byte[] key, SortingParams sortingParams) {
-    return executeCommand(commandObjects.sort(key, sortingParams));
-  }
-
-  @Override
-  public long sort(byte[] key, byte[] dstkey) {
-    return executeCommand(commandObjects.sort(key, dstkey));
-  }
-
-  @Override
-  public List<byte[]> sortReadonly(byte[] key, SortingParams sortingParams) {
-    return executeCommand(commandObjects.sortReadonly(key, sortingParams));
-  }
-
-  @Override
-  public long sort(byte[] key, SortingParams sortingParams, byte[] dstkey) {
-    return executeCommand(commandObjects.sort(key, sortingParams, dstkey));
-  }
-
-  @Override
-  public long del(String key) {
-    return executeCommand(commandObjects.del(key));
-  }
-
-  @Override
-  public long del(String... keys) {
-    return executeCommand(commandObjects.del(keys));
-  }
-
-  @Override
-  public long unlink(String key) {
-    return executeCommand(commandObjects.unlink(key));
-  }
-
-  @Override
-  public long unlink(String... keys) {
-    return executeCommand(commandObjects.unlink(keys));
-  }
-
-  @Override
-  public long del(byte[] key) {
-    return executeCommand(commandObjects.del(key));
-  }
-
-  @Override
-  public long del(byte[]... keys) {
-    return executeCommand(commandObjects.del(keys));
-  }
-
-  @Override
-  public long unlink(byte[] key) {
-    return executeCommand(commandObjects.unlink(key));
-  }
-
-  @Override
-  public long unlink(byte[]... keys) {
-    return executeCommand(commandObjects.unlink(keys));
-  }
-
-  @Override
-  public Long memoryUsage(String key) {
-    return executeCommand(commandObjects.memoryUsage(key));
-  }
-
-  @Override
-  public Long memoryUsage(String key, int samples) {
-    return executeCommand(commandObjects.memoryUsage(key, samples));
-  }
-
-  @Override
-  public Long memoryUsage(byte[] key) {
-    return executeCommand(commandObjects.memoryUsage(key));
-  }
-
-  @Override
-  public Long memoryUsage(byte[] key, int samples) {
-    return executeCommand(commandObjects.memoryUsage(key, samples));
-  }
-
-  @Override
-  public boolean copy(String srcKey, String dstKey, boolean replace) {
-    return executeCommand(commandObjects.copy(srcKey, dstKey, replace));
-  }
-
-  @Override
-  public String rename(String oldkey, String newkey) {
-    return executeCommand(commandObjects.rename(oldkey, newkey));
-  }
-
-  @Override
-  public long renamenx(String oldkey, String newkey) {
-    return executeCommand(commandObjects.renamenx(oldkey, newkey));
-  }
-
-  @Override
-  public boolean copy(byte[] srcKey, byte[] dstKey, boolean replace) {
-    return executeCommand(commandObjects.copy(srcKey, dstKey, replace));
-  }
-
-  @Override
-  public String rename(byte[] oldkey, byte[] newkey) {
-    return executeCommand(commandObjects.rename(oldkey, newkey));
-  }
-
-  @Override
-  public long renamenx(byte[] oldkey, byte[] newkey) {
-    return executeCommand(commandObjects.renamenx(oldkey, newkey));
-  }
-
-  public long dbSize() {
-    return executeCommand(commandObjects.dbSize());
-  }
-
-  @Override
-  public Set<String> keys(String pattern) {
-    return executeCommand(commandObjects.keys(pattern));
-  }
-
-  @Override
-  public ScanResult<String> scan(String cursor) {
-    return executeCommand(commandObjects.scan(cursor));
-  }
-
-  @Override
-  public ScanResult<String> scan(String cursor, ScanParams params) {
-    return executeCommand(commandObjects.scan(cursor, params));
-  }
-
-  @Override
-  public ScanResult<String> scan(String cursor, ScanParams params, String type) {
-    return executeCommand(commandObjects.scan(cursor, params, type));
-  }
-
-  /**
-   * @param batchCount COUNT for each batch execution
-   * @param match pattern
-   * @return scan iteration
-   */
-  public ScanIteration scanIteration(int batchCount, String match) {
-    return new ScanIteration(provider, batchCount, match);
-  }
-
-  /**
-   * @param batchCount COUNT for each batch execution
-   * @param match pattern
-   * @param type key type
-   * @return scan iteration
-   */
-  public ScanIteration scanIteration(int batchCount, String match, String type) {
-    return new ScanIteration(provider, batchCount, match, type);
-  }
-
-  @Override
-  public Set<byte[]> keys(byte[] pattern) {
-    return executeCommand(commandObjects.keys(pattern));
-  }
-
-  @Override
-  public ScanResult<byte[]> scan(byte[] cursor) {
-    return executeCommand(commandObjects.scan(cursor));
-  }
-
-  @Override
-  public ScanResult<byte[]> scan(byte[] cursor, ScanParams params) {
-    return executeCommand(commandObjects.scan(cursor, params));
-  }
-
-  @Override
-  public ScanResult<byte[]> scan(byte[] cursor, ScanParams params, byte[] type) {
-    return executeCommand(commandObjects.scan(cursor, params, type));
-  }
-
-  @Override
-  public String randomKey() {
-    return executeCommand(commandObjects.randomKey());
-  }
-
-  @Override
-  public byte[] randomBinaryKey() {
-    return executeCommand(commandObjects.randomBinaryKey());
-  }
-  // Key commands
-
-  // String commands
-  @Override
-  public String set(String key, String value) {
-    return executeCommand(commandObjects.set(key, value));
-  }
-
-  @Override
-  public String set(String key, String value, SetParams params) {
-    return executeCommand(commandObjects.set(key, value, params));
-  }
-
-  @Override
-  public String get(String key) {
-    return executeCommand(commandObjects.get(key));
-  }
-
-  @Override
-  public String setGet(String key, String value) {
-    return executeCommand(commandObjects.setGet(key, value));
-  }
-
-  @Override
-  public String setGet(String key, String value, SetParams params) {
-    return executeCommand(commandObjects.setGet(key, value, params));
-  }
-
-  @Override
-  public String getDel(String key) {
-    return executeCommand(commandObjects.getDel(key));
-  }
-
-  @Override
-  public String getEx(String key, GetExParams params) {
-    return executeCommand(commandObjects.getEx(key, params));
-  }
-
-  @Override
-  public String set(byte[] key, byte[] value) {
-    return executeCommand(commandObjects.set(key, value));
-  }
-
-  @Override
-  public String set(byte[] key, byte[] value, SetParams params) {
-    return executeCommand(commandObjects.set(key, value, params));
-  }
-
-  @Override
-  public byte[] get(byte[] key) {
-    return executeCommand(commandObjects.get(key));
-  }
-
-  @Override
-  public byte[] setGet(byte[] key, byte[] value) {
-    return executeCommand(commandObjects.setGet(key, value));
-  }
-
-  @Override
-  public byte[] setGet(byte[] key, byte[] value, SetParams params) {
-    return executeCommand(commandObjects.setGet(key, value, params));
-  }
-
-  @Override
-  public byte[] getDel(byte[] key) {
-    return executeCommand(commandObjects.getDel(key));
-  }
-
-  @Override
-  public byte[] getEx(byte[] key, GetExParams params) {
-    return executeCommand(commandObjects.getEx(key, params));
-  }
-
-  @Override
-  public boolean setbit(String key, long offset, boolean value) {
-    return executeCommand(commandObjects.setbit(key, offset, value));
-  }
-
-  @Override
-  public boolean getbit(String key, long offset) {
-    return executeCommand(commandObjects.getbit(key, offset));
-  }
-
-  @Override
-  public long setrange(String key, long offset, String value) {
-    return executeCommand(commandObjects.setrange(key, offset, value));
-  }
-
-  @Override
-  public String getrange(String key, long startOffset, long endOffset) {
-    return executeCommand(commandObjects.getrange(key, startOffset, endOffset));
-  }
-
-  @Override
-  public boolean setbit(byte[] key, long offset, boolean value) {
-    return executeCommand(commandObjects.setbit(key, offset, value));
-  }
-
-  @Override
-  public boolean getbit(byte[] key, long offset) {
-    return executeCommand(commandObjects.getbit(key, offset));
-  }
-
-  @Override
-  public long setrange(byte[] key, long offset, byte[] value) {
-    return executeCommand(commandObjects.setrange(key, offset, value));
-  }
-
-  @Override
-  public byte[] getrange(byte[] key, long startOffset, long endOffset) {
-    return executeCommand(commandObjects.getrange(key, startOffset, endOffset));
-  }
-
-  /**
-   * @deprecated Use {@link UnifiedJedis#setGet(java.lang.String, java.lang.String)}.
-   */
-  @Deprecated
-  @Override
-  public String getSet(String key, String value) {
-    return executeCommand(commandObjects.getSet(key, value));
-  }
-
-  @Override
-  public long setnx(String key, String value) {
-    return executeCommand(commandObjects.setnx(key, value));
-  }
-
-  @Override
-  public String setex(String key, long seconds, String value) {
-    return executeCommand(commandObjects.setex(key, seconds, value));
-  }
-
-  @Override
-  public String psetex(String key, long milliseconds, String value) {
-    return executeCommand(commandObjects.psetex(key, milliseconds, value));
-  }
-
-  /**
-   * @deprecated Use {@link UnifiedJedis#setGet(byte[], byte[])}.
-   */
-  @Deprecated
-  @Override
-  public byte[] getSet(byte[] key, byte[] value) {
-    return executeCommand(commandObjects.getSet(key, value));
-  }
-
-  @Override
-  public long setnx(byte[] key, byte[] value) {
-    return executeCommand(commandObjects.setnx(key, value));
-  }
-
-  @Override
-  public String setex(byte[] key, long seconds, byte[] value) {
-    return executeCommand(commandObjects.setex(key, seconds, value));
-  }
-
-  @Override
-  public String psetex(byte[] key, long milliseconds, byte[] value) {
-    return executeCommand(commandObjects.psetex(key, milliseconds, value));
-  }
-
-  @Override
-  public long incr(String key) {
-    return executeCommand(commandObjects.incr(key));
-  }
-
-  @Override
-  public long incrBy(String key, long increment) {
-    return executeCommand(commandObjects.incrBy(key, increment));
-  }
-
-  @Override
-  public double incrByFloat(String key, double increment) {
-    return executeCommand(commandObjects.incrByFloat(key, increment));
-  }
-
-  @Override
-  public long decr(String key) {
-    return executeCommand(commandObjects.decr(key));
-  }
-
-  @Override
-  public long decrBy(String key, long decrement) {
-    return executeCommand(commandObjects.decrBy(key, decrement));
-  }
-
-  @Override
-  public long incr(byte[] key) {
-    return executeCommand(commandObjects.incr(key));
-  }
-
-  @Override
-  public long incrBy(byte[] key, long increment) {
-    return executeCommand(commandObjects.incrBy(key, increment));
-  }
-
-  @Override
-  public double incrByFloat(byte[] key, double increment) {
-    return executeCommand(commandObjects.incrByFloat(key, increment));
-  }
-
-  @Override
-  public long decr(byte[] key) {
-    return executeCommand(commandObjects.decr(key));
-  }
-
-  @Override
-  public long decrBy(byte[] key, long decrement) {
-    return executeCommand(commandObjects.decrBy(key, decrement));
-  }
-
-  @Override
-  public List<String> mget(String... keys) {
-    return executeCommand(commandObjects.mget(keys));
-  }
-
-  @Override
-  public String mset(String... keysvalues) {
-    return executeCommand(commandObjects.mset(keysvalues));
-  }
-
-  @Override
-  public long msetnx(String... keysvalues) {
-    return executeCommand(commandObjects.msetnx(keysvalues));
-  }
-
-  @Override
-  public List<byte[]> mget(byte[]... keys) {
-    return executeCommand(commandObjects.mget(keys));
-  }
-
-  @Override
-  public String mset(byte[]... keysvalues) {
-    return executeCommand(commandObjects.mset(keysvalues));
-  }
-
-  @Override
-  public long msetnx(byte[]... keysvalues) {
-    return executeCommand(commandObjects.msetnx(keysvalues));
-  }
-
-  @Override
-  public long append(String key, String value) {
-    return executeCommand(commandObjects.append(key, value));
-  }
-
-  @Override
-  public String substr(String key, int start, int end) {
-    return executeCommand(commandObjects.substr(key, start, end));
-  }
-
-  @Override
-  public long strlen(String key) {
-    return executeCommand(commandObjects.strlen(key));
-  }
-
-  @Override
-  public long append(byte[] key, byte[] value) {
-    return executeCommand(commandObjects.append(key, value));
-  }
-
-  @Override
-  public byte[] substr(byte[] key, int start, int end) {
-    return executeCommand(commandObjects.substr(key, start, end));
-  }
-
-  @Override
-  public long strlen(byte[] key) {
-    return executeCommand(commandObjects.strlen(key));
-  }
-
-  @Override
-  public long bitcount(String key) {
-    return executeCommand(commandObjects.bitcount(key));
-  }
-
-  @Override
-  public long bitcount(String key, long start, long end) {
-    return executeCommand(commandObjects.bitcount(key, start, end));
-  }
-
-  @Override
-  public long bitcount(String key, long start, long end, BitCountOption option) {
-    return executeCommand(commandObjects.bitcount(key, start, end, option));
-  }
-
-  @Override
-  public long bitpos(String key, boolean value) {
-    return executeCommand(commandObjects.bitpos(key, value));
-  }
-
-  @Override
-  public long bitpos(String key, boolean value, BitPosParams params) {
-    return executeCommand(commandObjects.bitpos(key, value, params));
-  }
-
-  @Override
-  public long bitcount(byte[] key) {
-    return executeCommand(commandObjects.bitcount(key));
-  }
-
-  @Override
-  public long bitcount(byte[] key, long start, long end) {
-    return executeCommand(commandObjects.bitcount(key, start, end));
-  }
-
-  @Override
-  public long bitcount(byte[] key, long start, long end, BitCountOption option) {
-    return executeCommand(commandObjects.bitcount(key, start, end, option));
-  }
-
-  @Override
-  public long bitpos(byte[] key, boolean value) {
-    return executeCommand(commandObjects.bitpos(key, value));
-  }
-
-  @Override
-  public long bitpos(byte[] key, boolean value, BitPosParams params) {
-    return executeCommand(commandObjects.bitpos(key, value, params));
-  }
-
-  @Override
-  public List<Long> bitfield(String key, String... arguments) {
-    return executeCommand(commandObjects.bitfield(key, arguments));
-  }
-
-  @Override
-  public List<Long> bitfieldReadonly(String key, String... arguments) {
-    return executeCommand(commandObjects.bitfieldReadonly(key, arguments));
-  }
-
-  @Override
-  public List<Long> bitfield(byte[] key, byte[]... arguments) {
-    return executeCommand(commandObjects.bitfield(key, arguments));
-  }
-
-  @Override
-  public List<Long> bitfieldReadonly(byte[] key, byte[]... arguments) {
-    return executeCommand(commandObjects.bitfieldReadonly(key, arguments));
-  }
-
-  @Override
-  public long bitop(BitOP op, String destKey, String... srcKeys) {
-    return executeCommand(commandObjects.bitop(op, destKey, srcKeys));
-  }
-
-  @Override
-  public long bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
-    return executeCommand(commandObjects.bitop(op, destKey, srcKeys));
-  }
-
-  @Override
-  public LCSMatchResult lcs(String keyA, String keyB, LCSParams params) {
-    return executeCommand(commandObjects.lcs(keyA, keyB, params));
-  }
-
-  @Override
-  public LCSMatchResult lcs(byte[] keyA, byte[] keyB, LCSParams params) {
-    return executeCommand(commandObjects.lcs(keyA, keyB, params));
-  }
-  // String commands
-
-  // List commands
-  @Override
-  public long rpush(String key, String... string) {
-    return executeCommand(commandObjects.rpush(key, string));
-  }
-
-  @Override
-  public long lpush(String key, String... string) {
-    return executeCommand(commandObjects.lpush(key, string));
-  }
-
-  @Override
-  public long llen(String key) {
-    return executeCommand(commandObjects.llen(key));
-  }
-
-  @Override
-  public List<String> lrange(String key, long start, long stop) {
-    return executeCommand(commandObjects.lrange(key, start, stop));
-  }
-
-  @Override
-  public String ltrim(String key, long start, long stop) {
-    return executeCommand(commandObjects.ltrim(key, start, stop));
-  }
-
-  @Override
-  public String lindex(String key, long index) {
-    return executeCommand(commandObjects.lindex(key, index));
-  }
-
-  @Override
-  public long rpush(byte[] key, byte[]... args) {
-    return executeCommand(commandObjects.rpush(key, args));
-  }
-
-  @Override
-  public long lpush(byte[] key, byte[]... args) {
-    return executeCommand(commandObjects.lpush(key, args));
-  }
-
-  @Override
-  public long llen(byte[] key) {
-    return executeCommand(commandObjects.llen(key));
-  }
-
-  @Override
-  public List<byte[]> lrange(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.lrange(key, start, stop));
-  }
-
-  @Override
-  public String ltrim(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.ltrim(key, start, stop));
-  }
-
-  @Override
-  public byte[] lindex(byte[] key, long index) {
-    return executeCommand(commandObjects.lindex(key, index));
-  }
-
-  @Override
-  public String lset(String key, long index, String value) {
-    return executeCommand(commandObjects.lset(key, index, value));
-  }
-
-  @Override
-  public long lrem(String key, long count, String value) {
-    return executeCommand(commandObjects.lrem(key, count, value));
-  }
-
-  @Override
-  public String lpop(String key) {
-    return executeCommand(commandObjects.lpop(key));
-  }
-
-  @Override
-  public List<String> lpop(String key, int count) {
-    return executeCommand(commandObjects.lpop(key, count));
-  }
-
-  @Override
-  public String lset(byte[] key, long index, byte[] value) {
-    return executeCommand(commandObjects.lset(key, index, value));
-  }
-
-  @Override
-  public long lrem(byte[] key, long count, byte[] value) {
-    return executeCommand(commandObjects.lrem(key, count, value));
-  }
-
-  @Override
-  public byte[] lpop(byte[] key) {
-    return executeCommand(commandObjects.lpop(key));
-  }
-
-  @Override
-  public List<byte[]> lpop(byte[] key, int count) {
-    return executeCommand(commandObjects.lpop(key, count));
-  }
-
-  @Override
-  public Long lpos(String key, String element) {
-    return executeCommand(commandObjects.lpos(key, element));
-  }
-
-  @Override
-  public Long lpos(String key, String element, LPosParams params) {
-    return executeCommand(commandObjects.lpos(key, element, params));
-  }
-
-  @Override
-  public List<Long> lpos(String key, String element, LPosParams params, long count) {
-    return executeCommand(commandObjects.lpos(key, element, params, count));
-  }
-
-  @Override
-  public Long lpos(byte[] key, byte[] element) {
-    return executeCommand(commandObjects.lpos(key, element));
-  }
-
-  @Override
-  public Long lpos(byte[] key, byte[] element, LPosParams params) {
-    return executeCommand(commandObjects.lpos(key, element, params));
-  }
-
-  @Override
-  public List<Long> lpos(byte[] key, byte[] element, LPosParams params, long count) {
-    return executeCommand(commandObjects.lpos(key, element, params, count));
-  }
-
-  @Override
-  public String rpop(String key) {
-    return executeCommand(commandObjects.rpop(key));
-  }
-
-  @Override
-  public List<String> rpop(String key, int count) {
-    return executeCommand(commandObjects.rpop(key, count));
-  }
-
-  @Override
-  public byte[] rpop(byte[] key) {
-    return executeCommand(commandObjects.rpop(key));
-  }
-
-  @Override
-  public List<byte[]> rpop(byte[] key, int count) {
-    return executeCommand(commandObjects.rpop(key, count));
-  }
-
-  @Override
-  public long linsert(String key, ListPosition where, String pivot, String value) {
-    return executeCommand(commandObjects.linsert(key, where, pivot, value));
-  }
-
-  @Override
-  public long lpushx(String key, String... strings) {
-    return executeCommand(commandObjects.lpushx(key, strings));
-  }
-
-  @Override
-  public long rpushx(String key, String... strings) {
-    return executeCommand(commandObjects.rpushx(key, strings));
-  }
-
-  @Override
-  public long linsert(byte[] key, ListPosition where, byte[] pivot, byte[] value) {
-    return executeCommand(commandObjects.linsert(key, where, pivot, value));
-  }
-
-  @Override
-  public long lpushx(byte[] key, byte[]... args) {
-    return executeCommand(commandObjects.lpushx(key, args));
-  }
-
-  @Override
-  public long rpushx(byte[] key, byte[]... args) {
-    return executeCommand(commandObjects.rpushx(key, args));
-  }
-
-  @Override
-  public List<String> blpop(int timeout, String key) {
-    return executeCommand(commandObjects.blpop(timeout, key));
-  }
-
-  @Override
-  public KeyValue<String, String> blpop(double timeout, String key) {
-    return executeCommand(commandObjects.blpop(timeout, key));
-  }
-
-  @Override
-  public List<String> brpop(int timeout, String key) {
-    return executeCommand(commandObjects.brpop(timeout, key));
-  }
-
-  @Override
-  public KeyValue<String, String> brpop(double timeout, String key) {
-    return executeCommand(commandObjects.brpop(timeout, key));
-  }
-
-  @Override
-  public List<String> blpop(int timeout, String... keys) {
-    return executeCommand(commandObjects.blpop(timeout, keys));
-  }
-
-  @Override
-  public KeyValue<String, String> blpop(double timeout, String... keys) {
-    return executeCommand(commandObjects.blpop(timeout, keys));
-  }
-
-  @Override
-  public List<String> brpop(int timeout, String... keys) {
-    return executeCommand(commandObjects.brpop(timeout, keys));
-  }
-
-  @Override
-  public KeyValue<String, String> brpop(double timeout, String... keys) {
-    return executeCommand(commandObjects.brpop(timeout, keys));
-  }
-
-  @Override
-  public List<byte[]> blpop(int timeout, byte[]... keys) {
-    return executeCommand(commandObjects.blpop(timeout, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], byte[]> blpop(double timeout, byte[]... keys) {
-    return executeCommand(commandObjects.blpop(timeout, keys));
-  }
-
-  @Override
-  public List<byte[]> brpop(int timeout, byte[]... keys) {
-    return executeCommand(commandObjects.brpop(timeout, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], byte[]> brpop(double timeout, byte[]... keys) {
-    return executeCommand(commandObjects.brpop(timeout, keys));
-  }
-
-  @Override
-  public String rpoplpush(String srckey, String dstkey) {
-    return executeCommand(commandObjects.rpoplpush(srckey, dstkey));
-  }
-
-  @Override
-  public String brpoplpush(String source, String destination, int timeout) {
-    return executeCommand(commandObjects.brpoplpush(source, destination, timeout));
-  }
-
-  @Override
-  public byte[] rpoplpush(byte[] srckey, byte[] dstkey) {
-    return executeCommand(commandObjects.rpoplpush(srckey, dstkey));
-  }
-
-  @Override
-  public byte[] brpoplpush(byte[] source, byte[] destination, int timeout) {
-    return executeCommand(commandObjects.brpoplpush(source, destination, timeout));
-  }
-
-  @Override
-  public String lmove(String srcKey, String dstKey, ListDirection from, ListDirection to) {
-    return executeCommand(commandObjects.lmove(srcKey, dstKey, from, to));
-  }
-
-  @Override
-  public String blmove(String srcKey, String dstKey, ListDirection from, ListDirection to, double timeout) {
-    return executeCommand(commandObjects.blmove(srcKey, dstKey, from, to, timeout));
-  }
-
-  @Override
-  public byte[] lmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to) {
-    return executeCommand(commandObjects.lmove(srcKey, dstKey, from, to));
-  }
-
-  @Override
-  public byte[] blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to, double timeout) {
-    return executeCommand(commandObjects.blmove(srcKey, dstKey, from, to, timeout));
-  }
-
-  @Override
-  public KeyValue<String, List<String>> lmpop(ListDirection direction, String... keys) {
-    return executeCommand(commandObjects.lmpop(direction, keys));
-  }
-
-  @Override
-  public KeyValue<String, List<String>> lmpop(ListDirection direction, int count, String... keys) {
-    return executeCommand(commandObjects.lmpop(direction, count, keys));
-  }
-
-  @Override
-  public KeyValue<String, List<String>> blmpop(double timeout, ListDirection direction, String... keys) {
-    return executeCommand(commandObjects.blmpop(timeout, direction, keys));
-  }
-
-  @Override
-  public KeyValue<String, List<String>> blmpop(double timeout, ListDirection direction, int count, String... keys) {
-    return executeCommand(commandObjects.blmpop(timeout, direction, count, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], List<byte[]>> lmpop(ListDirection direction, byte[]... keys) {
-    return executeCommand(commandObjects.lmpop(direction, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], List<byte[]>> lmpop(ListDirection direction, int count, byte[]... keys) {
-    return executeCommand(commandObjects.lmpop(direction, count, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], List<byte[]>> blmpop(double timeout, ListDirection direction, byte[]... keys) {
-    return executeCommand(commandObjects.blmpop(timeout, direction, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], List<byte[]>> blmpop(double timeout, ListDirection direction, int count, byte[]... keys) {
-    return executeCommand(commandObjects.blmpop(timeout, direction, count, keys));
-  }
-  // List commands
-
-  // Hash commands
-  @Override
-  public long hset(String key, String field, String value) {
-    return executeCommand(commandObjects.hset(key, field, value));
-  }
-
-  @Override
-  public long hset(String key, Map<String, String> hash) {
-    return executeCommand(commandObjects.hset(key, hash));
-  }
-
-  @Override
-  public long hsetex(String key, HSetExParams params, String field, String value) {
-   return executeCommand(commandObjects.hsetex(key, params, field, value));
-  }
-
-  @Override
-  public long hsetex(String key, HSetExParams params, Map<String, String> hash) {
-    return executeCommand(commandObjects.hsetex(key, params, hash));
-  }
-  
-  @Override
-  public String hget(String key, String field) {
-    return executeCommand(commandObjects.hget(key, field));
-  }
-    
-  @Override
-  public List<String> hgetex(String key, HGetExParams params, String... fields) {
-    return executeCommand(commandObjects.hgetex(key, params, fields));
-  }
-
-  @Override
-  public List<String> hgetdel(String key, String... fields) {
-    return executeCommand(commandObjects.hgetdel(key, fields));
-  }
-
-  @Override
-  public long hsetnx(String key, String field, String value) {
-    return executeCommand(commandObjects.hsetnx(key, field, value));
-  }
-
-  @Override
-  public String hmset(String key, Map<String, String> hash) {
-    return executeCommand(commandObjects.hmset(key, hash));
-  }
-
-  @Override
-  public List<String> hmget(String key, String... fields) {
-    return executeCommand(commandObjects.hmget(key, fields));
-  }
-
-  @Override
-  public long hset(byte[] key, byte[] field, byte[] value) {
-    return executeCommand(commandObjects.hset(key, field, value));
-  }
-
-  @Override
-  public long hset(byte[] key, Map<byte[], byte[]> hash) {
-    return executeCommand(commandObjects.hset(key, hash));
-  }
-
-  @Override
-  public long hsetex(byte[] key, HSetExParams params, byte[] field, byte[] value) {
-   return executeCommand(commandObjects.hsetex(key, params, field, value));
-  }
-
-  @Override
-  public long hsetex(byte[] key, HSetExParams params, Map<byte[], byte[]> hash) {
-    return executeCommand(commandObjects.hsetex(key, params, hash));
-  }
-
-  @Override
-  public byte[] hget(byte[] key, byte[] field) {
-    return executeCommand(commandObjects.hget(key, field));
-  }
-
-  @Override
-  public List<byte[]> hgetex(byte[] key, HGetExParams params, byte[]... fields) {
-    return executeCommand(commandObjects.hgetex(key, params, fields));
-  }
-
-  @Override
-  public List<byte[]> hgetdel(byte[] key, byte[]... fields) {
-    return executeCommand(commandObjects.hgetdel(key, fields));
-  }
-
-  @Override
-  public long hsetnx(byte[] key, byte[] field, byte[] value) {
-    return executeCommand(commandObjects.hsetnx(key, field, value));
-  }
-
-  @Override
-  public String hmset(byte[] key, Map<byte[], byte[]> hash) {
-    return executeCommand(commandObjects.hmset(key, hash));
-  }
-
-  @Override
-  public List<byte[]> hmget(byte[] key, byte[]... fields) {
-    return executeCommand(commandObjects.hmget(key, fields));
-  }
-
-  @Override
-  public long hincrBy(String key, String field, long value) {
-    return executeCommand(commandObjects.hincrBy(key, field, value));
-  }
-
-  @Override
-  public double hincrByFloat(String key, String field, double value) {
-    return executeCommand(commandObjects.hincrByFloat(key, field, value));
-  }
-
-  @Override
-  public boolean hexists(String key, String field) {
-    return executeCommand(commandObjects.hexists(key, field));
-  }
-
-  @Override
-  public long hdel(String key, String... field) {
-    return executeCommand(commandObjects.hdel(key, field));
-  }
-
-  @Override
-  public long hlen(String key) {
-    return executeCommand(commandObjects.hlen(key));
-  }
-
-  @Override
-  public long hincrBy(byte[] key, byte[] field, long value) {
-    return executeCommand(commandObjects.hincrBy(key, field, value));
-  }
-
-  @Override
-  public double hincrByFloat(byte[] key, byte[] field, double value) {
-    return executeCommand(commandObjects.hincrByFloat(key, field, value));
-  }
-
-  @Override
-  public boolean hexists(byte[] key, byte[] field) {
-    return executeCommand(commandObjects.hexists(key, field));
-  }
-
-  @Override
-  public long hdel(byte[] key, byte[]... field) {
-    return executeCommand(commandObjects.hdel(key, field));
-  }
-
-  @Override
-  public long hlen(byte[] key) {
-    return executeCommand(commandObjects.hlen(key));
-  }
-
-  @Override
-  public Set<String> hkeys(String key) {
-    return executeCommand(commandObjects.hkeys(key));
-  }
-
-  @Override
-  public List<String> hvals(String key) {
-    return executeCommand(commandObjects.hvals(key));
-  }
-
-  @Override
-  public Map<String, String> hgetAll(String key) {
-    return executeCommand(commandObjects.hgetAll(key));
-  }
-
-  @Override
-  public Set<byte[]> hkeys(byte[] key) {
-    return executeCommand(commandObjects.hkeys(key));
-  }
-
-  @Override
-  public List<byte[]> hvals(byte[] key) {
-    return executeCommand(commandObjects.hvals(key));
-  }
-
-  @Override
-  public Map<byte[], byte[]> hgetAll(byte[] key) {
-    return executeCommand(commandObjects.hgetAll(key));
-  }
-
-  @Override
-  public String hrandfield(String key) {
-    return executeCommand(commandObjects.hrandfield(key));
-  }
-
-  @Override
-  public List<String> hrandfield(String key, long count) {
-    return executeCommand(commandObjects.hrandfield(key, count));
-  }
-
-  @Override
-  public List<Map.Entry<String, String>> hrandfieldWithValues(String key, long count) {
-    return executeCommand(commandObjects.hrandfieldWithValues(key, count));
-  }
-
-  @Override
-  public ScanResult<Map.Entry<String, String>> hscan(String key, String cursor, ScanParams params) {
-    return executeCommand(commandObjects.hscan(key, cursor, params));
-  }
-
-  @Override
-  public ScanResult<String> hscanNoValues(String key, String cursor, ScanParams params) {
-    return executeCommand(commandObjects.hscanNoValues(key, cursor, params));
-  }
-
-  @Override
-  public long hstrlen(String key, String field) {
-    return executeCommand(commandObjects.hstrlen(key, field));
-  }
-
-  @Override
-  public byte[] hrandfield(byte[] key) {
-    return executeCommand(commandObjects.hrandfield(key));
-  }
-
-  @Override
-  public List<byte[]> hrandfield(byte[] key, long count) {
-    return executeCommand(commandObjects.hrandfield(key, count));
-  }
-
-  @Override
-  public List<Map.Entry<byte[], byte[]>> hrandfieldWithValues(byte[] key, long count) {
-    return executeCommand(commandObjects.hrandfieldWithValues(key, count));
-  }
-
-  @Override
-  public ScanResult<Map.Entry<byte[], byte[]>> hscan(byte[] key, byte[] cursor, ScanParams params) {
-    return executeCommand(commandObjects.hscan(key, cursor, params));
-  }
-
-  @Override
-  public ScanResult<byte[]> hscanNoValues(byte[] key, byte[] cursor, ScanParams params) {
-    return executeCommand(commandObjects.hscanNoValues(key, cursor, params));
-  }
-
-  @Override
-  public long hstrlen(byte[] key, byte[] field) {
-    return executeCommand(commandObjects.hstrlen(key, field));
-  }
-
-  @Override
-  public List<Long> hexpire(String key, long seconds, String... fields) {
-    return executeCommand(commandObjects.hexpire(key, seconds, fields));
-  }
-
-  @Override
-  public List<Long> hexpire(String key, long seconds, ExpiryOption condition, String... fields) {
-    return executeCommand(commandObjects.hexpire(key, seconds, condition, fields));
-  }
-
-  @Override
-  public List<Long> hpexpire(String key, long milliseconds, String... fields) {
-    return executeCommand(commandObjects.hpexpire(key, milliseconds, fields));
-  }
-
-  @Override
-  public List<Long> hpexpire(String key, long milliseconds, ExpiryOption condition, String... fields) {
-    return executeCommand(commandObjects.hpexpire(key, milliseconds, condition, fields));
-  }
-
-  @Override
-  public List<Long> hexpireAt(String key, long unixTimeSeconds, String... fields) {
-    return executeCommand(commandObjects.hexpireAt(key, unixTimeSeconds, fields));
-  }
-
-  @Override
-  public List<Long> hexpireAt(String key, long unixTimeSeconds, ExpiryOption condition, String... fields) {
-    return executeCommand(commandObjects.hexpireAt(key, unixTimeSeconds, condition, fields));
-  }
-
-  @Override
-  public List<Long> hpexpireAt(String key, long unixTimeMillis, String... fields) {
-    return executeCommand(commandObjects.hpexpireAt(key, unixTimeMillis, fields));
-  }
-
-  @Override
-  public List<Long> hpexpireAt(String key, long unixTimeMillis, ExpiryOption condition, String... fields) {
-    return executeCommand(commandObjects.hpexpireAt(key, unixTimeMillis, condition, fields));
-  }
-
-  @Override
-  public List<Long> hexpire(byte[] key, long seconds, byte[]... fields) {
-    return executeCommand(commandObjects.hexpire(key, seconds, fields));
-  }
-
-  @Override
-  public List<Long> hexpire(byte[] key, long seconds, ExpiryOption condition, byte[]... fields) {
-    return executeCommand(commandObjects.hexpire(key, seconds, condition, fields));
-  }
-
-  @Override
-  public List<Long> hpexpire(byte[] key, long milliseconds, byte[]... fields) {
-    return executeCommand(commandObjects.hpexpire(key, milliseconds, fields));
-  }
-
-  @Override
-  public List<Long> hpexpire(byte[] key, long milliseconds, ExpiryOption condition, byte[]... fields) {
-    return executeCommand(commandObjects.hpexpire(key, milliseconds, condition, fields));
-  }
-
-  @Override
-  public List<Long> hexpireAt(byte[] key, long unixTimeSeconds, byte[]... fields) {
-    return executeCommand(commandObjects.hexpireAt(key, unixTimeSeconds, fields));
-  }
-
-  @Override
-  public List<Long> hexpireAt(byte[] key, long unixTimeSeconds, ExpiryOption condition, byte[]... fields) {
-    return executeCommand(commandObjects.hexpireAt(key, unixTimeSeconds, condition, fields));
-  }
-
-  @Override
-  public List<Long> hpexpireAt(byte[] key, long unixTimeMillis, byte[]... fields) {
-    return executeCommand(commandObjects.hpexpireAt(key, unixTimeMillis, fields));
-  }
-
-  @Override
-  public List<Long> hpexpireAt(byte[] key, long unixTimeMillis, ExpiryOption condition, byte[]... fields) {
-    return executeCommand(commandObjects.hpexpireAt(key, unixTimeMillis, condition, fields));
-  }
-
-  @Override
-  public List<Long> hexpireTime(String key, String... fields) {
-    return executeCommand(commandObjects.hexpireTime(key, fields));
-  }
-
-  @Override
-  public List<Long> hpexpireTime(String key, String... fields) {
-    return executeCommand(commandObjects.hpexpireTime(key, fields));
-  }
-
-  @Override
-  public List<Long> httl(String key, String... fields) {
-    return executeCommand(commandObjects.httl(key, fields));
-  }
-
-  @Override
-  public List<Long> hpttl(String key, String... fields) {
-    return executeCommand(commandObjects.hpttl(key, fields));
-  }
-
-  @Override
-  public List<Long> hexpireTime(byte[] key, byte[]... fields) {
-    return executeCommand(commandObjects.hexpireTime(key, fields));
-  }
-
-  @Override
-  public List<Long> hpexpireTime(byte[] key, byte[]... fields) {
-    return executeCommand(commandObjects.hpexpireTime(key, fields));
-  }
-
-  @Override
-  public List<Long> httl(byte[] key, byte[]... fields) {
-    return executeCommand(commandObjects.httl(key, fields));
-  }
-
-  @Override
-  public List<Long> hpttl(byte[] key, byte[]... fields) {
-    return executeCommand(commandObjects.hpttl(key, fields));
-  }
-
-  @Override
-  public List<Long> hpersist(String key, String... fields) {
-    return executeCommand(commandObjects.hpersist(key, fields));
-  }
-
-  @Override
-  public List<Long> hpersist(byte[] key, byte[]... fields) {
-    return executeCommand(commandObjects.hpersist(key, fields));
-  }
-  // Hash commands
-
-  // Set commands
-  @Override
-  public long sadd(String key, String... members) {
-    return executeCommand(commandObjects.sadd(key, members));
-  }
-
-  @Override
-  public Set<String> smembers(String key) {
-    return executeCommand(commandObjects.smembers(key));
-  }
-
-  @Override
-  public long srem(String key, String... members) {
-    return executeCommand(commandObjects.srem(key, members));
-  }
-
-  @Override
-  public String spop(String key) {
-    return executeCommand(commandObjects.spop(key));
-  }
-
-  @Override
-  public Set<String> spop(String key, long count) {
-    return executeCommand(commandObjects.spop(key, count));
-  }
-
-  @Override
-  public long scard(String key) {
-    return executeCommand(commandObjects.scard(key));
-  }
-
-  @Override
-  public boolean sismember(String key, String member) {
-    return executeCommand(commandObjects.sismember(key, member));
-  }
-
-  @Override
-  public List<Boolean> smismember(String key, String... members) {
-    return executeCommand(commandObjects.smismember(key, members));
-  }
-
-  @Override
-  public long sadd(byte[] key, byte[]... members) {
-    return executeCommand(commandObjects.sadd(key, members));
-  }
-
-  @Override
-  public Set<byte[]> smembers(byte[] key) {
-    return executeCommand(commandObjects.smembers(key));
-  }
-
-  @Override
-  public long srem(byte[] key, byte[]... members) {
-    return executeCommand(commandObjects.srem(key, members));
-  }
-
-  @Override
-  public byte[] spop(byte[] key) {
-    return executeCommand(commandObjects.spop(key));
-  }
-
-  @Override
-  public Set<byte[]> spop(byte[] key, long count) {
-    return executeCommand(commandObjects.spop(key, count));
-  }
-
-  @Override
-  public long scard(byte[] key) {
-    return executeCommand(commandObjects.scard(key));
-  }
-
-  @Override
-  public boolean sismember(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.sismember(key, member));
-  }
-
-  @Override
-  public List<Boolean> smismember(byte[] key, byte[]... members) {
-    return executeCommand(commandObjects.smismember(key, members));
-  }
-
-  @Override
-  public String srandmember(String key) {
-    return executeCommand(commandObjects.srandmember(key));
-  }
-
-  @Override
-  public List<String> srandmember(String key, int count) {
-    return executeCommand(commandObjects.srandmember(key, count));
-  }
-
-  @Override
-  public ScanResult<String> sscan(String key, String cursor, ScanParams params) {
-    return executeCommand(commandObjects.sscan(key, cursor, params));
-  }
-
-  @Override
-  public byte[] srandmember(byte[] key) {
-    return executeCommand(commandObjects.srandmember(key));
-  }
-
-  @Override
-  public List<byte[]> srandmember(byte[] key, int count) {
-    return executeCommand(commandObjects.srandmember(key, count));
-  }
-
-  @Override
-  public ScanResult<byte[]> sscan(byte[] key, byte[] cursor, ScanParams params) {
-    return executeCommand(commandObjects.sscan(key, cursor, params));
-  }
-
-  @Override
-  public Set<String> sdiff(String... keys) {
-    return executeCommand(commandObjects.sdiff(keys));
-  }
-
-  @Override
-  public long sdiffstore(String dstkey, String... keys) {
-    return executeCommand(commandObjects.sdiffstore(dstkey, keys));
-  }
-
-  @Override
-  public Set<String> sinter(String... keys) {
-    return executeCommand(commandObjects.sinter(keys));
-  }
-
-  @Override
-  public long sinterstore(String dstkey, String... keys) {
-    return executeCommand(commandObjects.sinterstore(dstkey, keys));
-  }
-
-  @Override
-  public long sintercard(String... keys) {
-    return executeCommand(commandObjects.sintercard(keys));
-  }
-
-  @Override
-  public long sintercard(int limit, String... keys) {
-    return executeCommand(commandObjects.sintercard(limit, keys));
-  }
-
-  @Override
-  public Set<String> sunion(String... keys) {
-    return executeCommand(commandObjects.sunion(keys));
-  }
-
-  @Override
-  public long sunionstore(String dstkey, String... keys) {
-    return executeCommand(commandObjects.sunionstore(dstkey, keys));
-  }
-
-  @Override
-  public long smove(String srckey, String dstkey, String member) {
-    return executeCommand(commandObjects.smove(srckey, dstkey, member));
-  }
-
-  @Override
-  public Set<byte[]> sdiff(byte[]... keys) {
-    return executeCommand(commandObjects.sdiff(keys));
-  }
-
-  @Override
-  public long sdiffstore(byte[] dstkey, byte[]... keys) {
-    return executeCommand(commandObjects.sdiffstore(dstkey, keys));
-  }
-
-  @Override
-  public Set<byte[]> sinter(byte[]... keys) {
-    return executeCommand(commandObjects.sinter(keys));
-  }
-
-  @Override
-  public long sinterstore(byte[] dstkey, byte[]... keys) {
-    return executeCommand(commandObjects.sinterstore(dstkey, keys));
-  }
-
-  @Override
-  public long sintercard(byte[]... keys) {
-    return executeCommand(commandObjects.sintercard(keys));
-  }
-
-  @Override
-  public long sintercard(int limit, byte[]... keys) {
-    return executeCommand(commandObjects.sintercard(limit, keys));
-  }
-
-  @Override
-  public Set<byte[]> sunion(byte[]... keys) {
-    return executeCommand(commandObjects.sunion(keys));
-  }
-
-  @Override
-  public long sunionstore(byte[] dstkey, byte[]... keys) {
-    return executeCommand(commandObjects.sunionstore(dstkey, keys));
-  }
-
-  @Override
-  public long smove(byte[] srckey, byte[] dstkey, byte[] member) {
-    return executeCommand(commandObjects.smove(srckey, dstkey, member));
-  }
-  // Set commands
-
-  // Sorted Set commands
-  @Override
-  public long zadd(String key, double score, String member) {
-    return executeCommand(commandObjects.zadd(key, score, member));
-  }
-
-  @Override
-  public long zadd(String key, double score, String member, ZAddParams params) {
-    return executeCommand(commandObjects.zadd(key, score, member, params));
-  }
-
-  @Override
-  public long zadd(String key, Map<String, Double> scoreMembers) {
-    return executeCommand(commandObjects.zadd(key, scoreMembers));
-  }
-
-  @Override
-  public long zadd(String key, Map<String, Double> scoreMembers, ZAddParams params) {
-    return executeCommand(commandObjects.zadd(key, scoreMembers, params));
-  }
-
-  @Override
-  public Double zaddIncr(String key, double score, String member, ZAddParams params) {
-    return executeCommand(commandObjects.zaddIncr(key, score, member, params));
-  }
-
-  @Override
-  public long zadd(byte[] key, double score, byte[] member) {
-    return executeCommand(commandObjects.zadd(key, score, member));
-  }
-
-  @Override
-  public long zadd(byte[] key, double score, byte[] member, ZAddParams params) {
-    return executeCommand(commandObjects.zadd(key, score, member, params));
-  }
-
-  @Override
-  public long zadd(byte[] key, Map<byte[], Double> scoreMembers) {
-    return executeCommand(commandObjects.zadd(key, scoreMembers));
-  }
-
-  @Override
-  public long zadd(byte[] key, Map<byte[], Double> scoreMembers, ZAddParams params) {
-    return executeCommand(commandObjects.zadd(key, scoreMembers, params));
-  }
-
-  @Override
-  public Double zaddIncr(byte[] key, double score, byte[] member, ZAddParams params) {
-    return executeCommand(commandObjects.zaddIncr(key, score, member, params));
-  }
-
-  @Override
-  public long zrem(String key, String... members) {
-    return executeCommand(commandObjects.zrem(key, members));
-  }
-
-  @Override
-  public double zincrby(String key, double increment, String member) {
-    return executeCommand(commandObjects.zincrby(key, increment, member));
-  }
-
-  @Override
-  public Double zincrby(String key, double increment, String member, ZIncrByParams params) {
-    return executeCommand(commandObjects.zincrby(key, increment, member, params));
-  }
-
-  @Override
-  public Long zrank(String key, String member) {
-    return executeCommand(commandObjects.zrank(key, member));
-  }
-
-  @Override
-  public Long zrevrank(String key, String member) {
-    return executeCommand(commandObjects.zrevrank(key, member));
-  }
-
-  @Override
-  public KeyValue<Long, Double> zrankWithScore(String key, String member) {
-    return executeCommand(commandObjects.zrankWithScore(key, member));
-  }
-
-  @Override
-  public KeyValue<Long, Double> zrevrankWithScore(String key, String member) {
-    return executeCommand(commandObjects.zrevrankWithScore(key, member));
-  }
-
-  @Override
-  public long zrem(byte[] key, byte[]... members) {
-    return executeCommand(commandObjects.zrem(key, members));
-  }
-
-  @Override
-  public double zincrby(byte[] key, double increment, byte[] member) {
-    return executeCommand(commandObjects.zincrby(key, increment, member));
-  }
-
-  @Override
-  public Double zincrby(byte[] key, double increment, byte[] member, ZIncrByParams params) {
-    return executeCommand(commandObjects.zincrby(key, increment, member, params));
-  }
-
-  @Override
-  public Long zrank(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.zrank(key, member));
-  }
-
-  @Override
-  public Long zrevrank(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.zrevrank(key, member));
-  }
-
-  @Override
-  public KeyValue<Long, Double> zrankWithScore(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.zrankWithScore(key, member));
-  }
-
-  @Override
-  public KeyValue<Long, Double> zrevrankWithScore(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.zrevrankWithScore(key, member));
-  }
-
-  @Override
-  public String zrandmember(String key) {
-    return executeCommand(commandObjects.zrandmember(key));
-  }
-
-  @Override
-  public List<String> zrandmember(String key, long count) {
-    return executeCommand(commandObjects.zrandmember(key, count));
-  }
-
-  @Override
-  public List<Tuple> zrandmemberWithScores(String key, long count) {
-    return executeCommand(commandObjects.zrandmemberWithScores(key, count));
-  }
-
-  @Override
-  public long zcard(String key) {
-    return executeCommand(commandObjects.zcard(key));
-  }
-
-  @Override
-  public Double zscore(String key, String member) {
-    return executeCommand(commandObjects.zscore(key, member));
-  }
-
-  @Override
-  public List<Double> zmscore(String key, String... members) {
-    return executeCommand(commandObjects.zmscore(key, members));
-  }
-
-  @Override
-  public byte[] zrandmember(byte[] key) {
-    return executeCommand(commandObjects.zrandmember(key));
-  }
-
-  @Override
-  public List<byte[]> zrandmember(byte[] key, long count) {
-    return executeCommand(commandObjects.zrandmember(key, count));
-  }
-
-  @Override
-  public List<Tuple> zrandmemberWithScores(byte[] key, long count) {
-    return executeCommand(commandObjects.zrandmemberWithScores(key, count));
-  }
-
-  @Override
-  public long zcard(byte[] key) {
-    return executeCommand(commandObjects.zcard(key));
-  }
-
-  @Override
-  public Double zscore(byte[] key, byte[] member) {
-    return executeCommand(commandObjects.zscore(key, member));
-  }
-
-  @Override
-  public List<Double> zmscore(byte[] key, byte[]... members) {
-    return executeCommand(commandObjects.zmscore(key, members));
-  }
-
-  @Override
-  public Tuple zpopmax(String key) {
-    return executeCommand(commandObjects.zpopmax(key));
-  }
-
-  @Override
-  public List<Tuple> zpopmax(String key, int count) {
-    return executeCommand(commandObjects.zpopmax(key, count));
-  }
-
-  @Override
-  public Tuple zpopmin(String key) {
-    return executeCommand(commandObjects.zpopmin(key));
-  }
-
-  @Override
-  public List<Tuple> zpopmin(String key, int count) {
-    return executeCommand(commandObjects.zpopmin(key, count));
-  }
-
-  @Override
-  public long zcount(String key, double min, double max) {
-    return executeCommand(commandObjects.zcount(key, min, max));
-  }
-
-  @Override
-  public long zcount(String key, String min, String max) {
-    return executeCommand(commandObjects.zcount(key, min, max));
-  }
-
-  @Override
-  public Tuple zpopmax(byte[] key) {
-    return executeCommand(commandObjects.zpopmax(key));
-  }
-
-  @Override
-  public List<Tuple> zpopmax(byte[] key, int count) {
-    return executeCommand(commandObjects.zpopmax(key, count));
-  }
-
-  @Override
-  public Tuple zpopmin(byte[] key) {
-    return executeCommand(commandObjects.zpopmin(key));
-  }
-
-  @Override
-  public List<Tuple> zpopmin(byte[] key, int count) {
-    return executeCommand(commandObjects.zpopmin(key, count));
-  }
-
-  @Override
-  public long zcount(byte[] key, double min, double max) {
-    return executeCommand(commandObjects.zcount(key, min, max));
-  }
-
-  @Override
-  public long zcount(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zcount(key, min, max));
-  }
-
-  @Override
-  public List<String> zrange(String key, long start, long stop) {
-    return executeCommand(commandObjects.zrange(key, start, stop));
-  }
-
-  @Override
-  public List<String> zrevrange(String key, long start, long stop) {
-    return executeCommand(commandObjects.zrevrange(key, start, stop));
-  }
-
-  @Override
-  public List<Tuple> zrangeWithScores(String key, long start, long stop) {
-    return executeCommand(commandObjects.zrangeWithScores(key, start, stop));
-  }
-
-  @Override
-  public List<Tuple> zrevrangeWithScores(String key, long start, long stop) {
-    return executeCommand(commandObjects.zrevrangeWithScores(key, start, stop));
-  }
-
-  @Override
-  public List<String> zrange(String key, ZRangeParams zRangeParams) {
-    return executeCommand(commandObjects.zrange(key, zRangeParams));
-  }
-
-  @Override
-  public List<Tuple> zrangeWithScores(String key, ZRangeParams zRangeParams) {
-    return executeCommand(commandObjects.zrangeWithScores(key, zRangeParams));
-  }
-
-  @Override
-  public long zrangestore(String dest, String src, ZRangeParams zRangeParams) {
-    return executeCommand(commandObjects.zrangestore(dest, src, zRangeParams));
-  }
-
-  @Override
-  public List<String> zrangeByScore(String key, double min, double max) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max));
-  }
-
-  @Override
-  public List<String> zrangeByScore(String key, String min, String max) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max));
-  }
-
-  @Override
-  public List<String> zrevrangeByScore(String key, double max, double min) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min));
-  }
-
-  @Override
-  public List<String> zrangeByScore(String key, double min, double max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
-  }
-
-  @Override
-  public List<String> zrevrangeByScore(String key, String max, String min) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min));
-  }
-
-  @Override
-  public List<String> zrangeByScore(String key, String min, String max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
-  }
-
-  @Override
-  public List<String> zrevrangeByScore(String key, double max, double min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
-  }
-
-  @Override
-  public List<Tuple> zrangeByScoreWithScores(String key, double min, double max) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
-  }
-
-  @Override
-  public List<Tuple> zrevrangeByScoreWithScores(String key, double max, double min) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
-  }
-
-  @Override
-  public List<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
-  }
-
-  @Override
-  public List<String> zrevrangeByScore(String key, String max, String min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
-  }
-
-  @Override
-  public List<Tuple> zrangeByScoreWithScores(String key, String min, String max) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
-  }
-
-  @Override
-  public List<Tuple> zrevrangeByScoreWithScores(String key, String max, String min) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
-  }
-
-  @Override
-  public List<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
-  }
-
-  @Override
-  public List<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
-  }
-
-  @Override
-  public List<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
-  }
-
-  @Override
-  public List<byte[]> zrange(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.zrange(key, start, stop));
-  }
-
-  @Override
-  public List<byte[]> zrevrange(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.zrevrange(key, start, stop));
-  }
-
-  @Override
-  public List<Tuple> zrangeWithScores(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.zrangeWithScores(key, start, stop));
-  }
-
-  @Override
-  public List<Tuple> zrevrangeWithScores(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.zrevrangeWithScores(key, start, stop));
-  }
-
-  @Override
-  public List<byte[]> zrange(byte[] key, ZRangeParams zRangeParams) {
-    return executeCommand(commandObjects.zrange(key, zRangeParams));
-  }
-
-  @Override
-  public List<Tuple> zrangeWithScores(byte[] key, ZRangeParams zRangeParams) {
-    return executeCommand(commandObjects.zrangeWithScores(key, zRangeParams));
-  }
-
-  @Override
-  public long zrangestore(byte[] dest, byte[] src, ZRangeParams zRangeParams) {
-    return executeCommand(commandObjects.zrangestore(dest, src, zRangeParams));
-  }
-
-  @Override
-  public List<byte[]> zrangeByScore(byte[] key, double min, double max) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max));
-  }
-
-  @Override
-  public List<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max));
-  }
-
-  @Override
-  public List<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min));
-  }
-
-  @Override
-  public List<byte[]> zrangeByScore(byte[] key, double min, double max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
-  }
-
-  @Override
-  public List<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min));
-  }
-
-  @Override
-  public List<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScore(key, min, max, offset, count));
-  }
-
-  @Override
-  public List<byte[]> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
-  }
-
-  @Override
-  public List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
-  }
-
-  @Override
-  public List<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
-  }
-
-  @Override
-  public List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
-  }
-
-  @Override
-  public List<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScore(key, max, min, offset, count));
-  }
-
-  @Override
-  public List<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max));
-  }
-
-  @Override
-  public List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min));
-  }
-
-  @Override
-  public List<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
-  }
-
-  @Override
-  public List<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
-  }
-
-  @Override
-  public List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
-  }
-
-  @Override
-  public long zremrangeByRank(String key, long start, long stop) {
-    return executeCommand(commandObjects.zremrangeByRank(key, start, stop));
-  }
-
-  @Override
-  public long zremrangeByScore(String key, double min, double max) {
-    return executeCommand(commandObjects.zremrangeByScore(key, min, max));
-  }
-
-  @Override
-  public long zremrangeByScore(String key, String min, String max) {
-    return executeCommand(commandObjects.zremrangeByScore(key, min, max));
-  }
-
-  @Override
-  public long zremrangeByRank(byte[] key, long start, long stop) {
-    return executeCommand(commandObjects.zremrangeByRank(key, start, stop));
-  }
-
-  @Override
-  public long zremrangeByScore(byte[] key, double min, double max) {
-    return executeCommand(commandObjects.zremrangeByScore(key, min, max));
-  }
-
-  @Override
-  public long zremrangeByScore(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zremrangeByScore(key, min, max));
-  }
-
-  @Override
-  public long zlexcount(String key, String min, String max) {
-    return executeCommand(commandObjects.zlexcount(key, min, max));
-  }
-
-  @Override
-  public List<String> zrangeByLex(String key, String min, String max) {
-    return executeCommand(commandObjects.zrangeByLex(key, min, max));
-  }
-
-  @Override
-  public List<String> zrangeByLex(String key, String min, String max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByLex(key, min, max, offset, count));
-  }
-
-  @Override
-  public List<String> zrevrangeByLex(String key, String max, String min) {
-    return executeCommand(commandObjects.zrevrangeByLex(key, max, min));
-  }
-
-  @Override
-  public List<String> zrevrangeByLex(String key, String max, String min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByLex(key, max, min, offset, count));
-  }
-
-  @Override
-  public long zremrangeByLex(String key, String min, String max) {
-    return executeCommand(commandObjects.zremrangeByLex(key, min, max));
-  }
-
-  @Override
-  public long zlexcount(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zlexcount(key, min, max));
-  }
-
-  @Override
-  public List<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zrangeByLex(key, min, max));
-  }
-
-  @Override
-  public List<byte[]> zrangeByLex(byte[] key, byte[] min, byte[] max, int offset, int count) {
-    return executeCommand(commandObjects.zrangeByLex(key, min, max, offset, count));
-  }
-
-  @Override
-  public List<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min) {
-    return executeCommand(commandObjects.zrevrangeByLex(key, max, min));
-  }
-
-  @Override
-  public List<byte[]> zrevrangeByLex(byte[] key, byte[] max, byte[] min, int offset, int count) {
-    return executeCommand(commandObjects.zrevrangeByLex(key, max, min, offset, count));
-  }
-
-  @Override
-  public long zremrangeByLex(byte[] key, byte[] min, byte[] max) {
-    return executeCommand(commandObjects.zremrangeByLex(key, min, max));
-  }
-
-  @Override
-  public ScanResult<Tuple> zscan(String key, String cursor, ScanParams params) {
-    return executeCommand(commandObjects.zscan(key, cursor, params));
-  }
-
-  @Override
-  public ScanResult<Tuple> zscan(byte[] key, byte[] cursor, ScanParams params) {
-    return executeCommand(commandObjects.zscan(key, cursor, params));
-  }
-
-  @Override
-  public KeyValue<String, Tuple> bzpopmax(double timeout, String... keys) {
-    return executeCommand(commandObjects.bzpopmax(timeout, keys));
-  }
-
-  @Override
-  public KeyValue<String, Tuple> bzpopmin(double timeout, String... keys) {
-    return executeCommand(commandObjects.bzpopmin(timeout, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], Tuple> bzpopmax(double timeout, byte[]... keys) {
-    return executeCommand(commandObjects.bzpopmax(timeout, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], Tuple> bzpopmin(double timeout, byte[]... keys) {
-    return executeCommand(commandObjects.bzpopmin(timeout, keys));
-  }
-
-  @Override
-  public List<String> zdiff(String... keys) {
-    return executeCommand(commandObjects.zdiff(keys));
-  }
-
-  @Override
-  public List<Tuple> zdiffWithScores(String... keys) {
-    return executeCommand(commandObjects.zdiffWithScores(keys));
-  }
-
-  @Override
-  @Deprecated
-  public long zdiffStore(String dstkey, String... keys) {
-    return executeCommand(commandObjects.zdiffStore(dstkey, keys));
-  }
-
-  @Override
-  public long zdiffstore(String dstkey, String... keys) {
-    return executeCommand(commandObjects.zdiffstore(dstkey, keys));
-  }
-
-  @Override
-  public List<byte[]> zdiff(byte[]... keys) {
-    return executeCommand(commandObjects.zdiff(keys));
-  }
-
-  @Override
-  public List<Tuple> zdiffWithScores(byte[]... keys) {
-    return executeCommand(commandObjects.zdiffWithScores(keys));
-  }
-
-  @Override
-  @Deprecated
-  public long zdiffStore(byte[] dstkey, byte[]... keys) {
-    return executeCommand(commandObjects.zdiffStore(dstkey, keys));
-  }
-
-  @Override
-  public long zdiffstore(byte[] dstkey, byte[]... keys) {
-    return executeCommand(commandObjects.zdiffstore(dstkey, keys));
-  }
-
-  @Override
-  public long zinterstore(String dstkey, String... sets) {
-    return executeCommand(commandObjects.zinterstore(dstkey, sets));
-  }
-
-  @Override
-  public long zinterstore(String dstkey, ZParams params, String... sets) {
-    return executeCommand(commandObjects.zinterstore(dstkey, params, sets));
-  }
-
-  @Override
-  public List<String> zinter(ZParams params, String... keys) {
-    return executeCommand(commandObjects.zinter(params, keys));
-  }
-
-  @Override
-  public List<Tuple> zinterWithScores(ZParams params, String... keys) {
-    return executeCommand(commandObjects.zinterWithScores(params, keys));
-  }
-
-  @Override
-  public long zinterstore(byte[] dstkey, byte[]... sets) {
-    return executeCommand(commandObjects.zinterstore(dstkey, sets));
-  }
-
-  @Override
-  public long zinterstore(byte[] dstkey, ZParams params, byte[]... sets) {
-    return executeCommand(commandObjects.zinterstore(dstkey, params, sets));
-  }
-
-  @Override
-  public long zintercard(byte[]... keys) {
-    return executeCommand(commandObjects.zintercard(keys));
-  }
-
-  @Override
-  public long zintercard(long limit, byte[]... keys) {
-    return executeCommand(commandObjects.zintercard(limit, keys));
-  }
-
-  @Override
-  public long zintercard(String... keys) {
-    return executeCommand(commandObjects.zintercard(keys));
-  }
-
-  @Override
-  public long zintercard(long limit, String... keys) {
-    return executeCommand(commandObjects.zintercard(limit, keys));
-  }
-
-  @Override
-  public List<byte[]> zinter(ZParams params, byte[]... keys) {
-    return executeCommand(commandObjects.zinter(params, keys));
-  }
-
-  @Override
-  public List<Tuple> zinterWithScores(ZParams params, byte[]... keys) {
-    return executeCommand(commandObjects.zinterWithScores(params, keys));
-  }
-
-  @Override
-  public List<String> zunion(ZParams params, String... keys) {
-    return executeCommand(commandObjects.zunion(params, keys));
-  }
-
-  @Override
-  public List<Tuple> zunionWithScores(ZParams params, String... keys) {
-    return executeCommand(commandObjects.zunionWithScores(params, keys));
-  }
-
-  @Override
-  public long zunionstore(String dstkey, String... sets) {
-    return executeCommand(commandObjects.zunionstore(dstkey, sets));
-  }
-
-  @Override
-  public long zunionstore(String dstkey, ZParams params, String... sets) {
-    return executeCommand(commandObjects.zunionstore(dstkey, params, sets));
-  }
-
-  @Override
-  public List<byte[]> zunion(ZParams params, byte[]... keys) {
-    return executeCommand(commandObjects.zunion(params, keys));
-  }
-
-  @Override
-  public List<Tuple> zunionWithScores(ZParams params, byte[]... keys) {
-    return executeCommand(commandObjects.zunionWithScores(params, keys));
-  }
-
-  @Override
-  public long zunionstore(byte[] dstkey, byte[]... sets) {
-    return executeCommand(commandObjects.zunionstore(dstkey, sets));
-  }
-
-  @Override
-  public long zunionstore(byte[] dstkey, ZParams params, byte[]... sets) {
-    return executeCommand(commandObjects.zunionstore(dstkey, params, sets));
-  }
-
-  @Override
-  public KeyValue<String, List<Tuple>> zmpop(SortedSetOption option, String... keys) {
-    return executeCommand(commandObjects.zmpop(option, keys));
-  }
-
-  @Override
-  public KeyValue<String, List<Tuple>> zmpop(SortedSetOption option, int count, String... keys) {
-    return executeCommand(commandObjects.zmpop(option, count, keys));
-  }
-
-  @Override
-  public KeyValue<String, List<Tuple>> bzmpop(double timeout, SortedSetOption option, String... keys) {
-    return executeCommand(commandObjects.bzmpop(timeout, option, keys));
-  }
-
-  @Override
-  public KeyValue<String, List<Tuple>> bzmpop(double timeout, SortedSetOption option, int count, String... keys) {
-    return executeCommand(commandObjects.bzmpop(timeout, option, count, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], List<Tuple>> zmpop(SortedSetOption option, byte[]... keys) {
-    return executeCommand(commandObjects.zmpop(option, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], List<Tuple>> zmpop(SortedSetOption option, int count, byte[]... keys) {
-    return executeCommand(commandObjects.zmpop(option, count, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], List<Tuple>> bzmpop(double timeout, SortedSetOption option, byte[]... keys) {
-    return executeCommand(commandObjects.bzmpop(timeout, option, keys));
-  }
-
-  @Override
-  public KeyValue<byte[], List<Tuple>> bzmpop(double timeout, SortedSetOption option, int count, byte[]... keys) {
-    return executeCommand(commandObjects.bzmpop(timeout, option, count, keys));
-  }
-  // Sorted Set commands
-
-  // Geo commands
-  @Override
-  public long geoadd(String key, double longitude, double latitude, String member) {
-    return executeCommand(commandObjects.geoadd(key, longitude, latitude, member));
-  }
-
-  @Override
-  public long geoadd(String key, Map<String, GeoCoordinate> memberCoordinateMap) {
-    return executeCommand(commandObjects.geoadd(key, memberCoordinateMap));
-  }
-
-  @Override
-  public long geoadd(String key, GeoAddParams params, Map<String, GeoCoordinate> memberCoordinateMap) {
-    return executeCommand(commandObjects.geoadd(key, params, memberCoordinateMap));
-  }
-
-  @Override
-  public Double geodist(String key, String member1, String member2) {
-    return executeCommand(commandObjects.geodist(key, member1, member2));
-  }
-
-  @Override
-  public Double geodist(String key, String member1, String member2, GeoUnit unit) {
-    return executeCommand(commandObjects.geodist(key, member1, member2, unit));
-  }
-
-  @Override
-  public List<String> geohash(String key, String... members) {
-    return executeCommand(commandObjects.geohash(key, members));
-  }
-
-  @Override
-  public List<GeoCoordinate> geopos(String key, String... members) {
-    return executeCommand(commandObjects.geopos(key, members));
-  }
-
-  @Override
-  public long geoadd(byte[] key, double longitude, double latitude, byte[] member) {
-    return executeCommand(commandObjects.geoadd(key, longitude, latitude, member));
-  }
-
-  @Override
-  public long geoadd(byte[] key, Map<byte[], GeoCoordinate> memberCoordinateMap) {
-    return executeCommand(commandObjects.geoadd(key, memberCoordinateMap));
-  }
-
-  @Override
-  public long geoadd(byte[] key, GeoAddParams params, Map<byte[], GeoCoordinate> memberCoordinateMap) {
-    return executeCommand(commandObjects.geoadd(key, params, memberCoordinateMap));
-  }
-
-  @Override
-  public Double geodist(byte[] key, byte[] member1, byte[] member2) {
-    return executeCommand(commandObjects.geodist(key, member1, member2));
-  }
-
-  @Override
-  public Double geodist(byte[] key, byte[] member1, byte[] member2, GeoUnit unit) {
-    return executeCommand(commandObjects.geodist(key, member1, member2, unit));
-  }
-
-  @Override
-  public List<byte[]> geohash(byte[] key, byte[]... members) {
-    return executeCommand(commandObjects.geohash(key, members));
-  }
-
-  @Override
-  public List<GeoCoordinate> geopos(byte[] key, byte[]... members) {
-    return executeCommand(commandObjects.geopos(key, members));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadius(String key, double longitude, double latitude, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadius(key, longitude, latitude, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadius(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadius(key, longitude, latitude, radius, unit, param));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusReadonly(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit, param));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusByMember(String key, String member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadiusByMember(key, member, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusByMember(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadiusByMember(key, member, radius, unit, param));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusByMemberReadonly(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit, param));
-  }
-
-  @Override
-  public long georadiusStore(String key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
-    return executeCommand(commandObjects.georadiusStore(key, longitude, latitude, radius, unit, param, storeParam));
-  }
-
-  @Override
-  public long georadiusByMemberStore(String key, String member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
-    return executeCommand(commandObjects.georadiusByMemberStore(key, member, radius, unit, param, storeParam));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> geosearch(String key, String member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, member, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> geosearch(String key, GeoCoordinate coord, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, coord, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> geosearch(String key, String member, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, member, width, height, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> geosearch(String key, GeoCoordinate coord, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, coord, width, height, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> geosearch(String key, GeoSearchParam params) {
-    return executeCommand(commandObjects.geosearch(key, params));
-  }
-
-  @Override
-  public long geosearchStore(String dest, String src, String member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearchStore(dest, src, member, radius, unit));
-  }
-
-  @Override
-  public long geosearchStore(String dest, String src, GeoCoordinate coord, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearchStore(dest, src, coord, radius, unit));
-  }
-
-  @Override
-  public long geosearchStore(String dest, String src, String member, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearchStore(dest, src, member, width, height, unit));
-  }
-
-  @Override
-  public long geosearchStore(String dest, String src, GeoCoordinate coord, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearchStore(dest, src, coord, width, height, unit));
-  }
-
-  @Override
-  public long geosearchStore(String dest, String src, GeoSearchParam params) {
-    return executeCommand(commandObjects.geosearchStore(dest, src, params));
-  }
-
-  @Override
-  public long geosearchStoreStoreDist(String dest, String src, GeoSearchParam params) {
-    return executeCommand(commandObjects.geosearchStoreStoreDist(dest, src, params));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadius(key, longitude, latitude, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadius(key, longitude, latitude, radius, unit, param));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusReadonly(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadiusReadonly(key, longitude, latitude, radius, unit, param));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadiusByMember(key, member, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusByMember(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadiusByMember(key, member, radius, unit, param));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> georadiusByMemberReadonly(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param) {
-    return executeCommand(commandObjects.georadiusByMemberReadonly(key, member, radius, unit, param));
-  }
-
-  @Override
-  public long georadiusStore(byte[] key, double longitude, double latitude, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
-    return executeCommand(commandObjects.georadiusStore(key, longitude, latitude, radius, unit, param, storeParam));
-  }
-
-  @Override
-  public long georadiusByMemberStore(byte[] key, byte[] member, double radius, GeoUnit unit, GeoRadiusParam param, GeoRadiusStoreParam storeParam) {
-    return executeCommand(commandObjects.georadiusByMemberStore(key, member, radius, unit, param, storeParam));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> geosearch(byte[] key, byte[] member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, member, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, coord, radius, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> geosearch(byte[] key, byte[] member, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, member, width, height, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearch(key, coord, width, height, unit));
-  }
-
-  @Override
-  public List<GeoRadiusResponse> geosearch(byte[] key, GeoSearchParam params) {
-    return executeCommand(commandObjects.geosearch(key, params));
-  }
-
-  @Override
-  public long geosearchStore(byte[] dest, byte[] src, byte[] member, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearchStore(dest, src, member, radius, unit));
-  }
-
-  @Override
-  public long geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double radius, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearchStore(dest, src, coord, radius, unit));
-  }
-
-  @Override
-  public long geosearchStore(byte[] dest, byte[] src, byte[] member, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearchStore(dest, src, member, width, height, unit));
-  }
-
-  @Override
-  public long geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double width, double height, GeoUnit unit) {
-    return executeCommand(commandObjects.geosearchStore(dest, src, coord, width, height, unit));
-  }
-
-  @Override
-  public long geosearchStore(byte[] dest, byte[] src, GeoSearchParam params) {
-    return executeCommand(commandObjects.geosearchStore(dest, src, params));
-  }
-
-  @Override
-  public long geosearchStoreStoreDist(byte[] dest, byte[] src, GeoSearchParam params) {
-    return executeCommand(commandObjects.geosearchStoreStoreDist(dest, src, params));
-  }
-  // Geo commands
-
-  // Hyper Log Log commands
-  @Override
-  public long pfadd(String key, String... elements) {
-    return executeCommand(commandObjects.pfadd(key, elements));
-  }
-
-  @Override
-  public String pfmerge(String destkey, String... sourcekeys) {
-    return executeCommand(commandObjects.pfmerge(destkey, sourcekeys));
-  }
-
-  @Override
-  public long pfcount(String key) {
-    return executeCommand(commandObjects.pfcount(key));
-  }
-
-  @Override
-  public long pfcount(String... keys) {
-    return executeCommand(commandObjects.pfcount(keys));
-  }
-
-  @Override
-  public long pfadd(byte[] key, byte[]... elements) {
-    return executeCommand(commandObjects.pfadd(key, elements));
-  }
-
-  @Override
-  public String pfmerge(byte[] destkey, byte[]... sourcekeys) {
-    return executeCommand(commandObjects.pfmerge(destkey, sourcekeys));
-  }
-
-  @Override
-  public long pfcount(byte[] key) {
-    return executeCommand(commandObjects.pfcount(key));
-  }
-
-  @Override
-  public long pfcount(byte[]... keys) {
-    return executeCommand(commandObjects.pfcount(keys));
-  }
-  // Hyper Log Log commands
-
-  // Stream commands
-  @Override
-  public StreamEntryID xadd(String key, StreamEntryID id, Map<String, String> hash) {
-    return executeCommand(commandObjects.xadd(key, id, hash));
-  }
-
-  @Override
-  public StreamEntryID xadd(String key, XAddParams params, Map<String, String> hash) {
-    return executeCommand(commandObjects.xadd(key, params, hash));
-  }
-
-  @Override
-  public long xlen(String key) {
-    return executeCommand(commandObjects.xlen(key));
-  }
-
-  @Override
-  public List<StreamEntry> xrange(String key, StreamEntryID start, StreamEntryID end) {
-    return executeCommand(commandObjects.xrange(key, start, end));
-  }
-
-  @Override
-  public List<StreamEntry> xrange(String key, StreamEntryID start, StreamEntryID end, int count) {
-    return executeCommand(commandObjects.xrange(key, start, end, count));
-  }
-
-  @Override
-  public List<StreamEntry> xrevrange(String key, StreamEntryID end, StreamEntryID start) {
-    return executeCommand(commandObjects.xrevrange(key, end, start));
-  }
-
-  @Override
-  public List<StreamEntry> xrevrange(String key, StreamEntryID end, StreamEntryID start, int count) {
-    return executeCommand(commandObjects.xrevrange(key, end, start, count));
-  }
-
-  @Override
-  public List<StreamEntry> xrange(String key, String start, String end) {
-    return executeCommand(commandObjects.xrange(key, start, end));
-  }
-
-  @Override
-  public List<StreamEntry> xrange(String key, String start, String end, int count) {
-    return executeCommand(commandObjects.xrange(key, start, end, count));
-  }
-
-  @Override
-  public List<StreamEntry> xrevrange(String key, String end, String start) {
-    return executeCommand(commandObjects.xrevrange(key, end, start));
-  }
-
-  @Override
-  public List<StreamEntry> xrevrange(String key, String end, String start, int count) {
-    return executeCommand(commandObjects.xrevrange(key, end, start, count));
-  }
-
-  @Override
-  public long xack(String key, String group, StreamEntryID... ids) {
-    return executeCommand(commandObjects.xack(key, group, ids));
-  }
-
-  @Override
-  public String xgroupCreate(String key, String groupName, StreamEntryID id, boolean makeStream) {
-    return executeCommand(commandObjects.xgroupCreate(key, groupName, id, makeStream));
-  }
-
-  @Override
-  public String xgroupSetID(String key, String groupName, StreamEntryID id) {
-    return executeCommand(commandObjects.xgroupSetID(key, groupName, id));
-  }
-
-  @Override
-  public long xgroupDestroy(String key, String groupName) {
-    return executeCommand(commandObjects.xgroupDestroy(key, groupName));
-  }
-
-  @Override
-  public boolean xgroupCreateConsumer(String key, String groupName, String consumerName) {
-    return executeCommand(commandObjects.xgroupCreateConsumer(key, groupName, consumerName));
-  }
-
-  @Override
-  public long xgroupDelConsumer(String key, String groupName, String consumerName) {
-    return executeCommand(commandObjects.xgroupDelConsumer(key, groupName, consumerName));
-  }
-
-  @Override
-  public StreamPendingSummary xpending(String key, String groupName) {
-    return executeCommand(commandObjects.xpending(key, groupName));
-  }
-
-  @Override
-  public List<StreamPendingEntry> xpending(String key, String groupName, XPendingParams params) {
-    return executeCommand(commandObjects.xpending(key, groupName, params));
-  }
-
-  @Override
-  public long xdel(String key, StreamEntryID... ids) {
-    return executeCommand(commandObjects.xdel(key, ids));
-  }
-
-  @Override
-  public long xtrim(String key, long maxLen, boolean approximate) {
-    return executeCommand(commandObjects.xtrim(key, maxLen, approximate));
-  }
-
-  @Override
-  public long xtrim(String key, XTrimParams params) {
-    return executeCommand(commandObjects.xtrim(key, params));
-  }
-
-  @Override
-  public List<StreamEntry> xclaim(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids) {
-    return executeCommand(commandObjects.xclaim(key, group, consumerName, minIdleTime, params, ids));
-  }
-
-  @Override
-  public List<StreamEntryID> xclaimJustId(String key, String group, String consumerName, long minIdleTime, XClaimParams params, StreamEntryID... ids) {
-    return executeCommand(commandObjects.xclaimJustId(key, group, consumerName, minIdleTime, params, ids));
-  }
-
-  @Override
-  public Map.Entry<StreamEntryID, List<StreamEntry>> xautoclaim(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params) {
-    return executeCommand(commandObjects.xautoclaim(key, group, consumerName, minIdleTime, start, params));
-  }
-
-  @Override
-  public Map.Entry<StreamEntryID, List<StreamEntryID>> xautoclaimJustId(String key, String group, String consumerName, long minIdleTime, StreamEntryID start, XAutoClaimParams params) {
-    return executeCommand(commandObjects.xautoclaimJustId(key, group, consumerName, minIdleTime, start, params));
-  }
-
-  @Override
-  public StreamInfo xinfoStream(String key) {
-    return executeCommand(commandObjects.xinfoStream(key));
-  }
-
-  @Override
-  public StreamFullInfo xinfoStreamFull(String key) {
-    return executeCommand(commandObjects.xinfoStreamFull(key));
-  }
-
-  @Override
-  public StreamFullInfo xinfoStreamFull(String key, int count) {
-    return executeCommand(commandObjects.xinfoStreamFull(key, count));
-  }
-
-  @Override
-  public List<StreamGroupInfo> xinfoGroups(String key) {
-    return executeCommand(commandObjects.xinfoGroups(key));
-  }
-
-  @Override
-  public List<StreamConsumersInfo> xinfoConsumers(String key, String group) {
-    return executeCommand(commandObjects.xinfoConsumers(key, group));
-  }
-
-  @Override
-  public List<StreamConsumerInfo> xinfoConsumers2(String key, String group) {
-    return executeCommand(commandObjects.xinfoConsumers2(key, group));
-  }
-
-  @Override
-  public List<Map.Entry<String, List<StreamEntry>>> xread(XReadParams xReadParams, Map<String, StreamEntryID> streams) {
-    return executeCommand(commandObjects.xread(xReadParams, streams));
-  }
-
-  @Override
-  public Map<String, List<StreamEntry>> xreadAsMap(XReadParams xReadParams, Map<String, StreamEntryID> streams) {
-    return executeCommand(commandObjects.xreadAsMap(xReadParams, streams));
-  }
-
-  @Override
-  public List<Map.Entry<String, List<StreamEntry>>> xreadGroup(String groupName, String consumer, XReadGroupParams xReadGroupParams, Map<String, StreamEntryID> streams) {
-    return executeCommand(commandObjects.xreadGroup(groupName, consumer, xReadGroupParams, streams));
-  }
-
-  @Override
-  public Map<String, List<StreamEntry>> xreadGroupAsMap(String groupName, String consumer, XReadGroupParams xReadGroupParams, Map<String, StreamEntryID> streams) {
-    return executeCommand(commandObjects.xreadGroupAsMap(groupName, consumer, xReadGroupParams, streams));
-  }
-
-  @Override
-  public byte[] xadd(byte[] key, XAddParams params, Map<byte[], byte[]> hash) {
-    return executeCommand(commandObjects.xadd(key, params, hash));
-  }
-
-  @Override
-  public long xlen(byte[] key) {
-    return executeCommand(commandObjects.xlen(key));
-  }
-
-  @Override
-  public List<Object> xrange(byte[] key, byte[] start, byte[] end) {
-    return executeCommand(commandObjects.xrange(key, start, end));
-  }
-
-  @Override
-  public List<Object> xrange(byte[] key, byte[] start, byte[] end, int count) {
-    return executeCommand(commandObjects.xrange(key, start, end, count));
-  }
-
-  @Override
-  public List<Object> xrevrange(byte[] key, byte[] end, byte[] start) {
-    return executeCommand(commandObjects.xrevrange(key, end, start));
-  }
-
-  @Override
-  public List<Object> xrevrange(byte[] key, byte[] end, byte[] start, int count) {
-    return executeCommand(commandObjects.xrevrange(key, end, start, count));
-  }
-
-  @Override
-  public long xack(byte[] key, byte[] group, byte[]... ids) {
-    return executeCommand(commandObjects.xack(key, group, ids));
-  }
-
-  @Override
-  public String xgroupCreate(byte[] key, byte[] groupName, byte[] id, boolean makeStream) {
-    return executeCommand(commandObjects.xgroupCreate(key, groupName, id, makeStream));
-  }
-
-  @Override
-  public String xgroupSetID(byte[] key, byte[] groupName, byte[] id) {
-    return executeCommand(commandObjects.xgroupSetID(key, groupName, id));
-  }
-
-  @Override
-  public long xgroupDestroy(byte[] key, byte[] groupName) {
-    return executeCommand(commandObjects.xgroupDestroy(key, groupName));
-  }
-
-  @Override
-  public boolean xgroupCreateConsumer(byte[] key, byte[] groupName, byte[] consumerName) {
-    return executeCommand(commandObjects.xgroupCreateConsumer(key, groupName, consumerName));
-  }
-
-  @Override
-  public long xgroupDelConsumer(byte[] key, byte[] groupName, byte[] consumerName) {
-    return executeCommand(commandObjects.xgroupDelConsumer(key, groupName, consumerName));
-  }
-
-  @Override
-  public long xdel(byte[] key, byte[]... ids) {
-    return executeCommand(commandObjects.xdel(key, ids));
-  }
-
-  @Override
-  public long xtrim(byte[] key, long maxLen, boolean approximateLength) {
-    return executeCommand(commandObjects.xtrim(key, maxLen, approximateLength));
-  }
-
-  @Override
-  public long xtrim(byte[] key, XTrimParams params) {
-    return executeCommand(commandObjects.xtrim(key, params));
-  }
-
-  @Override
-  public Object xpending(byte[] key, byte[] groupName) {
-    return executeCommand(commandObjects.xpending(key, groupName));
-  }
-
-  @Override
-  public List<Object> xpending(byte[] key, byte[] groupName, XPendingParams params) {
-    return executeCommand(commandObjects.xpending(key, groupName, params));
-  }
-
-  @Override
-  public List<byte[]> xclaim(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids) {
-    return executeCommand(commandObjects.xclaim(key, group, consumerName, minIdleTime, params, ids));
-  }
-
-  @Override
-  public List<byte[]> xclaimJustId(byte[] key, byte[] group, byte[] consumerName, long minIdleTime, XClaimParams params, byte[]... ids) {
-    return executeCommand(commandObjects.xclaimJustId(key, group, consumerName, minIdleTime, params, ids));
-  }
-
-  @Override
-  public List<Object> xautoclaim(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params) {
-    return executeCommand(commandObjects.xautoclaim(key, groupName, consumerName, minIdleTime, start, params));
-  }
-
-  @Override
-  public List<Object> xautoclaimJustId(byte[] key, byte[] groupName, byte[] consumerName, long minIdleTime, byte[] start, XAutoClaimParams params) {
-    return executeCommand(commandObjects.xautoclaimJustId(key, groupName, consumerName, minIdleTime, start, params));
-  }
-
-  @Override
-  public Object xinfoStream(byte[] key) {
-    return executeCommand(commandObjects.xinfoStream(key));
-  }
-
-  @Override
-  public Object xinfoStreamFull(byte[] key) {
-    return executeCommand(commandObjects.xinfoStreamFull(key));
-  }
-
-  @Override
-  public Object xinfoStreamFull(byte[] key, int count) {
-    return executeCommand(commandObjects.xinfoStreamFull(key, count));
-  }
-
-  @Override
-  public List<Object> xinfoGroups(byte[] key) {
-    return executeCommand(commandObjects.xinfoGroups(key));
-  }
-
-  @Override
-  public List<Object> xinfoConsumers(byte[] key, byte[] group) {
-    return executeCommand(commandObjects.xinfoConsumers(key, group));
-  }
-
-  /**
-   * @deprecated As of Jedis 6.1.0, use
-   *     {@link #xreadBinary(XReadParams, Map)} or
-   *     {@link #xreadBinaryAsMap(XReadParams, Map)} for type safety and better stream entry
-   *     parsing.
-   */
-  @Deprecated
-  @Override
-  public List<Object> xread(XReadParams xReadParams, Map.Entry<byte[], byte[]>... streams) {
-    return executeCommand(commandObjects.xread(xReadParams, streams));
-  }
-
-  /**
-   * @deprecated As of Jedis 6.1.0, use
-   *     {@link #xreadGroupBinary(byte[], byte[], XReadGroupParams, Map)} or
-   *     {@link #xreadGroupBinaryAsMap(byte[], byte[], XReadGroupParams, Map)} instead.
-   */
-  @Deprecated
-  @Override
-  public List<Object> xreadGroup(byte[] groupName, byte[] consumer,
-      XReadGroupParams xReadGroupParams, Map.Entry<byte[], byte[]>... streams) {
-    return executeCommand(
-        commandObjects.xreadGroup(groupName, consumer, xReadGroupParams, streams));
-  }
-
-  @Override
-  public List<Map.Entry<byte[], List<StreamEntryBinary>>> xreadBinary(XReadParams xReadParams,
-      Map<byte[], StreamEntryID> streams) {
-    return executeCommand(commandObjects.xreadBinary(xReadParams, streams));
-  }
-
-  @Override
-  public Map<byte[], List<StreamEntryBinary>> xreadBinaryAsMap(XReadParams xReadParams,
-      Map<byte[], StreamEntryID> streams) {
-    return executeCommand(commandObjects.xreadBinaryAsMap(xReadParams, streams));
-  }
-
-  @Override
-  public List<Map.Entry<byte[], List<StreamEntryBinary>>> xreadGroupBinary(byte[] groupName,
-      byte[] consumer, XReadGroupParams xReadGroupParams, Map<byte[], StreamEntryID> streams) {
-    return executeCommand(
-        commandObjects.xreadGroupBinary(groupName, consumer, xReadGroupParams, streams));
-  }
-
-  @Override
-  public Map<byte[], List<StreamEntryBinary>> xreadGroupBinaryAsMap(byte[] groupName,
-      byte[] consumer, XReadGroupParams xReadGroupParams, Map<byte[], StreamEntryID> streams) {
-    return executeCommand(
-        commandObjects.xreadGroupBinaryAsMap(groupName, consumer, xReadGroupParams, streams));
-  }
-  // Stream commands
-
-  // Scripting commands
-  @Override
-  public Object eval(String script) {
-    return executeCommand(commandObjects.eval(script));
-  }
-
-  @Override
-  public Object eval(String script, int keyCount, String... params) {
-    return executeCommand(commandObjects.eval(script, keyCount, params));
-  }
-
-  @Override
-  public Object eval(String script, List<String> keys, List<String> args) {
-    return executeCommand(commandObjects.eval(script, keys, args));
-  }
-
-  @Override
-  public Object evalReadonly(String script, List<String> keys, List<String> args) {
-    return executeCommand(commandObjects.evalReadonly(script, keys, args));
-  }
-
-  @Override
-  public Object evalsha(String sha1) {
-    return executeCommand(commandObjects.evalsha(sha1));
-  }
-
-  @Override
-  public Object evalsha(String sha1, int keyCount, String... params) {
-    return executeCommand(commandObjects.evalsha(sha1, keyCount, params));
-  }
-
-  @Override
-  public Object evalsha(String sha1, List<String> keys, List<String> args) {
-    return executeCommand(commandObjects.evalsha(sha1, keys, args));
-  }
-
-  @Override
-  public Object evalshaReadonly(String sha1, List<String> keys, List<String> args) {
-    return executeCommand(commandObjects.evalshaReadonly(sha1, keys, args));
-  }
-
-  @Override
-  public Object eval(byte[] script) {
-    return executeCommand(commandObjects.eval(script));
-  }
-
-  @Override
-  public Object eval(byte[] script, int keyCount, byte[]... params) {
-    return executeCommand(commandObjects.eval(script, keyCount, params));
-  }
-
-  @Override
-  public Object eval(byte[] script, List<byte[]> keys, List<byte[]> args) {
-    return executeCommand(commandObjects.eval(script, keys, args));
-  }
-
-  @Override
-  public Object evalReadonly(byte[] script, List<byte[]> keys, List<byte[]> args) {
-    return executeCommand(commandObjects.evalReadonly(script, keys, args));
-  }
-
-  @Override
-  public Object evalsha(byte[] sha1) {
-    return executeCommand(commandObjects.evalsha(sha1));
-  }
-
-  @Override
-  public Object evalsha(byte[] sha1, int keyCount, byte[]... params) {
-    return executeCommand(commandObjects.evalsha(sha1, keyCount, params));
-  }
-
-  @Override
-  public Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args) {
-    return executeCommand(commandObjects.evalsha(sha1, keys, args));
-  }
-
-  @Override
-  public Object evalshaReadonly(byte[] sha1, List<byte[]> keys, List<byte[]> args) {
-    return executeCommand(commandObjects.evalshaReadonly(sha1, keys, args));
-  }
-
-  @Override
-  public Object fcall(String name, List<String> keys, List<String> args) {
-    return executeCommand(commandObjects.fcall(name, keys, args));
-  }
-
-  @Override
-  public Object fcallReadonly(String name, List<String> keys, List<String> args) {
-    return executeCommand(commandObjects.fcallReadonly(name, keys, args));
-  }
-
-  @Override
-  public String functionDelete(String libraryName) {
-    return checkAndBroadcastCommand(commandObjects.functionDelete(libraryName));
-  }
-
-  @Override
-  public String functionFlush() {
-    return checkAndBroadcastCommand(commandObjects.functionFlush());
-  }
-
-  @Override
-  public String functionFlush(FlushMode mode) {
-    return checkAndBroadcastCommand(commandObjects.functionFlush(mode));
-  }
-
-  @Override
-  public String functionKill() {
-    return checkAndBroadcastCommand(commandObjects.functionKill());
-  }
-
-  @Override
-  public List<LibraryInfo> functionList() {
-    return executeCommand(commandObjects.functionList());
-  }
-
-  @Override
-  public List<LibraryInfo> functionList(String libraryNamePattern) {
-    return executeCommand(commandObjects.functionList(libraryNamePattern));
-  }
-
-  @Override
-  public List<LibraryInfo> functionListWithCode() {
-    return executeCommand(commandObjects.functionListWithCode());
-  }
-
-  @Override
-  public List<LibraryInfo> functionListWithCode(String libraryNamePattern) {
-    return executeCommand(commandObjects.functionListWithCode(libraryNamePattern));
-  }
-
-  @Override
-  public String functionLoad(String functionCode) {
-    return checkAndBroadcastCommand(commandObjects.functionLoad(functionCode));
-  }
-
-  @Override
-  public String functionLoadReplace(String functionCode) {
-    return checkAndBroadcastCommand(commandObjects.functionLoadReplace(functionCode));
-  }
-
-  @Override
-  public FunctionStats functionStats() {
-    return executeCommand(commandObjects.functionStats());
-  }
-
-  @Override
-  public Object fcall(byte[] name, List<byte[]> keys, List<byte[]> args) {
-    return executeCommand(commandObjects.fcall(name, keys, args));
-  }
-
-  @Override
-  public Object fcallReadonly(byte[] name, List<byte[]> keys, List<byte[]> args) {
-    return executeCommand(commandObjects.fcallReadonly(name, keys, args));
-  }
-
-  @Override
-  public String functionDelete(byte[] libraryName) {
-    return checkAndBroadcastCommand(commandObjects.functionDelete(libraryName));
-  }
-
-  @Override
-  public byte[] functionDump() {
-    return executeCommand(commandObjects.functionDump());
-  }
-
-  @Override
-  public List<Object> functionListBinary() {
-    return executeCommand(commandObjects.functionListBinary());
-  }
-
-  @Override
-  public List<Object> functionList(final byte[] libraryNamePattern) {
-    return executeCommand(commandObjects.functionList(libraryNamePattern));
-  }
-
-  @Override
-  public List<Object> functionListWithCodeBinary() {
-    return executeCommand(commandObjects.functionListWithCodeBinary());
-  }
-
-  @Override
-  public List<Object> functionListWithCode(final byte[] libraryNamePattern) {
-    return executeCommand(commandObjects.functionListWithCode(libraryNamePattern));
-  }
-
-  @Override
-  public String functionLoad(byte[] functionCode) {
-    return checkAndBroadcastCommand(commandObjects.functionLoad(functionCode));
-  }
-
-  @Override
-  public String functionLoadReplace(byte[] functionCode) {
-    return checkAndBroadcastCommand(commandObjects.functionLoadReplace(functionCode));
-  }
-
-  @Override
-  public String functionRestore(byte[] serializedValue) {
-    return checkAndBroadcastCommand(commandObjects.functionRestore(serializedValue));
-  }
-
-  @Override
-  public String functionRestore(byte[] serializedValue, FunctionRestorePolicy policy) {
-    return checkAndBroadcastCommand(commandObjects.functionRestore(serializedValue, policy));
-  }
-
-  @Override
-  public Object functionStatsBinary() {
-    return executeCommand(commandObjects.functionStatsBinary());
-  }
-  // Scripting commands
-
-  // Other key commands
-  @Override
-  public Long objectRefcount(String key) {
-    return executeCommand(commandObjects.objectRefcount(key));
-  }
-
-  @Override
-  public String objectEncoding(String key) {
-    return executeCommand(commandObjects.objectEncoding(key));
-  }
-
-  @Override
-  public Long objectIdletime(String key) {
-    return executeCommand(commandObjects.objectIdletime(key));
-  }
-
-  @Override
-  public Long objectFreq(String key) {
-    return executeCommand(commandObjects.objectFreq(key));
-  }
-
-  @Override
-  public Long objectRefcount(byte[] key) {
-    return executeCommand(commandObjects.objectRefcount(key));
-  }
-
-  @Override
-  public byte[] objectEncoding(byte[] key) {
-    return executeCommand(commandObjects.objectEncoding(key));
-  }
-
-  @Override
-  public Long objectIdletime(byte[] key) {
-    return executeCommand(commandObjects.objectIdletime(key));
-  }
-
-  @Override
-  public Long objectFreq(byte[] key) {
-    return executeCommand(commandObjects.objectFreq(key));
-  }
-
-  @Override
-  public String migrate(String host, int port, String key, int timeout) {
-    return executeCommand(commandObjects.migrate(host, port, key, timeout));
-  }
-
-  @Override
-  public String migrate(String host, int port, int timeout, MigrateParams params, String... keys) {
-    return executeCommand(commandObjects.migrate(host, port, timeout, params, keys));
-  }
-
-  @Override
-  public String migrate(String host, int port, byte[] key, int timeout) {
-    return executeCommand(commandObjects.migrate(host, port, key, timeout));
-  }
-
-  @Override
-  public String migrate(String host, int port, int timeout, MigrateParams params, byte[]... keys) {
-    return executeCommand(commandObjects.migrate(host, port, timeout, params, keys));
-  }
-  // Other key commands
-
-  // Sample key commands
-  @Override
-  public long waitReplicas(String sampleKey, int replicas, long timeout) {
-    return executeCommand(commandObjects.waitReplicas(sampleKey, replicas, timeout));
-  }
-
-  @Override
-  public long waitReplicas(byte[] sampleKey, int replicas, long timeout) {
-    return executeCommand(commandObjects.waitReplicas(sampleKey, replicas, timeout));
-  }
-
-  @Override
-  public KeyValue<Long, Long> waitAOF(String sampleKey, long numLocal, long numReplicas, long timeout) {
-    return executeCommand(commandObjects.waitAOF(sampleKey, numLocal, numReplicas, timeout));
-  }
-
-  @Override
-  public KeyValue<Long, Long> waitAOF(byte[] sampleKey, long numLocal, long numReplicas, long timeout) {
-    return executeCommand(commandObjects.waitAOF(sampleKey, numLocal, numReplicas, timeout));
-  }
-
-  @Override
-  public Object eval(String script, String sampleKey) {
-    return executeCommand(commandObjects.eval(script, sampleKey));
-  }
-
-  @Override
-  public Object evalsha(String sha1, String sampleKey) {
-    return executeCommand(commandObjects.evalsha(sha1, sampleKey));
-  }
-
-  @Override
-  public Object eval(byte[] script, byte[] sampleKey) {
-    return executeCommand(commandObjects.eval(script, sampleKey));
-  }
-
-  @Override
-  public Object evalsha(byte[] sha1, byte[] sampleKey) {
-    return executeCommand(commandObjects.evalsha(sha1, sampleKey));
-  }
-
-  public List<Boolean> scriptExists(List<String> sha1s) {
-    return checkAndBroadcastCommand(commandObjects.scriptExists(sha1s));
-  }
-
-  @Override
-  public Boolean scriptExists(String sha1, String sampleKey) {
-    return scriptExists(sampleKey, new String[] { sha1 }).get(0);
-  }
-
-  @Override
-  public List<Boolean> scriptExists(String sampleKey, String... sha1s) {
-    return executeCommand(commandObjects.scriptExists(sampleKey, sha1s));
-  }
-
-  @Override
-  public Boolean scriptExists(byte[] sha1, byte[] sampleKey) {
-    return scriptExists(sampleKey, new byte[][] { sha1 }).get(0);
-  }
-
-  @Override
-  public List<Boolean> scriptExists(byte[] sampleKey, byte[]... sha1s) {
-    return executeCommand(commandObjects.scriptExists(sampleKey, sha1s));
-  }
-
-  public String scriptLoad(String script) {
-    return checkAndBroadcastCommand(commandObjects.scriptLoad(script));
-  }
-
-  @Override
-  public String scriptLoad(String script, String sampleKey) {
-    return executeCommand(commandObjects.scriptLoad(script, sampleKey));
-  }
-
-  public String scriptFlush() {
-    return checkAndBroadcastCommand(commandObjects.scriptFlush());
-  }
-
-  @Override
-  public String scriptFlush(String sampleKey) {
-    return executeCommand(commandObjects.scriptFlush(sampleKey));
-  }
-
-  @Override
-  public String scriptFlush(String sampleKey, FlushMode flushMode) {
-    return executeCommand(commandObjects.scriptFlush(sampleKey, flushMode));
-  }
-
-  public String scriptKill() {
-    return checkAndBroadcastCommand(commandObjects.scriptKill());
-  }
-
-  @Override
-  public String scriptKill(String sampleKey) {
-    return executeCommand(commandObjects.scriptKill(sampleKey));
-  }
-
-  @Override
-  public byte[] scriptLoad(byte[] script, byte[] sampleKey) {
-    return executeCommand(commandObjects.scriptLoad(script, sampleKey));
-  }
-
-  @Override
-  public String scriptFlush(byte[] sampleKey) {
-    return executeCommand(commandObjects.scriptFlush(sampleKey));
-  }
-
-  @Override
-  public String scriptFlush(byte[] sampleKey, FlushMode flushMode) {
-    return executeCommand(commandObjects.scriptFlush(sampleKey, flushMode));
-  }
-
-  @Override
-  public String scriptKill(byte[] sampleKey) {
-    return executeCommand(commandObjects.scriptKill(sampleKey));
-  }
-
-  public String slowlogReset() {
-    return checkAndBroadcastCommand(commandObjects.slowlogReset());
-  }
-  // Sample key commands
-
-  // Random node commands
-  public long publish(String channel, String message) {
-    return executeCommand(commandObjects.publish(channel, message));
-  }
-
-  public long publish(byte[] channel, byte[] message) {
-    return executeCommand(commandObjects.publish(channel, message));
-  }
-
-  public void subscribe(final JedisPubSub jedisPubSub, final String... channels) {
-    try (Connection connection = this.provider.getConnection()) {
-      jedisPubSub.proceed(connection, channels);
-    }
-  }
-
-  public void psubscribe(final JedisPubSub jedisPubSub, final String... patterns) {
-    try (Connection connection = this.provider.getConnection()) {
-      jedisPubSub.proceedWithPatterns(connection, patterns);
-    }
-  }
-
-  public void subscribe(BinaryJedisPubSub jedisPubSub, final byte[]... channels) {
-    try (Connection connection = this.provider.getConnection()) {
-      jedisPubSub.proceed(connection, channels);
-    }
-  }
-
-  public void psubscribe(BinaryJedisPubSub jedisPubSub, final byte[]... patterns) {
-    try (Connection connection = this.provider.getConnection()) {
-      jedisPubSub.proceedWithPatterns(connection, patterns);
-    }
-  }
-  // Random node commands
-
-  // RediSearch commands
-  public long hsetObject(String key, String field, Object value) {
-    return executeCommand(commandObjects.hsetObject(key, field, value));
-  }
-
-  public long hsetObject(String key, Map<String, Object> hash) {
-    return executeCommand(commandObjects.hsetObject(key, hash));
-  }
-
-  @Override
-  public String ftCreate(String indexName, IndexOptions indexOptions, Schema schema) {
-    return checkAndBroadcastCommand(commandObjects.ftCreate(indexName, indexOptions, schema));
-  }
-
-  @Override
-  public String ftCreate(String indexName, FTCreateParams createParams, Iterable<SchemaField> schemaFields) {
-    return checkAndBroadcastCommand(commandObjects.ftCreate(indexName, createParams, schemaFields));
-  }
-
-  @Override
-  public String ftAlter(String indexName, Schema schema) {
-    return checkAndBroadcastCommand(commandObjects.ftAlter(indexName, schema));
-  }
-
-  @Override
-  public String ftAlter(String indexName, Iterable<SchemaField> schemaFields) {
-    return checkAndBroadcastCommand(commandObjects.ftAlter(indexName, schemaFields));
-  }
-
-  @Override
-  public String ftAliasAdd(String aliasName, String indexName) {
-    return checkAndBroadcastCommand(commandObjects.ftAliasAdd(aliasName, indexName));
-  }
-
-  @Override
-  public String ftAliasUpdate(String aliasName, String indexName) {
-    return checkAndBroadcastCommand(commandObjects.ftAliasUpdate(aliasName, indexName));
-  }
-
-  @Override
-  public String ftAliasDel(String aliasName) {
-    return checkAndBroadcastCommand(commandObjects.ftAliasDel(aliasName));
-  }
-
-  @Override
-  public String ftDropIndex(String indexName) {
-    return checkAndBroadcastCommand(commandObjects.ftDropIndex(indexName));
-  }
-
-  @Override
-  public String ftDropIndexDD(String indexName) {
-    return checkAndBroadcastCommand(commandObjects.ftDropIndexDD(indexName));
-  }
-
-  @Override
-  public SearchResult ftSearch(String indexName, String query) {
-    return executeCommand(commandObjects.ftSearch(indexName, query));
-  }
-
-  @Override
-  public SearchResult ftSearch(String indexName, String query, FTSearchParams params) {
-    return executeCommand(commandObjects.ftSearch(indexName, query, params));
-  }
-
-  /**
-   * {@link FTSearchParams#limit(int, int)} will be ignored.
-   * 
-   * @param batchSize batch size
-   * @param indexName index name
-   * @param query query
-   * @param params limit will be ignored
-   * @return search iteration
-   */
-  public FtSearchIteration ftSearchIteration(int batchSize, String indexName, String query, FTSearchParams params) {
-    return new FtSearchIteration(provider, commandObjects.getProtocol(), batchSize, indexName, query, params);
-  }
-
-  @Override
-  public SearchResult ftSearch(String indexName, Query query) {
-    return executeCommand(commandObjects.ftSearch(indexName, query));
-  }
-
-  /**
-   * {@link Query#limit(java.lang.Integer, java.lang.Integer)} will be ignored.
-   * @param batchSize batch size
-   * @param indexName index name
-   * @param query limit will be ignored
-   * @return search iteration
-   */
-  public FtSearchIteration ftSearchIteration(int batchSize, String indexName, Query query) {
-    return new FtSearchIteration(provider, commandObjects.getProtocol(), batchSize, indexName, query);
-  }
-
-  @Override
-  @Deprecated
-  public SearchResult ftSearch(byte[] indexName, Query query) {
-    return executeCommand(commandObjects.ftSearch(indexName, query));
-  }
-
-  @Override
-  public String ftExplain(String indexName, Query query) {
-    return executeCommand(commandObjects.ftExplain(indexName, query));
-  }
-
-  @Override
-  public List<String> ftExplainCLI(String indexName, Query query) {
-    return executeCommand(commandObjects.ftExplainCLI(indexName, query));
-  }
-
-  @Override
-  public AggregationResult ftAggregate(String indexName, AggregationBuilder aggr) {
-    return executeCommand(commandObjects.ftAggregate(indexName, aggr));
-  }
-
-  @Override
-  public AggregationResult ftCursorRead(String indexName, long cursorId, int count) {
-    return executeCommand(commandObjects.ftCursorRead(indexName, cursorId, count));
-  }
-
-  @Override
-  public String ftCursorDel(String indexName, long cursorId) {
-    return executeCommand(commandObjects.ftCursorDel(indexName, cursorId));
-  }
-
-  /**
-   * {@link AggregationBuilder#cursor(int, long) CURSOR} must be set.
-   * @param indexName index name
-   * @param aggr cursor must be set
-   * @return aggregate iteration
-   */
-  public FtAggregateIteration ftAggregateIteration(String indexName, AggregationBuilder aggr) {
-    return new FtAggregateIteration(provider, indexName, aggr);
-  }
-
-  @Override
-  public Map.Entry<AggregationResult, ProfilingInfo> ftProfileAggregate(String indexName,
-      FTProfileParams profileParams, AggregationBuilder aggr) {
-    return executeCommand(commandObjects.ftProfileAggregate(indexName, profileParams, aggr));
-  }
-
-  @Override
-  public Map.Entry<SearchResult, ProfilingInfo> ftProfileSearch(String indexName,
-      FTProfileParams profileParams, Query query) {
-    return executeCommand(commandObjects.ftProfileSearch(indexName, profileParams, query));
-  }
-
-  @Override
-  public Map.Entry<SearchResult, ProfilingInfo> ftProfileSearch(String indexName,
-      FTProfileParams profileParams, String query, FTSearchParams searchParams) {
-    return executeCommand(commandObjects.ftProfileSearch(indexName, profileParams, query, searchParams));
-  }
-
-  @Override
-  public String ftSynUpdate(String indexName, String synonymGroupId, String... terms) {
-    return executeCommand(commandObjects.ftSynUpdate(indexName, synonymGroupId, terms));
-  }
-
-  @Override
-  public Map<String, List<String>> ftSynDump(String indexName) {
-    return executeCommand(commandObjects.ftSynDump(indexName));
-  }
-
-  @Override
-  public long ftDictAdd(String dictionary, String... terms) {
-    return executeCommand(commandObjects.ftDictAdd(dictionary, terms));
-  }
-
-  @Override
-  public long ftDictDel(String dictionary, String... terms) {
-    return executeCommand(commandObjects.ftDictDel(dictionary, terms));
-  }
-
-  @Override
-  public Set<String> ftDictDump(String dictionary) {
-    return executeCommand(commandObjects.ftDictDump(dictionary));
-  }
-
-  @Override
-  public long ftDictAddBySampleKey(String indexName, String dictionary, String... terms) {
-    return executeCommand(commandObjects.ftDictAddBySampleKey(indexName, dictionary, terms));
-  }
-
-  @Override
-  public long ftDictDelBySampleKey(String indexName, String dictionary, String... terms) {
-    return executeCommand(commandObjects.ftDictDelBySampleKey(indexName, dictionary, terms));
-  }
-
-  @Override
-  public Set<String> ftDictDumpBySampleKey(String indexName, String dictionary) {
-    return executeCommand(commandObjects.ftDictDumpBySampleKey(indexName, dictionary));
-  }
-
-  @Override
-  public Map<String, Map<String, Double>> ftSpellCheck(String index, String query) {
-    return executeCommand(commandObjects.ftSpellCheck(index, query));
-  }
-
-  @Override
-  public Map<String, Map<String, Double>> ftSpellCheck(String index, String query,
-      FTSpellCheckParams spellCheckParams) {
-    return executeCommand(commandObjects.ftSpellCheck(index, query, spellCheckParams));
-  }
-
-  @Override
-  public Map<String, Object> ftInfo(String indexName) {
-    return executeCommand(commandObjects.ftInfo(indexName));
-  }
-
-  @Override
-  public Set<String> ftTagVals(String indexName, String fieldName) {
-    return executeCommand(commandObjects.ftTagVals(indexName, fieldName));
-  }
-
-  @Override
-  @Deprecated
-  public Map<String, Object> ftConfigGet(String option) {
-    return executeCommand(commandObjects.ftConfigGet(option));
-  }
-
-  @Override
-  @Deprecated
-  public Map<String, Object> ftConfigGet(String indexName, String option) {
-    return executeCommand(commandObjects.ftConfigGet(indexName, option));
-  }
-
-  @Override
-  @Deprecated
-  public String ftConfigSet(String option, String value) {
-    return executeCommand(commandObjects.ftConfigSet(option, value));
-  }
-
-  @Override
-  @Deprecated
-  public String ftConfigSet(String indexName, String option, String value) {
-    return executeCommand(commandObjects.ftConfigSet(indexName, option, value));
-  }
-
-  @Override
-  public long ftSugAdd(String key, String string, double score) {
-    return executeCommand(commandObjects.ftSugAdd(key, string, score));
-  }
-
-  @Override
-  public long ftSugAddIncr(String key, String string, double score) {
-    return executeCommand(commandObjects.ftSugAddIncr(key, string, score));
-  }
-
-  @Override
-  public List<String> ftSugGet(String key, String prefix) {
-    return executeCommand(commandObjects.ftSugGet(key, prefix));
-  }
-
-  @Override
-  public List<String> ftSugGet(String key, String prefix, boolean fuzzy, int max) {
-    return executeCommand(commandObjects.ftSugGet(key, prefix, fuzzy, max));
-  }
-
-  @Override
-  public List<Tuple> ftSugGetWithScores(String key, String prefix) {
-    return executeCommand(commandObjects.ftSugGetWithScores(key, prefix));
-  }
-
-  @Override
-  public List<Tuple> ftSugGetWithScores(String key, String prefix, boolean fuzzy, int max) {
-    return executeCommand(commandObjects.ftSugGetWithScores(key, prefix, fuzzy, max));
-  }
-
-  @Override
-  public boolean ftSugDel(String key, String string) {
-    return executeCommand(commandObjects.ftSugDel(key, string));
-  }
-
-  @Override
-  public long ftSugLen(String key) {
-    return executeCommand(commandObjects.ftSugLen(key));
-  }
-
-  @Override
-  public Set<String> ftList() {
-    return executeCommand(commandObjects.ftList());
-  }
-  // RediSearch commands
-
-  // RedisJSON commands
-  @Override
-  public String jsonSet(String key, Path2 path, Object object) {
-    return executeCommand(commandObjects.jsonSet(key, path, object));
-  }
-
-  @Override
-  public String jsonSetWithEscape(String key, Path2 path, Object object) {
-    return executeCommand(commandObjects.jsonSetWithEscape(key, path, object));
-  }
-
-  @Override
-  @Deprecated
-  public String jsonSet(String key, Path path, Object pojo) {
-    return executeCommand(commandObjects.jsonSet(key, path, pojo));
-  }
-
-  @Override
-  @Deprecated
-  public String jsonSetWithPlainString(String key, Path path, String string) {
-    return executeCommand(commandObjects.jsonSetWithPlainString(key, path, string));
-  }
-
-  @Override
-  public String jsonSet(String key, Path2 path, Object pojo, JsonSetParams params) {
-    return executeCommand(commandObjects.jsonSet(key, path, pojo, params));
-  }
-
-  @Override
-  public String jsonSetWithEscape(String key, Path2 path, Object pojo, JsonSetParams params) {
-    return executeCommand(commandObjects.jsonSetWithEscape(key, path, pojo, params));
-  }
-
-  @Override
-  @Deprecated
-  public String jsonSet(String key, Path path, Object pojo, JsonSetParams params) {
-    return executeCommand(commandObjects.jsonSet(key, path, pojo, params));
-  }
-
-  @Override
-  public String jsonMerge(String key, Path2 path, Object object) {
-    return executeCommand(commandObjects.jsonMerge(key, path, object));
-  }
-
-  @Override
-  @Deprecated
-  public String jsonMerge(String key, Path path, Object pojo) {
-    return executeCommand(commandObjects.jsonMerge(key, path, pojo));
-  }
-
-  @Override
-  public Object jsonGet(String key) {
-    return executeCommand(commandObjects.jsonGet(key));
-  }
-
-  @Override
-  @Deprecated
-  public <T> T jsonGet(String key, Class<T> clazz) {
-    return executeCommand(commandObjects.jsonGet(key, clazz));
-  }
-
-  @Override
-  public Object jsonGet(String key, Path2... paths) {
-    return executeCommand(commandObjects.jsonGet(key, paths));
-  }
-
-  @Override
-  @Deprecated
-  public Object jsonGet(String key, Path... paths) {
-    return executeCommand(commandObjects.jsonGet(key, paths));
-  }
-
-  @Override
-  @Deprecated
-  public String jsonGetAsPlainString(String key, Path path) {
-    return executeCommand(commandObjects.jsonGetAsPlainString(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public <T> T jsonGet(String key, Class<T> clazz, Path... paths) {
-    return executeCommand(commandObjects.jsonGet(key, clazz, paths));
-  }
-
-  @Override
-  public List<JSONArray> jsonMGet(Path2 path, String... keys) {
-    return executeCommand(commandObjects.jsonMGet(path, keys));
-  }
-
-  @Override
-  @Deprecated
-  public <T> List<T> jsonMGet(Path path, Class<T> clazz, String... keys) {
-    return executeCommand(commandObjects.jsonMGet(path, clazz, keys));
-  }
-
-  @Override
-  public long jsonDel(String key) {
-    return executeCommand(commandObjects.jsonDel(key));
-  }
-
-  @Override
-  public long jsonDel(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonDel(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public long jsonDel(String key, Path path) {
-    return executeCommand(commandObjects.jsonDel(key, path));
-  }
-
-  @Override
-  public long jsonClear(String key) {
-    return executeCommand(commandObjects.jsonClear(key));
-  }
-
-  @Override
-  public long jsonClear(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonClear(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public long jsonClear(String key, Path path) {
-    return executeCommand(commandObjects.jsonClear(key, path));
-  }
-
-  @Override
-  public List<Boolean> jsonToggle(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonToggle(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public String jsonToggle(String key, Path path) {
-    return executeCommand(commandObjects.jsonToggle(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public Class<?> jsonType(String key) {
-    return executeCommand(commandObjects.jsonType(key));
-  }
-
-  @Override
-  public List<Class<?>> jsonType(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonType(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public Class<?> jsonType(String key, Path path) {
-    return executeCommand(commandObjects.jsonType(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public long jsonStrAppend(String key, Object string) {
-    return executeCommand(commandObjects.jsonStrAppend(key, string));
-  }
-
-  @Override
-  public List<Long> jsonStrAppend(String key, Path2 path, Object string) {
-    return executeCommand(commandObjects.jsonStrAppend(key, path, string));
-  }
-
-  @Override
-  @Deprecated
-  public long jsonStrAppend(String key, Path path, Object string) {
-    return executeCommand(commandObjects.jsonStrAppend(key, path, string));
-  }
-
-  @Override
-  @Deprecated
-  public Long jsonStrLen(String key) {
-    return executeCommand(commandObjects.jsonStrLen(key));
-  }
-
-  @Override
-  public List<Long> jsonStrLen(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonStrLen(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public Long jsonStrLen(String key, Path path) {
-    return executeCommand(commandObjects.jsonStrLen(key, path));
-  }
-
-  @Override
-  public Object jsonNumIncrBy(String key, Path2 path, double value) {
-    return executeCommand(commandObjects.jsonNumIncrBy(key, path, value));
-  }
-
-  @Override
-  @Deprecated
-  public double jsonNumIncrBy(String key, Path path, double value) {
-    return executeCommand(commandObjects.jsonNumIncrBy(key, path, value));
-  }
-
-  @Override
-  public List<Long> jsonArrAppend(String key, Path2 path, Object... objects) {
-    return executeCommand(commandObjects.jsonArrAppend(key, path, objects));
-  }
-
-  @Override
-  public List<Long> jsonArrAppendWithEscape(String key, Path2 path, Object... objects) {
-    return executeCommand(commandObjects.jsonArrAppendWithEscape(key, path, objects));
-  }
-
-  @Override
-  @Deprecated
-  public Long jsonArrAppend(String key, Path path, Object... pojos) {
-    return executeCommand(commandObjects.jsonArrAppend(key, path, pojos));
-  }
-
-  @Override
-  public List<Long> jsonArrIndex(String key, Path2 path, Object scalar) {
-    return executeCommand(commandObjects.jsonArrIndex(key, path, scalar));
-  }
-
-  @Override
-  public List<Long> jsonArrIndexWithEscape(String key, Path2 path, Object scalar) {
-    return executeCommand(commandObjects.jsonArrIndexWithEscape(key, path, scalar));
-  }
-
-  @Override
-  @Deprecated
-  public long jsonArrIndex(String key, Path path, Object scalar) {
-    return executeCommand(commandObjects.jsonArrIndex(key, path, scalar));
-  }
-
-  @Override
-  public List<Long> jsonArrInsert(String key, Path2 path, int index, Object... objects) {
-    return executeCommand(commandObjects.jsonArrInsert(key, path, index, objects));
-  }
-
-  @Override
-  public List<Long> jsonArrInsertWithEscape(String key, Path2 path, int index, Object... objects) {
-    return executeCommand(commandObjects.jsonArrInsertWithEscape(key, path, index, objects));
-  }
-
-  @Override
-  @Deprecated
-  public long jsonArrInsert(String key, Path path, int index, Object... pojos) {
-    return executeCommand(commandObjects.jsonArrInsert(key, path, index, pojos));
-  }
-
-  @Override
-  @Deprecated
-  public Object jsonArrPop(String key) {
-    return executeCommand(commandObjects.jsonArrPop(key));
-  }
-
-  @Override
-  @Deprecated
-  public <T> T jsonArrPop(String key, Class<T> clazz) {
-    return executeCommand(commandObjects.jsonArrPop(key, clazz));
-  }
-
-  @Override
-  public List<Object> jsonArrPop(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonArrPop(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public Object jsonArrPop(String key, Path path) {
-    return executeCommand(commandObjects.jsonArrPop(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public <T> T jsonArrPop(String key, Class<T> clazz, Path path) {
-    return executeCommand(commandObjects.jsonArrPop(key, clazz, path));
-  }
-
-  @Override
-  public List<Object> jsonArrPop(String key, Path2 path, int index) {
-    return executeCommand(commandObjects.jsonArrPop(key, path, index));
-  }
-
-  @Override
-  @Deprecated
-  public Object jsonArrPop(String key, Path path, int index) {
-    return executeCommand(commandObjects.jsonArrPop(key, path, index));
-  }
-
-  @Override
-  @Deprecated
-  public <T> T jsonArrPop(String key, Class<T> clazz, Path path, int index) {
-    return executeCommand(commandObjects.jsonArrPop(key, clazz, path, index));
-  }
-
-  @Override
-  @Deprecated
-  public Long jsonArrLen(String key) {
-    return executeCommand(commandObjects.jsonArrLen(key));
-  }
-
-  @Override
-  public List<Long> jsonArrLen(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonArrLen(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public Long jsonArrLen(String key, Path path) {
-    return executeCommand(commandObjects.jsonArrLen(key, path));
-  }
-
-  @Override
-  public List<Long> jsonArrTrim(String key, Path2 path, int start, int stop) {
-    return executeCommand(commandObjects.jsonArrTrim(key, path, start, stop));
-  }
-
-  @Override
-  @Deprecated
-  public Long jsonArrTrim(String key, Path path, int start, int stop) {
-    return executeCommand(commandObjects.jsonArrTrim(key, path, start, stop));
-  }
-
-  @Override
-  @Deprecated
-  public Long jsonObjLen(String key) {
-    return executeCommand(commandObjects.jsonObjLen(key));
-  }
-
-  @Override
-  @Deprecated
-  public Long jsonObjLen(String key, Path path) {
-    return executeCommand(commandObjects.jsonObjLen(key, path));
-  }
-
-  @Override
-  public List<Long> jsonObjLen(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonObjLen(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public List<String> jsonObjKeys(String key) {
-    return executeCommand(commandObjects.jsonObjKeys(key));
-  }
-
-  @Override
-  @Deprecated
-  public List<String> jsonObjKeys(String key, Path path) {
-    return executeCommand(commandObjects.jsonObjKeys(key, path));
-  }
-
-  @Override
-  public List<List<String>> jsonObjKeys(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonObjKeys(key, path));
-  }
-
-  @Override
-  @Deprecated
-  public long jsonDebugMemory(String key) {
-    return executeCommand(commandObjects.jsonDebugMemory(key));
-  }
-
-  @Override
-  @Deprecated
-  public long jsonDebugMemory(String key, Path path) {
-    return executeCommand(commandObjects.jsonDebugMemory(key, path));
-  }
-
-  @Override
-  public List<Long> jsonDebugMemory(String key, Path2 path) {
-    return executeCommand(commandObjects.jsonDebugMemory(key, path));
-  }
-  // RedisJSON commands
-
-  // RedisTimeSeries commands
-  @Override
-  public String tsCreate(String key) {
-    return executeCommand(commandObjects.tsCreate(key));
-  }
-
-  @Override
-  public String tsCreate(String key, TSCreateParams createParams) {
-    return executeCommand(commandObjects.tsCreate(key, createParams));
-  }
-
-  @Override
-  public long tsDel(String key, long fromTimestamp, long toTimestamp) {
-    return executeCommand(commandObjects.tsDel(key, fromTimestamp, toTimestamp));
-  }
-
-  @Override
-  public String tsAlter(String key, TSAlterParams alterParams) {
-    return executeCommand(commandObjects.tsAlter(key, alterParams));
-  }
-
-  @Override
-  public long tsAdd(String key, double value) {
-    return executeCommand(commandObjects.tsAdd(key, value));
-  }
-
-  @Override
-  public long tsAdd(String key, long timestamp, double value) {
-    return executeCommand(commandObjects.tsAdd(key, timestamp, value));
-  }
-
-  @Override
-  public long tsAdd(String key, long timestamp, double value, TSCreateParams createParams) {
-    return executeCommand(commandObjects.tsAdd(key, timestamp, value, createParams));
-  }
-
-  @Override
-  public long tsAdd(String key, long timestamp, double value, TSAddParams addParams) {
-    return executeCommand(commandObjects.tsAdd(key, timestamp, value, addParams));
-  }
-
-  @Override
-  public List<Long> tsMAdd(Map.Entry<String, TSElement>... entries) {
-    return executeCommand(commandObjects.tsMAdd(entries));
-  }
-
-  @Override
-  public long tsIncrBy(String key, double value) {
-    return executeCommand(commandObjects.tsIncrBy(key, value));
-  }
-
-  @Override
-  public long tsIncrBy(String key, double value, long timestamp) {
-    return executeCommand(commandObjects.tsIncrBy(key, value, timestamp));
-  }
-
-  @Override
-  public long tsIncrBy(String key, double addend, TSIncrByParams incrByParams) {
-    return executeCommand(commandObjects.tsIncrBy(key, addend, incrByParams));
-  }
-
-  @Override
-  public long tsDecrBy(String key, double value) {
-    return executeCommand(commandObjects.tsDecrBy(key, value));
-  }
-
-  @Override
-  public long tsDecrBy(String key, double value, long timestamp) {
-    return executeCommand(commandObjects.tsDecrBy(key, value, timestamp));
-  }
-
-  @Override
-  public long tsDecrBy(String key, double subtrahend, TSDecrByParams decrByParams) {
-    return executeCommand(commandObjects.tsDecrBy(key, subtrahend, decrByParams));
-  }
-
-  @Override
-  public List<TSElement> tsRange(String key, long fromTimestamp, long toTimestamp) {
-    return executeCommand(commandObjects.tsRange(key, fromTimestamp, toTimestamp));
-  }
-
-  @Override
-  public List<TSElement> tsRange(String key, TSRangeParams rangeParams) {
-    return executeCommand(commandObjects.tsRange(key, rangeParams));
-  }
-
-  @Override
-  public List<TSElement> tsRevRange(String key, long fromTimestamp, long toTimestamp) {
-    return executeCommand(commandObjects.tsRevRange(key, fromTimestamp, toTimestamp));
-  }
-
-  @Override
-  public List<TSElement> tsRevRange(String key, TSRangeParams rangeParams) {
-    return executeCommand(commandObjects.tsRevRange(key, rangeParams));
-  }
-
-  @Override
-  public Map<String, TSMRangeElements> tsMRange(long fromTimestamp, long toTimestamp, String... filters) {
-    return executeCommand(commandObjects.tsMRange(fromTimestamp, toTimestamp, filters));
-  }
-
-  @Override
-  public Map<String, TSMRangeElements> tsMRange(TSMRangeParams multiRangeParams) {
-    return executeCommand(commandObjects.tsMRange(multiRangeParams));
-  }
-
-  @Override
-  public Map<String, TSMRangeElements> tsMRevRange(long fromTimestamp, long toTimestamp, String... filters) {
-    return executeCommand(commandObjects.tsMRevRange(fromTimestamp, toTimestamp, filters));
-  }
-
-  @Override
-  public Map<String, TSMRangeElements> tsMRevRange(TSMRangeParams multiRangeParams) {
-    return executeCommand(commandObjects.tsMRevRange(multiRangeParams));
-  }
-
-  @Override
-  public TSElement tsGet(String key) {
-    return executeCommand(commandObjects.tsGet(key));
-  }
-
-  @Override
-  public TSElement tsGet(String key, TSGetParams getParams) {
-    return executeCommand(commandObjects.tsGet(key, getParams));
-  }
-
-  @Override
-  public Map<String, TSMGetElement> tsMGet(TSMGetParams multiGetParams, String... filters) {
-    return executeCommand(commandObjects.tsMGet(multiGetParams, filters));
-  }
-
-  @Override
-  public String tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long timeBucket) {
-    return executeCommand(commandObjects.tsCreateRule(sourceKey, destKey, aggregationType, timeBucket));
-  }
-
-  @Override
-  public String tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long bucketDuration, long alignTimestamp) {
-    return executeCommand(
-        commandObjects.tsCreateRule(sourceKey, destKey, aggregationType, bucketDuration, alignTimestamp));
-  }
-
-  @Override
-  public String tsDeleteRule(String sourceKey, String destKey) {
-    return executeCommand(commandObjects.tsDeleteRule(sourceKey, destKey));
-  }
-
-  @Override
-  public List<String> tsQueryIndex(String... filters) {
-    return executeCommand(commandObjects.tsQueryIndex(filters));
-  }
-
-  @Override
-  public TSInfo tsInfo(String key) {
-    return executeCommand(commandObjects.tsInfo(key));
-  }
-
-  @Override
-  public TSInfo tsInfoDebug(String key) {
-    return executeCommand(commandObjects.tsInfoDebug(key));
-  }
-  // RedisTimeSeries commands
-
-  // RedisBloom commands
   @Override
-  public String bfReserve(String key, double errorRate, long capacity) {
-    return executeCommand(commandObjects.bfReserve(key, errorRate, capacity));
+  protected CommandObjects getCommandObjects() {
+    return commandObjects;
   }
 
   @Override
-  public String bfReserve(String key, double errorRate, long capacity, BFReserveParams reserveParams) {
-    return executeCommand(commandObjects.bfReserve(key, errorRate, capacity, reserveParams));
+  protected ConnectionProvider getConnectionProvider() {
+    return provider;
   }
 
   @Override
-  public boolean bfAdd(String key, String item) {
-    return executeCommand(commandObjects.bfAdd(key, item));
+  public final <T> T executeCommand(CommandObject<T> commandObject) {
+    return executor.executeCommand(commandObject);
   }
 
-  @Override
-  public List<Boolean> bfMAdd(String key, String... items) {
-    return executeCommand(commandObjects.bfMAdd(key, items));
+  public Object executeCommand(CommandArguments args) {
+    return executeCommand(new CommandObject<>(args, BuilderFactory.RAW_OBJECT));
   }
 
   @Override
-  public List<Boolean> bfInsert(String key, String... items) {
-    return executeCommand(commandObjects.bfInsert(key, items));
+  public final <T> T broadcastCommand(CommandObject<T> commandObject) {
+    return executor.broadcastCommand(commandObject);
   }
 
   @Override
-  public List<Boolean> bfInsert(String key, BFInsertParams insertParams, String... items) {
-    return executeCommand(commandObjects.bfInsert(key, insertParams, items));
-  }
+  protected <T> T checkAndBroadcastCommand(CommandObject<T> commandObject) {
+    boolean broadcast = true;
 
-  @Override
-  public boolean bfExists(String key, String item) {
-    return executeCommand(commandObjects.bfExists(key, item));
-  }
+    if (broadcastAndRoundRobinConfig == null) {
+    } else if (commandObject.getArguments().getCommand() instanceof SearchProtocol.SearchCommand
+        && broadcastAndRoundRobinConfig
+            .getRediSearchModeInCluster() == JedisBroadcastAndRoundRobinConfig.RediSearchMode.LIGHT) {
+      broadcast = false;
+    }
 
-  @Override
-  public List<Boolean> bfMExists(String key, String... items) {
-    return executeCommand(commandObjects.bfMExists(key, items));
+    return broadcast ? broadcastCommand(commandObject) : executeCommand(commandObject);
   }
 
-  @Override
-  public Map.Entry<Long, byte[]> bfScanDump(String key, long iterator) {
-    return executeCommand(commandObjects.bfScanDump(key, iterator));
+  public void setBroadcastAndRoundRobinConfig(JedisBroadcastAndRoundRobinConfig config) {
+    this.broadcastAndRoundRobinConfig = config;
+    this.commandObjects.setBroadcastAndRoundRobinConfig(this.broadcastAndRoundRobinConfig);
   }
 
   @Override
-  public String bfLoadChunk(String key, long iterator, byte[] data) {
-    return executeCommand(commandObjects.bfLoadChunk(key, iterator, data));
+  public Cache getCache() {
+    return cache;
   }
 
-  @Override
-  public long bfCard(String key) {
-    return executeCommand(commandObjects.bfCard(key));
+  // String commands
+  /**
+   * @deprecated Use {@link UnifiedJedis#setGet(java.lang.String, java.lang.String)}.
+   */
+  @Deprecated
+  public String getSet(String key, String value) {
+    return executeCommand(commandObjects.getSet(key, value));
   }
 
-  @Override
-  public Map<String, Object> bfInfo(String key) {
-    return executeCommand(commandObjects.bfInfo(key));
+  /**
+   * @deprecated Use {@link UnifiedJedis#setGet(byte[], byte[])}.
+   */
+  @Deprecated
+  public byte[] getSet(byte[] key, byte[] value) {
+    return executeCommand(commandObjects.getSet(key, value));
   }
 
-  @Override
-  public String cfReserve(String key, long capacity) {
-    return executeCommand(commandObjects.cfReserve(key, capacity));
+  // Sorted Set commands
+  @Deprecated
+  public long zdiffStore(String dstkey, String... keys) {
+    return executeCommand(commandObjects.zdiffStore(dstkey, keys));
   }
 
-  @Override
-  public String cfReserve(String key, long capacity, CFReserveParams reserveParams) {
-    return executeCommand(commandObjects.cfReserve(key, capacity, reserveParams));
+  @Deprecated
+  public long zdiffStore(byte[] dstkey, byte[]... keys) {
+    return executeCommand(commandObjects.zdiffStore(dstkey, keys));
   }
+  // Sorted Set commands
 
-  @Override
-  public boolean cfAdd(String key, String item) {
-    return executeCommand(commandObjects.cfAdd(key, item));
+  // Stream commands
+  /**
+   * @deprecated As of Jedis 6.1.0, use
+   *     {@link #xreadBinary(XReadParams, Map)} or
+   *     {@link #xreadBinaryAsMap(XReadParams, Map)} for type safety and better stream entry
+   *     parsing.
+   */
+  @Deprecated
+  public List<Object> xread(XReadParams xReadParams, Map.Entry<byte[], byte[]>... streams) {
+    return executeCommand(commandObjects.xread(xReadParams, streams));
   }
 
-  @Override
-  public boolean cfAddNx(String key, String item) {
-    return executeCommand(commandObjects.cfAddNx(key, item));
+  /**
+   * @deprecated As of Jedis 6.1.0, use
+   *     {@link #xreadGroupBinary(byte[], byte[], XReadGroupParams, Map)} or
+   *     {@link #xreadGroupBinaryAsMap(byte[], byte[], XReadGroupParams, Map)} instead.
+   */
+  @Deprecated
+  public List<Object> xreadGroup(byte[] groupName, byte[] consumer,
+      XReadGroupParams xReadGroupParams, Map.Entry<byte[], byte[]>... streams) {
+    return executeCommand(
+        commandObjects.xreadGroup(groupName, consumer, xReadGroupParams, streams));
   }
+  // Stream commands
 
-  @Override
-  public List<Boolean> cfInsert(String key, String... items) {
-    return executeCommand(commandObjects.cfInsert(key, items));
+  // RediSearch commands
+  @Deprecated
+  public SearchResult ftSearch(byte[] indexName, Query query) {
+    return executeCommand(commandObjects.ftSearch(indexName, query));
   }
 
-  @Override
-  public List<Boolean> cfInsert(String key, CFInsertParams insertParams, String... items) {
-    return executeCommand(commandObjects.cfInsert(key, insertParams, items));
+  @Deprecated
+  public Map<String, Object> ftConfigGet(String option) {
+    return executeCommand(commandObjects.ftConfigGet(option));
   }
 
-  @Override
-  public List<Boolean> cfInsertNx(String key, String... items) {
-    return executeCommand(commandObjects.cfInsertNx(key, items));
+  @Deprecated
+  public Map<String, Object> ftConfigGet(String indexName, String option) {
+    return executeCommand(commandObjects.ftConfigGet(indexName, option));
   }
 
-  @Override
-  public List<Boolean> cfInsertNx(String key, CFInsertParams insertParams, String... items) {
-    return executeCommand(commandObjects.cfInsertNx(key, insertParams, items));
+  @Deprecated
+  public String ftConfigSet(String option, String value) {
+    return executeCommand(commandObjects.ftConfigSet(option, value));
   }
 
-  @Override
-  public boolean cfExists(String key, String item) {
-    return executeCommand(commandObjects.cfExists(key, item));
+  @Deprecated
+  public String ftConfigSet(String indexName, String option, String value) {
+    return executeCommand(commandObjects.ftConfigSet(indexName, option, value));
   }
+  // RediSearch commands
 
+  // RedisJSON commands
   @Override
-  public List<Boolean> cfMExists(String key, String... items) {
-    return executeCommand(commandObjects.cfMExists(key, items));
+  @Deprecated
+  public String jsonSet(String key, Path path, Object pojo) {
+    return executeCommand(commandObjects.jsonSet(key, path, pojo));
   }
 
   @Override
-  public boolean cfDel(String key, String item) {
-    return executeCommand(commandObjects.cfDel(key, item));
+  @Deprecated
+  public String jsonSetWithPlainString(String key, Path path, String string) {
+    return executeCommand(commandObjects.jsonSetWithPlainString(key, path, string));
   }
 
   @Override
-  public long cfCount(String key, String item) {
-    return executeCommand(commandObjects.cfCount(key, item));
+  @Deprecated
+  public String jsonSet(String key, Path path, Object pojo, JsonSetParams params) {
+    return executeCommand(commandObjects.jsonSet(key, path, pojo, params));
   }
 
   @Override
-  public Map.Entry<Long, byte[]> cfScanDump(String key, long iterator) {
-    return executeCommand(commandObjects.cfScanDump(key, iterator));
+  @Deprecated
+  public String jsonMerge(String key, Path path, Object pojo) {
+    return executeCommand(commandObjects.jsonMerge(key, path, pojo));
   }
 
   @Override
-  public String cfLoadChunk(String key, long iterator, byte[] data) {
-    return executeCommand(commandObjects.cfLoadChunk(key, iterator, data));
+  @Deprecated
+  public <T> T jsonGet(String key, Class<T> clazz) {
+    return executeCommand(commandObjects.jsonGet(key, clazz));
   }
 
   @Override
-  public Map<String, Object> cfInfo(String key) {
-    return executeCommand(commandObjects.cfInfo(key));
+  @Deprecated
+  public Object jsonGet(String key, Path... paths) {
+    return executeCommand(commandObjects.jsonGet(key, paths));
   }
 
   @Override
-  public String cmsInitByDim(String key, long width, long depth) {
-    return executeCommand(commandObjects.cmsInitByDim(key, width, depth));
+  @Deprecated
+  public String jsonGetAsPlainString(String key, Path path) {
+    return executeCommand(commandObjects.jsonGetAsPlainString(key, path));
   }
 
   @Override
-  public String cmsInitByProb(String key, double error, double probability) {
-    return executeCommand(commandObjects.cmsInitByProb(key, error, probability));
+  @Deprecated
+  public <T> T jsonGet(String key, Class<T> clazz, Path... paths) {
+    return executeCommand(commandObjects.jsonGet(key, clazz, paths));
   }
 
   @Override
-  public List<Long> cmsIncrBy(String key, Map<String, Long> itemIncrements) {
-    return executeCommand(commandObjects.cmsIncrBy(key, itemIncrements));
+  @Deprecated
+  public <T> List<T> jsonMGet(Path path, Class<T> clazz, String... keys) {
+    return executeCommand(commandObjects.jsonMGet(path, clazz, keys));
   }
 
   @Override
-  public List<Long> cmsQuery(String key, String... items) {
-    return executeCommand(commandObjects.cmsQuery(key, items));
+  @Deprecated
+  public long jsonDel(String key, Path path) {
+    return executeCommand(commandObjects.jsonDel(key, path));
   }
 
   @Override
-  public String cmsMerge(String destKey, String... keys) {
-    return executeCommand(commandObjects.cmsMerge(destKey, keys));
+  @Deprecated
+  public long jsonClear(String key, Path path) {
+    return executeCommand(commandObjects.jsonClear(key, path));
   }
 
   @Override
-  public String cmsMerge(String destKey, Map<String, Long> keysAndWeights) {
-    return executeCommand(commandObjects.cmsMerge(destKey, keysAndWeights));
+  @Deprecated
+  public String jsonToggle(String key, Path path) {
+    return executeCommand(commandObjects.jsonToggle(key, path));
   }
 
   @Override
-  public Map<String, Object> cmsInfo(String key) {
-    return executeCommand(commandObjects.cmsInfo(key));
+  @Deprecated
+  public Class<?> jsonType(String key) {
+    return executeCommand(commandObjects.jsonType(key));
   }
 
   @Override
-  public String topkReserve(String key, long topk) {
-    return executeCommand(commandObjects.topkReserve(key, topk));
+  @Deprecated
+  public Class<?> jsonType(String key, Path path) {
+    return executeCommand(commandObjects.jsonType(key, path));
   }
 
   @Override
-  public String topkReserve(String key, long topk, long width, long depth, double decay) {
-    return executeCommand(commandObjects.topkReserve(key, topk, width, depth, decay));
+  @Deprecated
+  public long jsonStrAppend(String key, Object string) {
+    return executeCommand(commandObjects.jsonStrAppend(key, string));
   }
 
   @Override
-  public List<String> topkAdd(String key, String... items) {
-    return executeCommand(commandObjects.topkAdd(key, items));
+  @Deprecated
+  public long jsonStrAppend(String key, Path path, Object string) {
+    return executeCommand(commandObjects.jsonStrAppend(key, path, string));
   }
 
   @Override
-  public List<String> topkIncrBy(String key, Map<String, Long> itemIncrements) {
-    return executeCommand(commandObjects.topkIncrBy(key, itemIncrements));
+  @Deprecated
+  public Long jsonStrLen(String key) {
+    return executeCommand(commandObjects.jsonStrLen(key));
   }
 
   @Override
-  public List<Boolean> topkQuery(String key, String... items) {
-    return executeCommand(commandObjects.topkQuery(key, items));
+  @Deprecated
+  public Long jsonStrLen(String key, Path path) {
+    return executeCommand(commandObjects.jsonStrLen(key, path));
   }
 
   @Override
-  public List<String> topkList(String key) {
-    return executeCommand(commandObjects.topkList(key));
+  @Deprecated
+  public double jsonNumIncrBy(String key, Path path, double value) {
+    return executeCommand(commandObjects.jsonNumIncrBy(key, path, value));
   }
 
   @Override
-  public Map<String, Long> topkListWithCount(String key) {
-    return executeCommand(commandObjects.topkListWithCount(key));
+  @Deprecated
+  public Long jsonArrAppend(String key, Path path, Object... pojos) {
+    return executeCommand(commandObjects.jsonArrAppend(key, path, pojos));
   }
 
   @Override
-  public Map<String, Object> topkInfo(String key) {
-    return executeCommand(commandObjects.topkInfo(key));
+  @Deprecated
+  public long jsonArrIndex(String key, Path path, Object scalar) {
+    return executeCommand(commandObjects.jsonArrIndex(key, path, scalar));
   }
 
   @Override
-  public String tdigestCreate(String key) {
-    return executeCommand(commandObjects.tdigestCreate(key));
+  @Deprecated
+  public long jsonArrInsert(String key, Path path, int index, Object... pojos) {
+    return executeCommand(commandObjects.jsonArrInsert(key, path, index, pojos));
   }
 
   @Override
-  public String tdigestCreate(String key, int compression) {
-    return executeCommand(commandObjects.tdigestCreate(key, compression));
+  @Deprecated
+  public Object jsonArrPop(String key) {
+    return executeCommand(commandObjects.jsonArrPop(key));
   }
 
   @Override
-  public String tdigestReset(String key) {
-    return executeCommand(commandObjects.tdigestReset(key));
+  @Deprecated
+  public <T> T jsonArrPop(String key, Class<T> clazz) {
+    return executeCommand(commandObjects.jsonArrPop(key, clazz));
   }
 
   @Override
-  public String tdigestMerge(String destinationKey, String... sourceKeys) {
-    return executeCommand(commandObjects.tdigestMerge(destinationKey, sourceKeys));
+  @Deprecated
+  public Object jsonArrPop(String key, Path path) {
+    return executeCommand(commandObjects.jsonArrPop(key, path));
   }
 
   @Override
-  public String tdigestMerge(TDigestMergeParams mergeParams, String destinationKey, String... sourceKeys) {
-    return executeCommand(commandObjects.tdigestMerge(mergeParams, destinationKey, sourceKeys));
+  @Deprecated
+  public <T> T jsonArrPop(String key, Class<T> clazz, Path path) {
+    return executeCommand(commandObjects.jsonArrPop(key, clazz, path));
   }
 
   @Override
-  public Map<String, Object> tdigestInfo(String key) {
-    return executeCommand(commandObjects.tdigestInfo(key));
+  @Deprecated
+  public Object jsonArrPop(String key, Path path, int index) {
+    return executeCommand(commandObjects.jsonArrPop(key, path, index));
   }
 
   @Override
-  public String tdigestAdd(String key, double... values) {
-    return executeCommand(commandObjects.tdigestAdd(key, values));
+  @Deprecated
+  public <T> T jsonArrPop(String key, Class<T> clazz, Path path, int index) {
+    return executeCommand(commandObjects.jsonArrPop(key, clazz, path, index));
   }
 
   @Override
-  public List<Double> tdigestCDF(String key, double... values) {
-    return executeCommand(commandObjects.tdigestCDF(key, values));
+  @Deprecated
+  public Long jsonArrLen(String key) {
+    return executeCommand(commandObjects.jsonArrLen(key));
   }
 
   @Override
-  public List<Double> tdigestQuantile(String key, double... quantiles) {
-    return executeCommand(commandObjects.tdigestQuantile(key, quantiles));
+  @Deprecated
+  public Long jsonArrLen(String key, Path path) {
+    return executeCommand(commandObjects.jsonArrLen(key, path));
   }
 
   @Override
-  public double tdigestMin(String key) {
-    return executeCommand(commandObjects.tdigestMin(key));
+  @Deprecated
+  public Long jsonArrTrim(String key, Path path, int start, int stop) {
+    return executeCommand(commandObjects.jsonArrTrim(key, path, start, stop));
   }
 
   @Override
-  public double tdigestMax(String key) {
-    return executeCommand(commandObjects.tdigestMax(key));
+  @Deprecated
+  public Long jsonObjLen(String key) {
+    return executeCommand(commandObjects.jsonObjLen(key));
   }
 
   @Override
-  public double tdigestTrimmedMean(String key, double lowCutQuantile, double highCutQuantile) {
-    return executeCommand(commandObjects.tdigestTrimmedMean(key, lowCutQuantile, highCutQuantile));
+  @Deprecated
+  public Long jsonObjLen(String key, Path path) {
+    return executeCommand(commandObjects.jsonObjLen(key, path));
   }
 
   @Override
-  public List<Long> tdigestRank(String key, double... values) {
-    return executeCommand(commandObjects.tdigestRank(key, values));
+  @Deprecated
+  public List<String> jsonObjKeys(String key) {
+    return executeCommand(commandObjects.jsonObjKeys(key));
   }
 
   @Override
-  public List<Long> tdigestRevRank(String key, double... values) {
-    return executeCommand(commandObjects.tdigestRevRank(key, values));
+  @Deprecated
+  public List<String> jsonObjKeys(String key, Path path) {
+    return executeCommand(commandObjects.jsonObjKeys(key, path));
   }
 
   @Override
-  public List<Double> tdigestByRank(String key, long... ranks) {
-    return executeCommand(commandObjects.tdigestByRank(key, ranks));
+  @Deprecated
+  public long jsonDebugMemory(String key) {
+    return executeCommand(commandObjects.jsonDebugMemory(key));
   }
 
   @Override
-  public List<Double> tdigestByRevRank(String key, long... ranks) {
-    return executeCommand(commandObjects.tdigestByRevRank(key, ranks));
+  @Deprecated
+  public long jsonDebugMemory(String key, Path path) {
+    return executeCommand(commandObjects.jsonDebugMemory(key, path));
   }
-  // RedisBloom commands
+  // RedisJSON commands
 
   /**
-   * @return pipeline object. Use {@link AbstractPipeline} instead of {@link PipelineBase}.
+   * @return pipeline object.
    */
-  public PipelineBase pipelined() {
+  @Override
+  public AbstractPipeline pipelined() {
     if (provider == null) {
       throw new IllegalStateException("It is not allowed to create Pipeline from this " + getClass());
     } else if (provider instanceof MultiClusterPooledConnectionProvider) {
@@ -5061,6 +659,7 @@ public PipelineBase pipelined() {
   /**
    * @return transaction object
    */
+  @Override
   public AbstractTransaction multi() {
     return transaction(true);
   }
@@ -5069,6 +668,7 @@ public AbstractTransaction multi() {
    * @param doMulti {@code false} should be set to enable manual WATCH, UNWATCH and MULTI
    * @return transaction object
    */
+  @Override
   public AbstractTransaction transaction(boolean doMulti) {
     if (provider == null) {
       throw new IllegalStateException("It is not allowed to create Transaction from this " + getClass());
@@ -5079,48 +679,6 @@ public AbstractTransaction transaction(boolean doMulti) {
     }
   }
 
-  public Object sendCommand(ProtocolCommand cmd) {
-    return executeCommand(commandObjects.commandArguments(cmd));
-  }
-
-  public Object sendCommand(ProtocolCommand cmd, byte[]... args) {
-    return executeCommand(commandObjects.commandArguments(cmd).addObjects((Object[]) args));
-  }
-
-  public Object sendBlockingCommand(ProtocolCommand cmd, byte[]... args) {
-    return executeCommand(commandObjects.commandArguments(cmd).addObjects((Object[]) args).blocking());
-  }
-
-  public Object sendCommand(ProtocolCommand cmd, String... args) {
-    return executeCommand(commandObjects.commandArguments(cmd).addObjects((Object[]) args));
-  }
-
-  public Object sendBlockingCommand(ProtocolCommand cmd, String... args) {
-    return executeCommand(commandObjects.commandArguments(cmd).addObjects((Object[]) args).blocking());
-  }
-
-  public Object sendCommand(byte[] sampleKey, ProtocolCommand cmd, byte[]... args) {
-    return executeCommand(commandObjects.commandArguments(cmd).addObjects((Object[]) args).processKey(sampleKey));
-  }
-
-  public Object sendBlockingCommand(byte[] sampleKey, ProtocolCommand cmd, byte[]... args) {
-    return executeCommand(
-        commandObjects.commandArguments(cmd).addObjects((Object[]) args).blocking().processKey(sampleKey));
-  }
-
-  public Object sendCommand(String sampleKey, ProtocolCommand cmd, String... args) {
-    return executeCommand(commandObjects.commandArguments(cmd).addObjects((Object[]) args).processKey(sampleKey));
-  }
-
-  public Object sendBlockingCommand(String sampleKey, ProtocolCommand cmd, String... args) {
-    return executeCommand(
-        commandObjects.commandArguments(cmd).addObjects((Object[]) args).blocking().processKey(sampleKey));
-  }
-
-  public Object executeCommand(CommandArguments args) {
-    return executeCommand(new CommandObject<>(args, BuilderFactory.RAW_OBJECT));
-  }
-
   @Experimental
   public void setKeyArgumentPreProcessor(CommandKeyArgumentPreProcessor keyPreProcessor) {
     this.commandObjects.setKeyArgumentPreProcessor(keyPreProcessor);
diff --git a/src/main/java/redis/clients/jedis/commands/ClusterCommands.java b/src/main/java/redis/clients/jedis/commands/ClusterCommands.java
index 4ad918d12b..f9527ea6d1 100644
--- a/src/main/java/redis/clients/jedis/commands/ClusterCommands.java
+++ b/src/main/java/redis/clients/jedis/commands/ClusterCommands.java
@@ -66,28 +66,12 @@ public interface ClusterCommands {
 
   String clusterReplicate(String nodeId);
 
-  /**
-   * {@code CLUSTER SLAVES} command is deprecated since Redis 5.
-   *
-   * @deprecated Use {@link ClusterCommands#clusterReplicas(java.lang.String)}.
-   */
-  @Deprecated
-  List<String> clusterSlaves(String nodeId);
-
   List<String> clusterReplicas(String nodeId);
 
   String clusterFailover();
 
   String clusterFailover(ClusterFailoverOption failoverOption);
 
-  /**
-   * {@code CLUSTER SLOTS} command is deprecated since Redis 7.
-   *
-   * @deprecated Use {@link ClusterCommands#clusterShards()}.
-   */
-  @Deprecated
-  List<Object> clusterSlots();
-
   /**
    * {@code CLUSTER SHARDS} returns details about the shards of the cluster.
    * This command replaces the {@code CLUSTER SLOTS} command from Redis 7,
diff --git a/src/main/java/redis/clients/jedis/commands/SortedSetBinaryCommands.java b/src/main/java/redis/clients/jedis/commands/SortedSetBinaryCommands.java
index e9cb38a616..cda9a939ad 100644
--- a/src/main/java/redis/clients/jedis/commands/SortedSetBinaryCommands.java
+++ b/src/main/java/redis/clients/jedis/commands/SortedSetBinaryCommands.java
@@ -137,12 +137,6 @@ default ScanResult<Tuple> zscan(byte[] key, byte[] cursor) {
 
   List<Tuple> zdiffWithScores(byte[]... keys);
 
-  /**
-   * @deprecated Use {@link #zdiffstore(byte[], byte[][])}.
-   */
-  @Deprecated
-  long zdiffStore(byte[] dstkey, byte[]... keys);
-
   long zdiffstore(byte[] dstkey, byte[]... keys);
 
   List<byte[]> zinter(ZParams params, byte[]... keys);
diff --git a/src/main/java/redis/clients/jedis/commands/SortedSetCommands.java b/src/main/java/redis/clients/jedis/commands/SortedSetCommands.java
index 65bf4daa67..f8c1255c94 100644
--- a/src/main/java/redis/clients/jedis/commands/SortedSetCommands.java
+++ b/src/main/java/redis/clients/jedis/commands/SortedSetCommands.java
@@ -694,16 +694,6 @@ default ScanResult<Tuple> zscan(String key, String cursor) {
    */
   List<Tuple> zdiffWithScores(String... keys);
 
-  /**
-   * Compute the difference between all the sets in the given keys. Store the result in dstkey.
-   * @param dstkey
-   * @param keys group of sets
-   * @return The number of elements in the resulting sorted set at dstkey.
-   * @deprecated Use {@link #zdiffstore(java.lang.String, java.lang.String...)}.
-   */
-  @Deprecated
-  long zdiffStore(String dstkey, String... keys);
-
   /**
    * Compute the difference between all the sets in the given keys. Store the result in dstkey.
    * @param dstkey
diff --git a/src/main/java/redis/clients/jedis/commands/StreamBinaryCommands.java b/src/main/java/redis/clients/jedis/commands/StreamBinaryCommands.java
index 5db025ef2d..57a0753bae 100644
--- a/src/main/java/redis/clients/jedis/commands/StreamBinaryCommands.java
+++ b/src/main/java/redis/clients/jedis/commands/StreamBinaryCommands.java
@@ -76,21 +76,6 @@ List<Object> xautoclaimJustId(byte[] key, byte[] groupName, byte[] consumerName,
 
   List<Object> xinfoConsumers(byte[] key, byte[] group);
 
-  /**
-   * @deprecated As of Jedis 6.1.0, replaced by {@link #xreadBinary(XReadParams, Map)} or
-   * {@link #xreadBinaryAsMap(XReadParams, Map)} for type safety and better stream entry parsing.
-   */
-  @Deprecated
-  List<Object> xread(XReadParams xReadParams, Map.Entry<byte[], byte[]>... streams);
-
-  /**
-   * @deprecated As of Jedis 6.1.0, use {@link #xreadGroupBinary(byte[], byte[], XReadGroupParams, Map)} or
-   * {@link #xreadGroupBinaryAsMap(byte[], byte[], XReadGroupParams, Map)} instead.
-   */
-  @Deprecated
-  List<Object> xreadGroup(byte[] groupName, byte[] consumer, XReadGroupParams xReadGroupParams,
-      Map.Entry<byte[], byte[]>... streams);
-
   /**
    * Read from one or more streams.
    * @param xReadParams {@link XReadParams}
diff --git a/src/main/java/redis/clients/jedis/commands/StringBinaryCommands.java b/src/main/java/redis/clients/jedis/commands/StringBinaryCommands.java
index 0d087bc1b3..d8aa374dcf 100644
--- a/src/main/java/redis/clients/jedis/commands/StringBinaryCommands.java
+++ b/src/main/java/redis/clients/jedis/commands/StringBinaryCommands.java
@@ -27,12 +27,6 @@ public interface StringBinaryCommands extends BitBinaryCommands {
 
   byte[] getrange(byte[] key, long startOffset, long endOffset);
 
-  /**
-   * @deprecated Use {@link StringBinaryCommands#setGet(byte[], byte[])}.
-   */
-  @Deprecated
-  byte[] getSet(byte[] key, byte[] value);
-
   long setnx(byte[] key, byte[] value);
 
   String setex(byte[] key, long seconds, byte[] value);
diff --git a/src/main/java/redis/clients/jedis/commands/StringCommands.java b/src/main/java/redis/clients/jedis/commands/StringCommands.java
index c4ea21fea7..b4dac04015 100644
--- a/src/main/java/redis/clients/jedis/commands/StringCommands.java
+++ b/src/main/java/redis/clients/jedis/commands/StringCommands.java
@@ -107,20 +107,6 @@ public interface StringCommands extends BitCommands {
    */
   String getrange(String key, long startOffset, long endOffset);
 
-  /**
-   * <b><a href="http://redis.io/commands/getset">GetSet Command</a></b>
-   * GETSET is an atomic set this value and return the old value command. Set key to the string
-   * value and return the old value stored at key. The string can't be longer than 1073741824 byte (1 GB).
-   * <p>
-   * Time complexity: O(1)
-   * @param key
-   * @param value
-   * @return The old value that was stored in key
-   * @deprecated Use {@link StringCommands#setGet(java.lang.String, java.lang.String)}.
-   */
-  @Deprecated
-  String getSet(String key, String value);
-
   /**
    * <b><a href="http://redis.io/commands/setnx">SetNE Command</a></b>
    * SETNX works exactly like {@link StringCommands#set(String, String) SET} with the only difference that if
diff --git a/src/main/java/redis/clients/jedis/search/RediSearchCommands.java b/src/main/java/redis/clients/jedis/search/RediSearchCommands.java
index 451f2e58bb..fd398bc6a1 100644
--- a/src/main/java/redis/clients/jedis/search/RediSearchCommands.java
+++ b/src/main/java/redis/clients/jedis/search/RediSearchCommands.java
@@ -61,9 +61,6 @@ default SearchResult ftSearch(String indexName) {
 
   SearchResult ftSearch(String indexName, Query query);
 
-  @Deprecated
-  SearchResult ftSearch(byte[] indexName, Query query);
-
   String ftExplain(String indexName, Query query);
 
   List<String> ftExplainCLI(String indexName, Query query);
@@ -108,24 +105,6 @@ Map<String, Map<String, Double>> ftSpellCheck(String index, String query,
 
   Set<String> ftTagVals(String indexName, String fieldName);
 
-  /**
-   * @deprecated {@link ConfigCommands#configGet(java.lang.String)} is used since Redis 8.
-   */
-  @Deprecated
-  Map<String, Object> ftConfigGet(String option);
-
-  @Deprecated
-  Map<String, Object> ftConfigGet(String indexName, String option);
-
-  /**
-   * @deprecated {@link ConfigCommands#configSet(java.lang.String, java.lang.String)} is used since Redis 8.
-   */
-  @Deprecated
-  String ftConfigSet(String option, String value);
-
-  @Deprecated
-  String ftConfigSet(String indexName, String option, String value);
-
   long ftSugAdd(String key, String string, double score);
 
   long ftSugAddIncr(String key, String string, double score);
diff --git a/src/main/java/redis/clients/jedis/search/SearchProtocol.java b/src/main/java/redis/clients/jedis/search/SearchProtocol.java
index b1a6e88c7a..b4938f1b22 100644
--- a/src/main/java/redis/clients/jedis/search/SearchProtocol.java
+++ b/src/main/java/redis/clients/jedis/search/SearchProtocol.java
@@ -6,6 +6,8 @@
 
 public class SearchProtocol {
 
+  public static final int DEFAULT_DIALECT = 2;
+
   public enum SearchCommand implements ProtocolCommand {
 
     CREATE("FT.CREATE"),
diff --git a/src/test/java/redis/clients/jedis/AbstractRedisClientBuilderTest.java b/src/test/java/redis/clients/jedis/AbstractRedisClientBuilderTest.java
new file mode 100644
index 0000000000..6e9407ae0c
--- /dev/null
+++ b/src/test/java/redis/clients/jedis/AbstractRedisClientBuilderTest.java
@@ -0,0 +1,158 @@
+package redis.clients.jedis;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.Set;
+import java.util.HashSet;
+
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
+import redis.clients.jedis.json.JsonObjectMapper;
+import redis.clients.jedis.providers.SentineledConnectionProvider;
+
+/**
+ * Test class to verify that the AbstractRedisClientBuilder works correctly with both
+ * RedisClient.Builder and RedisSentinelClient.Builder.
+ */
+public class AbstractRedisClientBuilderTest {
+
+  @Test
+  public void testRedisClientBuilderInheritance() {
+    // Test that RedisClient.Builder inherits common methods from AbstractRedisClientBuilder
+    RedisClient.Builder builder = RedisClient.builder();
+
+    // Test method chaining with inherited methods
+    GenericObjectPoolConfig<Connection> poolConfig = new ConnectionPoolConfig();
+    poolConfig.setMaxTotal(20);
+
+    CommandKeyArgumentPreProcessor keyProcessor = key -> "test:" + key;
+
+    RedisClient.Builder result = builder.host("localhost").port(6379).poolConfig(poolConfig)
+        .keyPreProcessor(keyProcessor).searchDialect(3);
+
+    // Verify method chaining returns the correct builder type
+    assertSame(builder, result);
+    assertNotNull(builder);
+  }
+
+  @Test
+  public void testRedisSentinelClientBuilderInheritance() {
+    // Test that RedisSentinelClient.Builder inherits common methods from AbstractRedisClientBuilder
+    Set<HostAndPort> sentinels = new HashSet<>();
+    sentinels.add(new HostAndPort("localhost", 26379));
+
+    RedisSentinelClient.Builder builder = RedisSentinelClient.builder();
+
+    // Test method chaining with inherited methods
+    GenericObjectPoolConfig<Connection> poolConfig = new ConnectionPoolConfig();
+    poolConfig.setMaxTotal(15);
+
+    CommandKeyArgumentPreProcessor keyProcessor = key -> "sentinel:" + key;
+
+    RedisSentinelClient.Builder result = builder.masterName("mymaster").sentinels(sentinels)
+        .poolConfig(poolConfig).keyPreProcessor(keyProcessor).searchDialect(2);
+
+    // Verify method chaining returns the correct builder type
+    assertSame(builder, result);
+    assertNotNull(builder);
+  }
+
+  @Test
+  public void testCommonMethodsAvailableOnBothBuilders() {
+    // Test that both builders have the same common methods available
+    RedisClient.Builder redisBuilder = RedisClient.builder();
+    RedisSentinelClient.Builder sentinelBuilder = RedisSentinelClient.builder();
+
+    GenericObjectPoolConfig<Connection> poolConfig = new ConnectionPoolConfig();
+    CommandKeyArgumentPreProcessor keyProcessor = key -> "prefix:" + key;
+
+    // Test that both builders support the same common configuration methods
+    assertNotNull(redisBuilder.poolConfig(poolConfig));
+    assertNotNull(sentinelBuilder.poolConfig(poolConfig));
+
+    assertNotNull(redisBuilder.keyPreProcessor(keyProcessor));
+    assertNotNull(sentinelBuilder.keyPreProcessor(keyProcessor));
+
+    assertNotNull(redisBuilder.searchDialect(3));
+    assertNotNull(sentinelBuilder.searchDialect(3));
+  }
+
+  @Test
+  public void testSearchDialectValidation() {
+    // Test that search dialect validation works for both builders
+    RedisClient.Builder redisBuilder = RedisClient.builder();
+    RedisSentinelClient.Builder sentinelBuilder = RedisSentinelClient.builder();
+
+    // Test that dialect 0 is rejected for both builders
+    assertThrows(IllegalArgumentException.class, () -> {
+      redisBuilder.searchDialect(0);
+    });
+
+    assertThrows(IllegalArgumentException.class, () -> {
+      sentinelBuilder.searchDialect(0);
+    });
+
+    // Test that valid dialects are accepted
+    assertNotNull(redisBuilder.searchDialect(1));
+    assertNotNull(redisBuilder.searchDialect(2));
+    assertNotNull(redisBuilder.searchDialect(3));
+
+    assertNotNull(sentinelBuilder.searchDialect(1));
+    assertNotNull(sentinelBuilder.searchDialect(2));
+    assertNotNull(sentinelBuilder.searchDialect(3));
+  }
+
+  @Test
+  public void testBuilderSpecificMethods() {
+    // Test that each builder still has its specific methods
+    RedisClient.Builder redisBuilder = RedisClient.builder();
+    RedisSentinelClient.Builder sentinelBuilder = RedisSentinelClient.builder();
+
+    // RedisClient.Builder specific methods
+    assertNotNull(redisBuilder.host("localhost"));
+    assertNotNull(redisBuilder.port(6379));
+    assertNotNull(redisBuilder.config(DefaultJedisClientConfig.builder().build()));
+
+    // RedisSentinelClient.Builder specific methods
+    Set<HostAndPort> sentinels = new HashSet<>();
+    sentinels.add(new HostAndPort("localhost", 26379));
+
+    assertNotNull(sentinelBuilder.masterName("mymaster"));
+    assertNotNull(sentinelBuilder.sentinels(sentinels));
+    assertNotNull(sentinelBuilder.masterConfig(DefaultJedisClientConfig.builder().build()));
+    assertNotNull(sentinelBuilder.sentinelConfig(DefaultJedisClientConfig.builder().build()));
+  }
+
+  @Test
+  public void testConnectionProviderOverride() {
+    // Test that RedisSentinelClient.Builder properly overrides connectionProvider method
+    RedisSentinelClient.Builder builder = RedisSentinelClient.builder();
+
+    // Test that the connectionProvider method exists and returns the correct type
+    // We don't actually create a provider to avoid connection issues in tests
+    assertNotNull(builder);
+
+    // Test that we can call the connectionProvider method (even with null)
+    // This tests the API without requiring actual sentinel connections
+    RedisSentinelClient.Builder result = builder.connectionProvider(null);
+    assertSame(builder, result);
+  }
+
+  @Test
+  public void testAbstractBuilderGenerics() {
+    // Test that the generic types work correctly
+    RedisClient.Builder redisBuilder = RedisClient.builder();
+    RedisSentinelClient.Builder sentinelBuilder = RedisSentinelClient.builder();
+
+    // Verify that the builders are instances of AbstractRedisClientBuilder
+    assertTrue(redisBuilder instanceof AbstractRedisClientBuilder);
+    assertTrue(sentinelBuilder instanceof AbstractRedisClientBuilder);
+
+    // Verify that method chaining preserves the correct types
+    RedisClient.Builder redisResult = redisBuilder.searchDialect(2);
+    RedisSentinelClient.Builder sentinelResult = sentinelBuilder.searchDialect(2);
+
+    assertSame(redisBuilder, redisResult);
+    assertSame(sentinelBuilder, sentinelResult);
+  }
+}
diff --git a/src/test/java/redis/clients/jedis/RedisClientTest.java b/src/test/java/redis/clients/jedis/RedisClientTest.java
new file mode 100644
index 0000000000..3983aebf3a
--- /dev/null
+++ b/src/test/java/redis/clients/jedis/RedisClientTest.java
@@ -0,0 +1,461 @@
+package redis.clients.jedis;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import redis.clients.jedis.csc.Cache;
+import redis.clients.jedis.json.JsonObjectMapper;
+import redis.clients.jedis.providers.ConnectionProvider;
+import redis.clients.jedis.util.EnabledOnCommandCondition;
+import redis.clients.jedis.util.PrefixedKeyArgumentPreProcessor;
+import redis.clients.jedis.util.RedisVersionCondition;
+
+/**
+ * Comprehensive tests for RedisClient class covering: - Constructor variations - Builder pattern
+ * functionality - Configuration validation - Redis operations - Pipeline and transaction support -
+ * Resource management
+ */
+public class RedisClientTest {
+
+  @RegisterExtension
+  public RedisVersionCondition versionCondition = new RedisVersionCondition(endpoint);
+  @RegisterExtension
+  public EnabledOnCommandCondition enabledOnCommandCondition = new EnabledOnCommandCondition(
+      endpoint);
+
+  private static final EndpointConfig endpoint = HostAndPorts.getRedisEndpoint("standalone0");
+
+  private RedisClient client;
+
+  @BeforeEach
+  public void setUp() {
+    // Clean up any existing data
+    try (Jedis jedis = new Jedis(endpoint.getHostAndPort(),
+        endpoint.getClientConfigBuilder().build())) {
+      jedis.flushAll();
+    }
+  }
+
+  @AfterEach
+  public void tearDown() {
+    if (client != null) {
+      client.close();
+    }
+  }
+
+  // Constructor Tests
+
+  @Test
+  public void testDefaultConstructor() {
+    client = new RedisClient();
+    assertNotNull(client);
+    // Note: Cannot test actual connection without Redis running on default localhost:6379
+  }
+
+  @Test
+  public void testHostPortConstructor() {
+    client = new RedisClient(endpoint.getHost(), endpoint.getPort());
+    assertNotNull(client);
+
+    // Note: Authentication needs to be done through client configuration
+    // This test just verifies the constructor works
+  }
+
+  @Test
+  public void testHostAndPortConstructor() {
+    HostAndPort hostAndPort = new HostAndPort(endpoint.getHost(), endpoint.getPort());
+    client = new RedisClient(hostAndPort);
+    assertNotNull(client);
+  }
+
+  @Test
+  public void testURIConstructor() throws URISyntaxException {
+    URI uri = endpoint.getURIBuilder().defaultCredentials().build();
+    client = new RedisClient(uri);
+    assertNotNull(client);
+
+    // Test basic operation
+    try {
+      client.set("uri-test-key", "uri-test-value");
+      assertEquals("uri-test-value", client.get("uri-test-key"));
+    } catch (Exception e) {
+      // Redis not available, skip operation test
+    }
+  }
+
+  // Builder Tests
+
+  @Test
+  public void testBuilderBasicConfiguration() {
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).build();
+
+    assertNotNull(client);
+
+    // Test basic operation
+    try {
+      client.set("builder-test-key", "builder-test-value");
+      assertEquals("builder-test-value", client.get("builder-test-key"));
+    } catch (Exception e) {
+      // Redis not available, skip operation test
+    }
+  }
+
+  @Test
+  public void testBuilderWithClientConfig() {
+    JedisClientConfig config = DefaultJedisClientConfig.builder().password(endpoint.getPassword())
+        .database(0).timeoutMillis(5000).build();
+
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort()).config(config)
+        .build();
+
+    assertNotNull(client);
+  }
+
+  @Test
+  public void testBuilderWithPoolConfig() {
+    GenericObjectPoolConfig<Connection> poolConfig = new ConnectionPoolConfig();
+    poolConfig.setMaxTotal(20);
+    poolConfig.setMaxIdle(10);
+    poolConfig.setMinIdle(5);
+
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).poolConfig(poolConfig).build();
+
+    assertNotNull(client);
+  }
+
+  @Test
+  public void testBuilderWithCache() {
+    Cache mockCache = mock(Cache.class);
+
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).cache(mockCache).build();
+
+    assertNotNull(client);
+    assertEquals(mockCache, client.getCache());
+  }
+
+  @Test
+  public void testBuilderWithCustomConnectionProvider() {
+    ConnectionProvider mockProvider = mock(ConnectionProvider.class);
+    Connection mockConnection = mock(Connection.class);
+    when(mockProvider.getConnection()).thenReturn(mockConnection);
+    when(mockProvider.getConnection(any())).thenReturn(mockConnection);
+
+    client = RedisClient.builder().connectionProvider(mockProvider).build();
+
+    assertNotNull(client);
+  }
+
+  @Test
+  public void testBuilderWithKeyPreProcessor() {
+    CommandKeyArgumentPreProcessor keyProcessor = new PrefixedKeyArgumentPreProcessor("test:");
+
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).keyPreProcessor(keyProcessor).build();
+
+    assertNotNull(client);
+
+    // Test that key preprocessing works
+    try {
+      client.set("mykey", "myvalue");
+      // The actual key stored should be "test:mykey"
+      // We can verify this by connecting with a regular client
+      try (Jedis jedis = new Jedis(endpoint.getHostAndPort(),
+          endpoint.getClientConfigBuilder().build())) {
+        assertEquals("myvalue", jedis.get("test:mykey"));
+        assertNull(jedis.get("mykey")); // Original key should not exist
+      }
+    } catch (Exception e) {
+      // Redis not available, skip operation test
+    }
+  }
+
+  @Test
+  public void testBuilderWithJsonObjectMapper() {
+    JsonObjectMapper mockMapper = mock(JsonObjectMapper.class);
+
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).jsonObjectMapper(mockMapper).build();
+
+    assertNotNull(client);
+  }
+
+  @Test
+  public void testBuilderWithSearchDialect() {
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).searchDialect(3).build();
+
+    assertNotNull(client);
+  }
+
+  @Test
+  public void testBuilderSearchDialectValidation() {
+    RedisClient.Builder builder = RedisClient.builder();
+
+    // Test that dialect 0 throws exception
+    assertThrows(IllegalArgumentException.class, () -> {
+      builder.searchDialect(0);
+    });
+
+    // Test that other dialects are accepted
+    assertDoesNotThrow(() -> {
+      builder.searchDialect(1);
+      builder.searchDialect(2);
+      builder.searchDialect(3);
+    });
+  }
+
+  @Test
+  public void testBuilderFromURI() throws URISyntaxException {
+    URI uri = endpoint.getURIBuilder().defaultCredentials().build();
+
+    client = RedisClient.builder().fromURI(uri).build();
+
+    assertNotNull(client);
+
+    // Test basic operation
+    try {
+      client.set("uri-builder-test", "uri-builder-value");
+      assertEquals("uri-builder-value", client.get("uri-builder-test"));
+    } catch (Exception e) {
+      // Redis not available, skip operation test
+    }
+  }
+
+  // Validation Tests
+
+  @Test
+  public void testBuilderValidationNullHost() {
+    RedisClient.Builder builder = RedisClient.builder().host(null);
+
+    assertThrows(IllegalArgumentException.class, builder::build);
+  }
+
+  @Test
+  public void testBuilderValidationEmptyHost() {
+    RedisClient.Builder builder = RedisClient.builder().host("");
+
+    assertThrows(IllegalArgumentException.class, builder::build);
+  }
+
+  @Test
+  public void testBuilderValidationInvalidPort() {
+    RedisClient.Builder builder1 = RedisClient.builder().port(0);
+
+    assertThrows(IllegalArgumentException.class, builder1::build);
+
+    RedisClient.Builder builder2 = RedisClient.builder().port(65536);
+
+    assertThrows(IllegalArgumentException.class, builder2::build);
+  }
+
+  @Test
+  public void testBuilderValidationWithCustomProvider() {
+    ConnectionProvider mockProvider = mock(ConnectionProvider.class);
+
+    // When custom provider is set, host/port validation should be skipped
+    client = RedisClient.builder().connectionProvider(mockProvider).host(null) // This should not
+                                                                               // cause validation
+                                                                               // error
+        .port(0) // This should not cause validation error
+        .build();
+
+    assertNotNull(client);
+  }
+
+  // Redis Operations Tests
+
+  @Test
+  public void testBasicRedisOperations() {
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).build();
+
+    try {
+      // String operations
+      assertEquals("OK", client.set("string-key", "string-value"));
+      assertEquals("string-value", client.get("string-key"));
+
+      // Hash operations
+      assertEquals(1L, client.hset("hash-key", "field1", "value1"));
+      assertEquals("value1", client.hget("hash-key", "field1"));
+
+      // List operations
+      assertEquals(1L, client.lpush("list-key", "item1"));
+      assertEquals("item1", client.lpop("list-key"));
+
+      // Set operations
+      assertEquals(1L, client.sadd("set-key", "member1"));
+      assertTrue(client.sismember("set-key", "member1"));
+
+      // Sorted set operations
+      assertEquals(1L, client.zadd("zset-key", 1.0, "member1"));
+      assertEquals(Double.valueOf(1.0), client.zscore("zset-key", "member1"));
+
+    } catch (Exception e) {
+      // Redis not available, skip operation test
+    }
+  }
+
+  @Test
+  public void testPipelineOperations() {
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).build();
+
+    try {
+      Pipeline pipeline = client.pipelined();
+      assertNotNull(pipeline);
+
+      // Queue multiple operations
+      pipeline.set("pipe-key1", "pipe-value1");
+      pipeline.set("pipe-key2", "pipe-value2");
+      pipeline.get("pipe-key1");
+      pipeline.get("pipe-key2");
+
+      // Execute pipeline
+      pipeline.sync();
+      pipeline.close();
+
+      // Verify results
+      assertEquals("pipe-value1", client.get("pipe-key1"));
+      assertEquals("pipe-value2", client.get("pipe-key2"));
+
+    } catch (Exception e) {
+      // Redis not available, skip operation test
+    }
+  }
+
+  @Test
+  public void testTransactionOperations() {
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).build();
+
+    try {
+      Transaction transaction = client.multi();
+      assertNotNull(transaction);
+
+      // Queue multiple operations in transaction
+      transaction.set("tx-key1", "tx-value1");
+      transaction.set("tx-key2", "tx-value2");
+      transaction.get("tx-key1");
+
+      // Execute transaction
+      transaction.exec();
+      transaction.close();
+
+      // Verify results
+      assertEquals("tx-value1", client.get("tx-key1"));
+      assertEquals("tx-value2", client.get("tx-key2"));
+
+    } catch (Exception e) {
+      // Redis not available, skip operation test
+    }
+  }
+
+  @Test
+  public void testTransactionWithoutMulti() {
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).build();
+
+    try {
+      Transaction transaction = client.transaction(false);
+      assertNotNull(transaction);
+
+      transaction.close();
+
+    } catch (Exception e) {
+      // Redis not available, skip operation test
+    }
+  }
+
+  // Resource Management Tests
+
+  @Test
+  public void testAutoCloseable() {
+    // Test that RedisClient implements AutoCloseable properly
+    try (RedisClient autoClient = RedisClient.builder().host(endpoint.getHost())
+        .port(endpoint.getPort()).config(endpoint.getClientConfigBuilder().build()).build()) {
+
+      assertNotNull(autoClient);
+      // Client should be automatically closed when exiting try block
+    } catch (Exception e) {
+      // Redis not available, skip test
+    }
+  }
+
+  @Test
+  public void testManualClose() {
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).build();
+
+    assertNotNull(client);
+
+    // Manual close should not throw exception
+    assertDoesNotThrow(() -> {
+      client.close();
+    });
+
+    // Multiple closes should be safe
+    assertDoesNotThrow(() -> {
+      client.close();
+    });
+
+    client = null; // Prevent tearDown from closing again
+  }
+
+  // Abstract Method Implementation Tests
+
+  @Test
+  public void testAbstractMethodImplementations() {
+    client = RedisClient.builder().host(endpoint.getHost()).port(endpoint.getPort())
+        .config(endpoint.getClientConfigBuilder().build()).build();
+
+    // Test that abstract methods are properly implemented
+    assertNotNull(client.getCommandObjects());
+    assertNotNull(client.getConnectionProvider());
+
+    // Test command execution methods don't throw
+    try {
+      // These methods are protected, but we can test them indirectly
+      // through public Redis operations
+      client.set("ping-test", "pong");
+      assertEquals("pong", client.get("ping-test"));
+    } catch (Exception e) {
+      // Redis not available, skip test
+    }
+  }
+
+  // Error Handling Tests
+
+  @Test
+  public void testInvalidHostConnection() {
+    // Test connection to invalid host
+    client = RedisClient.builder().host("invalid-host-that-does-not-exist").port(6379).build();
+
+    assertNotNull(client);
+
+    // Operations should fail with connection exception
+    assertThrows(Exception.class, () -> {
+      client.set("test", "value");
+    });
+  }
+
+  @Test
+  public void testBuilderDefaults() {
+    // Test that builder uses proper defaults
+    client = RedisClient.builder().build();
+
+    assertNotNull(client);
+    // Should use localhost:6379 by default
+  }
+}
diff --git a/src/test/java/redis/clients/jedis/RedisClusterClientTest.java b/src/test/java/redis/clients/jedis/RedisClusterClientTest.java
new file mode 100644
index 0000000000..3c569987fb
--- /dev/null
+++ b/src/test/java/redis/clients/jedis/RedisClusterClientTest.java
@@ -0,0 +1,223 @@
+package redis.clients.jedis;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.time.Duration;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.BeforeEach;
+
+/**
+ * Unit tests for RedisClusterClient. These tests verify the basic functionality and configuration
+ * of RedisClusterClient using the stable cluster endpoints for consistent testing.
+ */
+public class RedisClusterClientTest {
+
+  private Set<HostAndPort> nodes;
+  private JedisClientConfig clientConfig;
+
+  @BeforeEach
+  public void setUp() {
+    // Use stable cluster servers that are configured for testing
+    nodes = new HashSet<>(HostAndPorts.getStableClusterServers());
+
+    // Create client configuration with cluster authentication
+    clientConfig = DefaultJedisClientConfig.builder()
+        .password("cluster")
+        .build();
+  }
+
+  @Test
+  public void testBuilderWithNodes() {
+    RedisClusterClient.Builder builder = RedisClusterClient.builder()
+        .nodes(nodes)
+        .clientConfig(clientConfig);
+
+    assertNotNull(builder);
+
+    // Test that we can build without throwing exceptions
+    try (RedisClusterClient client = builder.build()) {
+      assertNotNull(client);
+    } catch (Exception e) {
+      // Expected since we don't have a real cluster running
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception");
+    }
+  }
+
+  @Test
+  public void testBuilderWithClientConfig() {
+    JedisClientConfig customClientConfig = DefaultJedisClientConfig.builder()
+        .password("cluster")
+        .connectionTimeoutMillis(5000)
+        .socketTimeoutMillis(10000)
+        .build();
+
+    RedisClusterClient.Builder builder = RedisClusterClient.builder()
+        .nodes(nodes)
+        .clientConfig(customClientConfig);
+
+    assertNotNull(builder);
+
+    try (RedisClusterClient client = builder.build()) {
+      assertNotNull(client);
+    } catch (Exception e) {
+      // Expected since we don't have a real cluster running
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception");
+    }
+  }
+
+  @Test
+  public void testBuilderWithMaxAttempts() {
+    RedisClusterClient.Builder builder = RedisClusterClient.builder()
+        .nodes(nodes)
+        .clientConfig(clientConfig)
+        .maxAttempts(10);
+
+    assertNotNull(builder);
+
+    try (RedisClusterClient client = builder.build()) {
+      assertNotNull(client);
+    } catch (Exception e) {
+      // Expected since we don't have a real cluster running
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception");
+    }
+  }
+
+  @Test
+  public void testBuilderWithMaxTotalRetriesDuration() {
+    RedisClusterClient.Builder builder = RedisClusterClient.builder()
+        .nodes(nodes)
+        .clientConfig(clientConfig)
+        .maxTotalRetriesDuration(Duration.ofSeconds(30));
+
+    assertNotNull(builder);
+
+    try (RedisClusterClient client = builder.build()) {
+      assertNotNull(client);
+    } catch (Exception e) {
+      // Expected since we don't have a real cluster running
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception");
+    }
+  }
+
+  @Test
+  public void testBuilderWithTopologyRefreshPeriod() {
+    RedisClusterClient.Builder builder = RedisClusterClient.builder()
+        .nodes(nodes)
+        .clientConfig(clientConfig)
+        .topologyRefreshPeriod(Duration.ofMinutes(5));
+
+    assertNotNull(builder);
+
+    try (RedisClusterClient client = builder.build()) {
+      assertNotNull(client);
+    } catch (Exception e) {
+      // Expected since we don't have a real cluster running
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception");
+    }
+  }
+
+  @Test
+  public void testBuilderWithNullNodes() {
+    assertThrows(IllegalArgumentException.class, () -> {
+      RedisClusterClient.builder().nodes(null).build();
+    });
+  }
+
+  @Test
+  public void testBuilderWithEmptyNodes() {
+    assertThrows(IllegalArgumentException.class, () -> {
+      Set<HostAndPort> nodes1 = new HashSet<>();
+      RedisClusterClient.builder().nodes(nodes1).build();
+    });
+  }
+
+  @Test
+  public void testBuilderWithInvalidMaxAttempts() {
+    assertThrows(IllegalArgumentException.class, () -> {
+      RedisClusterClient.builder().nodes(nodes).maxAttempts(0).build();
+    });
+  }
+
+  @Test
+  public void testConstructorWithNodes() {
+    try (RedisClusterClient client = new RedisClusterClient(nodes, clientConfig)) {
+      assertNotNull(client);
+    } catch (Exception e) {
+      // Expected since we don't have a real cluster running
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception");
+    }
+  }
+
+  @Test
+  public void testConstructorWithNodesAndClientConfig() {
+    JedisClientConfig customClientConfig = DefaultJedisClientConfig.builder()
+        .password("cluster")
+        .build();
+
+    try (RedisClusterClient client = new RedisClusterClient(nodes, customClientConfig)) {
+      assertNotNull(client);
+    } catch (Exception e) {
+      // Expected since we don't have a real cluster running
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception");
+    }
+  }
+
+  @Test
+  public void testTransactionNotSupported() {
+    try (RedisClusterClient client = new RedisClusterClient(nodes, clientConfig)) {
+      try {
+        client.transaction(true);
+        fail("Expected UnsupportedOperationException");
+      } catch (UnsupportedOperationException e) {
+        assertEquals("Transactions are not supported in cluster mode", e.getMessage());
+      }
+    } catch (Exception e) {
+      // If we can't create the client due to connection issues,
+      // we can't test the transaction method, so we skip this test
+      if (e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+          || e.getCause() instanceof java.net.ConnectException) {
+        // This is expected when no cluster is running
+        return;
+      }
+      throw e;
+    }
+  }
+
+  @Test
+  public void testPipelinedMethod() {
+    try (RedisClusterClient client = new RedisClusterClient(nodes, clientConfig)) {
+      ClusterPipeline pipeline = client.pipelined();
+      assertNotNull(pipeline);
+    } catch (Exception e) {
+      // Expected since we don't have a real cluster running
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception");
+    }
+  }
+}
diff --git a/src/test/java/redis/clients/jedis/RedisSentinelClientTest.java b/src/test/java/redis/clients/jedis/RedisSentinelClientTest.java
new file mode 100644
index 0000000000..09c8591ad6
--- /dev/null
+++ b/src/test/java/redis/clients/jedis/RedisSentinelClientTest.java
@@ -0,0 +1,264 @@
+package redis.clients.jedis;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.BeforeEach;
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.Set;
+import java.util.HashSet;
+
+import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
+
+/**
+ * Tests for RedisSentinelClient. These tests include both unit tests for configuration
+ * and integration tests that attempt actual connections to sentinel-managed Redis instances.
+ */
+public class RedisSentinelClientTest {
+
+  private static final String PRIMARY_NAME = "myprimary";
+
+  private static final HostAndPort sentinel1 = HostAndPorts.getSentinelServers().get(1);
+  private static final HostAndPort sentinel2 = HostAndPorts.getSentinelServers().get(3);
+
+  private Set<HostAndPort> sentinels;
+  private JedisClientConfig primaryConfig;
+  private JedisClientConfig sentinelConfig;
+
+  @BeforeEach
+  public void setUp() throws Exception {
+    // Use configured sentinel endpoints
+    sentinels = new HashSet<>();
+    sentinels.add(sentinel1);
+    sentinels.add(sentinel2);
+
+    // Create master configuration with proper authentication
+    primaryConfig = DefaultJedisClientConfig.builder()
+        .password("foobared")
+        .database(2)
+        .build();
+
+    // Create sentinel configuration (sentinels typically don't require auth in test env)
+    sentinelConfig = DefaultJedisClientConfig.builder()
+        .build();
+  }
+
+  @Test
+  public void testBuilderWithMinimalConfiguration() {
+    // Test that builder can be created with minimal configuration
+    RedisSentinelClient.Builder builder = RedisSentinelClient.builder()
+        .primary(PRIMARY_NAME, primaryConfig)
+        .sentinels(sentinels);
+
+    assertNotNull(builder);
+
+    // Test actual connection attempt
+    try (RedisSentinelClient client = builder.build()) {
+      assertNotNull(client);
+    } catch (Exception e) {
+      // Expected if sentinel/master not available in test environment
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getMessage().contains("sentinel") || e.getMessage().contains("master")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception, got: " + e.getMessage());
+    }
+  }
+
+  @Test
+  public void testBuilderWithAdvancedConfiguration() {
+    JedisClientConfig customPrimaryConfig = DefaultJedisClientConfig.builder()
+        .password("foobared")
+        .database(1)
+        .connectionTimeoutMillis(5000)
+        .socketTimeoutMillis(10000)
+        .build();
+
+    JedisClientConfig customSentinelConfig = DefaultJedisClientConfig.builder()
+        .connectionTimeoutMillis(3000)
+        .build();
+
+    GenericObjectPoolConfig<Connection> poolConfig = new ConnectionPoolConfig();
+    poolConfig.setMaxTotal(20);
+    poolConfig.setMaxIdle(10);
+
+    RedisSentinelClient.Builder builder = RedisSentinelClient.builder()
+        .primary(PRIMARY_NAME, customPrimaryConfig)
+        .sentinels(sentinels)
+        .sentinelConfig(customSentinelConfig)
+        .poolConfig(poolConfig)
+        .subscribeRetryWaitTimeMillis(10000)
+        .searchDialect(3);
+
+    assertNotNull(builder);
+
+    // Test actual connection attempt
+    try (RedisSentinelClient client = builder.build()) {
+      assertNotNull(client);
+    } catch (Exception e) {
+      // Expected if sentinel/master not available in test environment
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getMessage().contains("sentinel") || e.getMessage().contains("master")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception, got: " + e.getMessage());
+    }
+  }
+
+  @Test
+  public void testBuilderWithCustomConnectionProvider() {
+    // Test that the builder accepts a custom connection provider method
+    // We don't actually create a provider here to avoid connection issues in tests
+    RedisSentinelClient.Builder builder = RedisSentinelClient.builder();
+
+    // Test that the method exists and returns the builder for chaining
+    assertNotNull(builder);
+
+    // Test that we can call the connectionProvider method (even with null)
+    // This tests the API without requiring actual sentinel connections
+    assertSame(builder, builder.connectionProvider(null));
+  }
+
+  @Test
+  public void testBuilderFailsWithoutSentinels() {
+    assertThrows(IllegalArgumentException.class, () -> {
+      RedisSentinelClient.builder()
+          .masterName(PRIMARY_NAME)
+          .masterConfig(primaryConfig)
+          .build();
+    });
+  }
+
+  @Test
+  public void testBuilderFailsWithEmptySentinels() {
+    assertThrows(IllegalArgumentException.class, () -> {
+      RedisSentinelClient.builder()
+          .masterName(PRIMARY_NAME)
+          .sentinels(new HashSet<>())
+          .masterConfig(primaryConfig)
+          .build();
+    });
+  }
+
+  @Test
+  public void testBuilderMethodChaining() {
+    // Test that all builder methods return the builder for chaining
+    RedisSentinelClient.Builder builder = RedisSentinelClient.builder();
+
+    assertSame(builder, builder.masterName(PRIMARY_NAME));
+    assertSame(builder, builder.sentinels(sentinels));
+    assertSame(builder, builder.masterConfig(primaryConfig));
+    assertSame(builder, builder.sentinelConfig(sentinelConfig));
+    assertSame(builder, builder.poolConfig(new ConnectionPoolConfig()));
+    assertSame(builder, builder.subscribeRetryWaitTimeMillis(5000));
+    assertSame(builder, builder.searchDialect(3));
+  }
+
+  @Test
+  public void testBuilderDefaults() {
+    // Test that builder has sensible defaults
+    RedisSentinelClient.Builder builder = RedisSentinelClient.builder();
+
+    // These should not throw exceptions when accessed
+    assertNotNull(builder);
+  }
+
+  // Integration Tests
+
+  @Test
+  public void testIntegrationBasicOperations() {
+    // Test basic Redis operations through sentinel client
+    try (RedisSentinelClient client = RedisSentinelClient.builder()
+        .masterName(PRIMARY_NAME)
+        .sentinels(sentinels)
+        .masterConfig(primaryConfig)
+        .sentinelConfig(sentinelConfig)
+        .build()) {
+
+      // Test basic operations
+      client.set("sentinel-test-key", "sentinel-test-value");
+      assertEquals("sentinel-test-value", client.get("sentinel-test-key"));
+
+      // Clean up
+      client.del("sentinel-test-key");
+
+    } catch (Exception e) {
+      // Expected if sentinel/master not available in test environment
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getMessage().contains("sentinel") || e.getMessage().contains("master")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception, got: " + e.getMessage());
+    }
+  }
+
+  @Test
+  public void testIntegrationWithPoolConfiguration() {
+    // Test sentinel client with custom pool configuration
+    GenericObjectPoolConfig<Connection> poolConfig = new ConnectionPoolConfig();
+    poolConfig.setMaxTotal(5);
+    poolConfig.setMaxIdle(2);
+    poolConfig.setMinIdle(1);
+
+    try (RedisSentinelClient client = RedisSentinelClient.builder()
+        .masterName(PRIMARY_NAME)
+        .sentinels(sentinels)
+        .masterConfig(primaryConfig)
+        .sentinelConfig(sentinelConfig)
+        .poolConfig(poolConfig)
+        .build()) {
+
+      // Test that client was created successfully
+      assertNotNull(client);
+
+      // Test basic operation
+      client.set("pool-test-key", "pool-test-value");
+      assertEquals("pool-test-value", client.get("pool-test-key"));
+
+      // Clean up
+      client.del("pool-test-key");
+
+    } catch (Exception e) {
+      // Expected if sentinel/master not available in test environment
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getMessage().contains("sentinel") || e.getMessage().contains("master")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception, got: " + e.getMessage());
+    }
+  }
+
+  @Test
+  public void testIntegrationWithCustomConnectionProvider() {
+    // Test with custom connection provider (null test for API verification)
+    try (RedisSentinelClient client = RedisSentinelClient.builder()
+        .masterName(PRIMARY_NAME)
+        .sentinels(sentinels)
+        .masterConfig(primaryConfig)
+        .sentinelConfig(sentinelConfig)
+        .subscribeRetryWaitTimeMillis(3000)
+        .build()) {
+
+      assertNotNull(client);
+
+      // Test basic operation
+      client.set("provider-test-key", "provider-test-value");
+      assertEquals("provider-test-value", client.get("provider-test-key"));
+
+      // Test sentinel-specific method
+      HostAndPort currentMaster = client.getCurrentMaster();
+      assertNotNull(currentMaster);
+
+      // Clean up
+      client.del("provider-test-key");
+
+    } catch (Exception e) {
+      // Expected if sentinel/master not available in test environment
+      assertTrue(
+        e.getMessage().contains("Connection") || e.getMessage().contains("connection")
+            || e.getMessage().contains("sentinel") || e.getMessage().contains("master")
+            || e.getCause() instanceof java.net.ConnectException,
+        "Expected connection-related exception, got: " + e.getMessage());
+    }
+  }
+
+}
diff --git a/src/test/java/redis/clients/jedis/commands/unified/AllKindOfValuesCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/AllKindOfValuesCommandsTestBase.java
index ac6489e23e..b8d3a890c4 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/AllKindOfValuesCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/AllKindOfValuesCommandsTestBase.java
@@ -37,6 +37,7 @@
 
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.ScanIteration;
 import redis.clients.jedis.StreamEntryID;
@@ -69,8 +70,8 @@ public abstract class AllKindOfValuesCommandsTestBase extends UnifiedJedisComman
   protected final byte[] bex = { 0x65, 0x78 };
   final int expireSeconds = 2;
 
-  public AllKindOfValuesCommandsTestBase(RedisProtocol protocol) {
-    super(protocol);
+  public AllKindOfValuesCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/BinaryValuesCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/BinaryValuesCommandsTestBase.java
index 0dc28baeed..2b32fb1db1 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/BinaryValuesCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/BinaryValuesCommandsTestBase.java
@@ -18,6 +18,7 @@
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.Protocol;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.exceptions.JedisDataException;
@@ -35,8 +36,8 @@ public abstract class BinaryValuesCommandsTestBase extends UnifiedJedisCommandsT
   protected long expireMillis = expireSeconds * 1000;
   protected byte[] binaryValue;
 
-  public BinaryValuesCommandsTestBase(RedisProtocol protocol) {
-    super(protocol);
+  public BinaryValuesCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
@@ -139,12 +140,6 @@ public void setAndExat() {
     assertTrue(ttl > 0 && ttl <= expireSeconds);
   }
 
-  @Test
-  public void getSet() {
-    assertNull(jedis.getSet(bfoo, binaryValue));
-    assertArrayEquals(binaryValue, jedis.get(bfoo));
-  }
-
   @Test
   public void getDel() {
     assertEquals("OK", jedis.set(bfoo, bbar));
diff --git a/src/test/java/redis/clients/jedis/commands/unified/BitCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/BitCommandsTestBase.java
index d3c4da08b7..424159d9ed 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/BitCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/BitCommandsTestBase.java
@@ -5,6 +5,7 @@
 import io.redis.test.annotations.SinceRedisVersion;
 
 import org.junit.jupiter.api.Test;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.Protocol;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.args.BitCountOption;
@@ -22,8 +23,8 @@
 
 public abstract class BitCommandsTestBase extends UnifiedJedisCommandsTestBase {
 
-  public BitCommandsTestBase(RedisProtocol protocol) {
-    super(protocol);
+  public BitCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/GeoCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/GeoCommandsTestBase.java
index 51817b1d9b..6bc28a5ae0 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/GeoCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/GeoCommandsTestBase.java
@@ -6,6 +6,7 @@
 import java.util.Map;
 
 import org.junit.jupiter.api.Test;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.GeoCoordinate;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.args.GeoUnit;
@@ -35,8 +36,8 @@ public abstract class GeoCommandsTestBase extends UnifiedJedisCommandsTestBase {
 
   private static final double EPSILON = 1e-5;
 
-  public GeoCommandsTestBase(RedisProtocol protocol) {
-    super(protocol);
+  public GeoCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/HashesCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/HashesCommandsTestBase.java
index 7042bf325b..ed9c6653af 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/HashesCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/HashesCommandsTestBase.java
@@ -34,6 +34,7 @@
 import io.redis.test.annotations.SinceRedisVersion;
 
 import org.junit.jupiter.api.Test;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.args.ExpiryOption;
 import redis.clients.jedis.params.HGetExParams;
@@ -56,8 +57,8 @@ public abstract class HashesCommandsTestBase extends UnifiedJedisCommandsTestBas
   final byte[] bbar3 = { 0x05, 0x06, 0x07, 0x08, 0x0C };
   final byte[] bbarstar = { 0x05, 0x06, 0x07, 0x08, '*' };
 
-  public HashesCommandsTestBase(RedisProtocol protocol) {
-    super(protocol);
+  public HashesCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/HyperLogLogCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/HyperLogLogCommandsTestBase.java
index 892dbca7cd..a3b0e391a1 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/HyperLogLogCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/HyperLogLogCommandsTestBase.java
@@ -1,6 +1,7 @@
 package redis.clients.jedis.commands.unified;
 
 import org.junit.jupiter.api.Test;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.util.SafeEncoder;
 
@@ -8,8 +9,8 @@
 
 public abstract class HyperLogLogCommandsTestBase extends UnifiedJedisCommandsTestBase {
 
-  public HyperLogLogCommandsTestBase(RedisProtocol protocol) {
-    super(protocol);
+  public HyperLogLogCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/ListCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/ListCommandsTestBase.java
index 85476f2110..c3f6ebc6ac 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/ListCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/ListCommandsTestBase.java
@@ -18,6 +18,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.args.ListPosition;
 import redis.clients.jedis.args.ListDirection;
@@ -27,7 +28,7 @@
 
 public abstract class ListCommandsTestBase extends UnifiedJedisCommandsTestBase {
 
-  private final Logger logger = LoggerFactory.getLogger(getClass());
+  protected final Logger logger = LoggerFactory.getLogger(getClass());
 
   protected final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
   protected final byte[] bfoo1 = { 0x01, 0x02, 0x03, 0x04, 0x05 };
@@ -43,8 +44,8 @@ public abstract class ListCommandsTestBase extends UnifiedJedisCommandsTestBase
   protected final byte[] bx = { 0x02, 0x04 };
   protected final byte[] bdst = { 0x11, 0x12, 0x13, 0x14 };
 
-  public ListCommandsTestBase(RedisProtocol protocol) {
-    super(protocol);
+  public ListCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/SetCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/SetCommandsTestBase.java
index 25eb631145..ba52ee91bd 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/SetCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/SetCommandsTestBase.java
@@ -21,6 +21,7 @@
 import io.redis.test.annotations.SinceRedisVersion;
 
 import org.junit.jupiter.api.Test;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.params.ScanParams;
 import redis.clients.jedis.resps.ScanResult;
@@ -40,8 +41,8 @@ public abstract class SetCommandsTestBase extends UnifiedJedisCommandsTestBase {
   final byte[] bbar3 = { 0x05, 0x06, 0x07, 0x08, 0x0C };
   final byte[] bbarstar = { 0x05, 0x06, 0x07, 0x08, '*' };
 
-  public SetCommandsTestBase(RedisProtocol protocol) {
-    super(protocol);
+  public SetCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/SortedSetCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/SortedSetCommandsTestBase.java
index e4f4bdfa12..9df0961c87 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/SortedSetCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/SortedSetCommandsTestBase.java
@@ -15,6 +15,7 @@
 import io.redis.test.annotations.SinceRedisVersion;
 
 import org.junit.jupiter.api.Test;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.args.SortedSetOption;
 import redis.clients.jedis.params.*;
@@ -41,8 +42,8 @@ public abstract class SortedSetCommandsTestBase extends UnifiedJedisCommandsTest
   final byte[] bbar3 = { 0x05, 0x06, 0x07, 0x08, 0x0C };
   final byte[] bbarstar = { 0x05, 0x06, 0x07, 0x08, '*' };
 
-  public SortedSetCommandsTestBase(RedisProtocol protocol) {
-    super(protocol);
+  public SortedSetCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/StreamsBinaryCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/StreamsBinaryCommandsTestBase.java
index 816dd8e6ac..40daa78583 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/StreamsBinaryCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/StreamsBinaryCommandsTestBase.java
@@ -2,6 +2,7 @@
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.StreamEntryID;
 import redis.clients.jedis.exceptions.JedisDataException;
@@ -49,8 +50,8 @@ public abstract class StreamsBinaryCommandsTestBase extends UnifiedJedisCommands
     stream2Entries.add(new StreamEntryBinary(new StreamEntryID("0-2"), HASH_1));
   }
 
-  public StreamsBinaryCommandsTestBase(RedisProtocol protocol) {
-    super(protocol);
+  public StreamsBinaryCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   /**
diff --git a/src/test/java/redis/clients/jedis/commands/unified/StringValuesCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/StringValuesCommandsTestBase.java
index 491d304eea..e07b1f0522 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/StringValuesCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/StringValuesCommandsTestBase.java
@@ -12,6 +12,7 @@
 import io.redis.test.annotations.SinceRedisVersion;
 
 import org.junit.jupiter.api.Test;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.params.LCSParams;
 import redis.clients.jedis.resps.LCSMatchResult;
@@ -20,8 +21,8 @@
 
 public abstract class StringValuesCommandsTestBase extends UnifiedJedisCommandsTestBase {
 
-  public StringValuesCommandsTestBase(RedisProtocol protocol) {
-    super(protocol);
+  public StringValuesCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
@@ -35,14 +36,6 @@ public void setAndGet() {
     assertNull(jedis.get("bar"));
   }
 
-  @Test
-  public void getSet() {
-    String value = jedis.getSet("foo", "bar");
-    assertNull(value);
-    value = jedis.get("foo");
-    assertEquals("bar", value);
-  }
-
   @Test
   public void setGetWithParams() {
     jedis.del("foo");
diff --git a/src/test/java/redis/clients/jedis/commands/unified/UnifiedJedisCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/UnifiedJedisCommandsTestBase.java
index 1ae765d6e4..41581dc183 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/UnifiedJedisCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/UnifiedJedisCommandsTestBase.java
@@ -1,12 +1,17 @@
 package redis.clients.jedis.commands.unified;
 
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.UnifiedJedis;
 import redis.clients.jedis.commands.CommandsTestsParameters;
 
 public abstract class UnifiedJedisCommandsTestBase {
 
+  protected final Logger logger = LoggerFactory.getLogger(getClass());
+
   /**
    * Input data for parameterized tests. In principle all subclasses of this
    * class should be parameterized tests, to run with several versions of RESP.
@@ -15,7 +20,13 @@ public abstract class UnifiedJedisCommandsTestBase {
    */
   protected final RedisProtocol protocol;
 
-  protected UnifiedJedis jedis;
+  /**
+   * The {@link BaseRedisClient} instance to use for the tests. This is the subject-under-test.
+   */
+  protected BaseRedisClient jedis;
+
+
+  protected Class<? extends BaseRedisClient> clientType;
 
   /**
    * The RESP protocol is to be injected by the subclasses, usually via JUnit
@@ -26,7 +37,8 @@ public abstract class UnifiedJedisCommandsTestBase {
    *
    * @param protocol The RESP protocol to use during the tests.
    */
-  public UnifiedJedisCommandsTestBase(RedisProtocol protocol) {
+  public UnifiedJedisCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
     this.protocol = protocol;
+    this.clientType = clientType;
   }
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterAllKindOfValuesCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterAllKindOfValuesCommandsTest.java
index 350342462a..d815795a11 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterAllKindOfValuesCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterAllKindOfValuesCommandsTest.java
@@ -17,6 +17,7 @@
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.DefaultJedisClientConfig;
 import redis.clients.jedis.HostAndPorts;
 import redis.clients.jedis.RedisProtocol;
@@ -27,7 +28,7 @@
 import redis.clients.jedis.util.RedisVersionCondition;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.cluster.ClusterCommandsTestHelper#testParamsProvider")
 public class ClusterAllKindOfValuesCommandsTest extends AllKindOfValuesCommandsTestBase {
 
   @RegisterExtension
@@ -39,18 +40,22 @@ public class ClusterAllKindOfValuesCommandsTest extends AllKindOfValuesCommandsT
           HostAndPorts.getStableClusterServers().get(0),
           DefaultJedisClientConfig.builder().password("cluster").build());
 
-  public ClusterAllKindOfValuesCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ClusterAllKindOfValuesCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol);
+    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
     ClusterCommandsTestHelper.clearClusterData();
   }
 
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterBinaryValuesCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterBinaryValuesCommandsTest.java
index ca95f6c5a7..a24801b9ec 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterBinaryValuesCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterBinaryValuesCommandsTest.java
@@ -5,25 +5,30 @@
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.BinaryValuesCommandsTestBase;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.cluster.ClusterCommandsTestHelper#testParamsProvider")
 public class ClusterBinaryValuesCommandsTest extends BinaryValuesCommandsTestBase {
 
-  public ClusterBinaryValuesCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ClusterBinaryValuesCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol);
+    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
     ClusterCommandsTestHelper.clearClusterData();
   }
 
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterBitCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterBitCommandsTest.java
index 07a4198e38..167e64a84e 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterBitCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterBitCommandsTest.java
@@ -9,6 +9,7 @@
 import org.junit.jupiter.params.provider.MethodSource;
 import redis.clients.jedis.util.EnabledOnCommandCondition;
 import redis.clients.jedis.util.RedisVersionCondition;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.DefaultJedisClientConfig;
 import redis.clients.jedis.HostAndPorts;
 import redis.clients.jedis.RedisProtocol;
@@ -20,7 +21,7 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.cluster.ClusterCommandsTestHelper#testParamsProvider")
 public class ClusterBitCommandsTest extends BitCommandsTestBase {
 
   @RegisterExtension
@@ -32,18 +33,22 @@ public class ClusterBitCommandsTest extends BitCommandsTestBase {
           HostAndPorts.getStableClusterServers().get(0),
           DefaultJedisClientConfig.builder().password("cluster").build());
 
-  public ClusterBitCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ClusterBitCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol);
+    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
     ClusterCommandsTestHelper.clearClusterData();
   }
 
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterCommandsTestHelper.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterCommandsTestHelper.java
index 6c8f3e25cc..62223f3c3f 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterCommandsTestHelper.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterCommandsTestHelper.java
@@ -1,20 +1,30 @@
 package redis.clients.jedis.commands.unified.cluster;
 
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
+import java.util.Set;
+import java.util.stream.Stream;
 
-import redis.clients.jedis.DefaultJedisClientConfig;
-import redis.clients.jedis.HostAndPorts;
-import redis.clients.jedis.Jedis;
-import redis.clients.jedis.JedisCluster;
-import redis.clients.jedis.RedisProtocol;
+import org.junit.jupiter.params.provider.Arguments;
+import redis.clients.jedis.*;
 
 public class ClusterCommandsTestHelper {
 
-  static JedisCluster getCleanCluster(RedisProtocol protocol) {
+  static BaseRedisClient getCleanCluster(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
     clearClusterData();
-    return new JedisCluster(
-        Collections.singleton(HostAndPorts.getStableClusterServers().get(0)),
-        DefaultJedisClientConfig.builder().password("cluster").protocol(protocol).build());
+
+    DefaultJedisClientConfig conf = DefaultJedisClientConfig.builder().password("cluster").protocol(protocol).build();
+
+    if (clientType == JedisCluster.class) {
+      return new JedisCluster(
+          Collections.singleton(HostAndPorts.getStableClusterServers().get(0)),
+          conf);
+    } else if (clientType == RedisClusterClient.class) {
+      return RedisClusterClient.builder().node(HostAndPorts.getStableClusterServers().get(0)).clientConfig(conf).build();
+    } else {
+      throw new IllegalArgumentException("Unknown client type: " + clientType);
+    }
   }
 
   static void clearClusterData() {
@@ -25,4 +35,14 @@ static void clearClusterData() {
       }
     }
   }
+
+  public static Stream<Arguments> testParamsProvider() {
+    return Stream.of(
+        Arguments.of(RedisProtocol.RESP2, JedisCluster.class),
+        Arguments.of(RedisProtocol.RESP2, RedisClusterClient.class),
+        Arguments.of(RedisProtocol.RESP3, JedisCluster.class),
+        Arguments.of(RedisProtocol.RESP3, RedisClusterClient.class)
+    );
+  }
+
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterGeoCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterGeoCommandsTest.java
index 12f163175e..af7c9aec69 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterGeoCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterGeoCommandsTest.java
@@ -11,6 +11,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.GeoCoordinate;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.args.GeoUnit;
@@ -21,21 +22,26 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.cluster.ClusterCommandsTestHelper#testParamsProvider")
 public class ClusterGeoCommandsTest extends GeoCommandsTestBase {
 
-  public ClusterGeoCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ClusterGeoCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol);
+    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
+
     ClusterCommandsTestHelper.clearClusterData();
   }
 
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterHashesCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterHashesCommandsTest.java
index 4d1cd38214..90c2f1bd25 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterHashesCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterHashesCommandsTest.java
@@ -5,6 +5,7 @@
 import org.junit.jupiter.api.extension.RegisterExtension;
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.DefaultJedisClientConfig;
 import redis.clients.jedis.HostAndPorts;
 import redis.clients.jedis.RedisProtocol;
@@ -13,7 +14,7 @@
 import redis.clients.jedis.util.RedisVersionCondition;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.cluster.ClusterCommandsTestHelper#testParamsProvider")
 public class ClusterHashesCommandsTest extends HashesCommandsTestBase {
 
   @RegisterExtension
@@ -25,18 +26,22 @@ public class ClusterHashesCommandsTest extends HashesCommandsTestBase {
           HostAndPorts.getStableClusterServers().get(0),
           DefaultJedisClientConfig.builder().password("cluster").build());
 
-  public ClusterHashesCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ClusterHashesCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol);
+    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
     ClusterCommandsTestHelper.clearClusterData();
   }
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterHyperLogLogCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterHyperLogLogCommandsTest.java
index 62f1503c6a..6f04b92378 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterHyperLogLogCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterHyperLogLogCommandsTest.java
@@ -6,27 +6,32 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.HyperLogLogCommandsTestBase;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.cluster.ClusterCommandsTestHelper#testParamsProvider")
 public class ClusterHyperLogLogCommandsTest extends HyperLogLogCommandsTestBase {
 
-  public ClusterHyperLogLogCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ClusterHyperLogLogCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol);
+    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
     ClusterCommandsTestHelper.clearClusterData();
   }
 
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterListCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterListCommandsTest.java
index 569911ca7a..44b97940b1 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterListCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterListCommandsTest.java
@@ -17,6 +17,7 @@
 
 import redis.clients.jedis.DefaultJedisClientConfig;
 import redis.clients.jedis.HostAndPorts;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.args.ListDirection;
 import redis.clients.jedis.commands.unified.ListCommandsTestBase;
@@ -30,7 +31,7 @@
 import static org.junit.jupiter.api.Assertions.assertNull;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.cluster.ClusterCommandsTestHelper#testParamsProvider")
 public class ClusterListCommandsTest extends ListCommandsTestBase {
 
   private final Logger logger = LoggerFactory.getLogger(getClass());
@@ -44,18 +45,22 @@ public class ClusterListCommandsTest extends ListCommandsTestBase {
           HostAndPorts.getStableClusterServers().get(0),
           DefaultJedisClientConfig.builder().password("cluster").build());
 
-  public ClusterListCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ClusterListCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol);
+    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
     ClusterCommandsTestHelper.clearClusterData();
   }
 
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterSetCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterSetCommandsTest.java
index f9acf84521..f65c9fd78c 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterSetCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterSetCommandsTest.java
@@ -13,6 +13,7 @@
 
 import redis.clients.jedis.DefaultJedisClientConfig;
 import redis.clients.jedis.HostAndPorts;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.SetCommandsTestBase;
 import redis.clients.jedis.util.EnabledOnCommandCondition;
@@ -21,7 +22,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.cluster.ClusterCommandsTestHelper#testParamsProvider")
 public class ClusterSetCommandsTest extends SetCommandsTestBase {
 
   final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
@@ -30,8 +31,8 @@ public class ClusterSetCommandsTest extends SetCommandsTestBase {
   final byte[] bb = { 0x0B };
   final byte[] bc = { 0x0C };
 
-  public ClusterSetCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ClusterSetCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @RegisterExtension
@@ -45,12 +46,16 @@ public ClusterSetCommandsTest(RedisProtocol protocol) {
 
   @BeforeEach
   public void setUp() {
-    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol);
+    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
     ClusterCommandsTestHelper.clearClusterData();
   }
 
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterSortedSetCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterSortedSetCommandsTest.java
index cce518c361..17a59177d7 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterSortedSetCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterSortedSetCommandsTest.java
@@ -20,6 +20,7 @@
 
 import redis.clients.jedis.DefaultJedisClientConfig;
 import redis.clients.jedis.HostAndPorts;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.SortedSetCommandsTestBase;
 import redis.clients.jedis.params.ZAddParams;
@@ -31,7 +32,7 @@
 import redis.clients.jedis.util.RedisVersionCondition;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.cluster.ClusterCommandsTestHelper#testParamsProvider")
 public class ClusterSortedSetCommandsTest extends SortedSetCommandsTestBase {
 
   final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
@@ -49,18 +50,22 @@ public class ClusterSortedSetCommandsTest extends SortedSetCommandsTestBase {
           HostAndPorts.getStableClusterServers().get(0),
           DefaultJedisClientConfig.builder().password("cluster").build());
 
-  public ClusterSortedSetCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ClusterSortedSetCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol);
+    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
     ClusterCommandsTestHelper.clearClusterData();
   }
 
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterStreamsBinaryCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterStreamsBinaryCommandsTest.java
index e651c1a4c1..ad09cfb7a1 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterStreamsBinaryCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterStreamsBinaryCommandsTest.java
@@ -3,25 +3,30 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.StreamsBinaryCommandsTestBase;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.cluster.ClusterCommandsTestHelper#testParamsProvider")
 public class ClusterStreamsBinaryCommandsTest extends StreamsBinaryCommandsTestBase {
 
-  public ClusterStreamsBinaryCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ClusterStreamsBinaryCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Override
   protected void setUpTestClient() {
-    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol);
+    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
     ClusterCommandsTestHelper.clearClusterData();
   }
 
diff --git a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterStringValuesCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterStringValuesCommandsTest.java
index 3e8b89905d..dd86df1e3c 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterStringValuesCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/cluster/ClusterStringValuesCommandsTest.java
@@ -13,6 +13,7 @@
 
 import redis.clients.jedis.DefaultJedisClientConfig;
 import redis.clients.jedis.HostAndPorts;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.StringValuesCommandsTestBase;
 import redis.clients.jedis.params.LCSParams;
@@ -23,11 +24,11 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.cluster.ClusterCommandsTestHelper#testParamsProvider")
 public class ClusterStringValuesCommandsTest extends StringValuesCommandsTestBase {
 
-  public ClusterStringValuesCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ClusterStringValuesCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @RegisterExtension
@@ -41,12 +42,16 @@ public ClusterStringValuesCommandsTest(RedisProtocol protocol) {
 
   @BeforeEach
   public void setUp() {
-    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol);
+    jedis = ClusterCommandsTestHelper.getCleanCluster(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
     ClusterCommandsTestHelper.clearClusterData();
   }
 
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pipeline/BinaryStreamsPipelineCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pipeline/BinaryStreamsPipelineCommandsTest.java
index c22559e7a2..3ca2b2286b 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pipeline/BinaryStreamsPipelineCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pipeline/BinaryStreamsPipelineCommandsTest.java
@@ -4,6 +4,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.Response;
 import redis.clients.jedis.StreamEntryID;
@@ -26,7 +27,7 @@
 import static redis.clients.jedis.util.StreamEntryBinaryListMatcher.equalsStreamEntries;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class BinaryStreamsPipelineCommandsTest extends PipelineCommandsTestBase {
   protected static final byte[] STREAM_KEY_1 = "{binary-stream}-1".getBytes();
   protected static final byte[] STREAM_KEY_2 = "{binary-stream}-2".getBytes();
@@ -51,8 +52,8 @@ public class BinaryStreamsPipelineCommandsTest extends PipelineCommandsTestBase
     stream2Entries.add(new StreamEntryBinary(new StreamEntryID("0-2"), HASH_1));
   }
 
-  public BinaryStreamsPipelineCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public BinaryStreamsPipelineCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   /**
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pipeline/GeoPipelineCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pipeline/GeoPipelineCommandsTest.java
index 1083e0a73f..356a0e2087 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pipeline/GeoPipelineCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pipeline/GeoPipelineCommandsTest.java
@@ -19,6 +19,7 @@
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.GeoCoordinate;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.Response;
@@ -31,7 +32,7 @@
 import redis.clients.jedis.util.SafeEncoder;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class GeoPipelineCommandsTest extends PipelineCommandsTestBase {
 
   protected final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
@@ -42,8 +43,8 @@ public class GeoPipelineCommandsTest extends PipelineCommandsTestBase {
 
   private static final double EPSILON = 1e-5;
 
-  public GeoPipelineCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public GeoPipelineCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pipeline/HashesPipelineCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pipeline/HashesPipelineCommandsTest.java
index 122eef6350..fbd9692855 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pipeline/HashesPipelineCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pipeline/HashesPipelineCommandsTest.java
@@ -8,10 +8,11 @@
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class HashesPipelineCommandsTest extends PipelineCommandsTestBase {
 
   final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
@@ -23,8 +24,8 @@ public class HashesPipelineCommandsTest extends PipelineCommandsTestBase {
   final byte[] bbar3 = { 0x05, 0x06, 0x07, 0x08, 0x0C };
   final byte[] bbarstar = { 0x05, 0x06, 0x07, 0x08, '*' };
 
-  public HashesPipelineCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public HashesPipelineCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pipeline/ListPipelineCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pipeline/ListPipelineCommandsTest.java
index 71a93f3abf..e5cbc55849 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pipeline/ListPipelineCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pipeline/ListPipelineCommandsTest.java
@@ -17,6 +17,7 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.Response;
 import redis.clients.jedis.args.ListDirection;
@@ -26,7 +27,7 @@
 import redis.clients.jedis.util.KeyValue;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class ListPipelineCommandsTest extends PipelineCommandsTestBase {
 
   private final Logger logger = LoggerFactory.getLogger(getClass());
@@ -45,8 +46,8 @@ public class ListPipelineCommandsTest extends PipelineCommandsTestBase {
   protected final byte[] bx = { 0x02, 0x04 };
   protected final byte[] bdst = { 0x11, 0x12, 0x13, 0x14 };
 
-  public ListPipelineCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public ListPipelineCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pipeline/PipelineCommandsTestBase.java b/src/test/java/redis/clients/jedis/commands/unified/pipeline/PipelineCommandsTestBase.java
index aaf9058848..42219288c0 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pipeline/PipelineCommandsTestBase.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pipeline/PipelineCommandsTestBase.java
@@ -3,15 +3,22 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.provider.Arguments;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import redis.clients.jedis.util.EnabledOnCommandCondition;
 import redis.clients.jedis.util.RedisVersionCondition;
 import redis.clients.jedis.*;
 import redis.clients.jedis.commands.CommandsTestsParameters;
 import redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper;
 
+import java.util.stream.Stream;
+
 public abstract class PipelineCommandsTestBase {
 
-  protected JedisPooled jedis;
+  private static final Logger logger = LoggerFactory.getLogger(PipelineCommandsTestBase.class);
+
+  protected BaseRedisClient jedis;
   protected Pipeline pipe;
   /**
    * Input data for parameterized tests. In principle all subclasses of this class should be
@@ -19,6 +26,7 @@ public abstract class PipelineCommandsTestBase {
    * @see CommandsTestsParameters#respVersions()
    */
   protected final RedisProtocol protocol;
+  protected final Class<? extends BaseRedisClient> clientType;
 
   @RegisterExtension
   public RedisVersionCondition versionCondition = new RedisVersionCondition(PooledCommandsTestHelper.nodeInfo);
@@ -32,21 +40,28 @@ public abstract class PipelineCommandsTestBase {
    * call this constructor.
    *
    * @param protocol The RESP protocol to use during the tests.
+   * @param clientType The client type to use during the tests.
    */
-  public PipelineCommandsTestBase(RedisProtocol protocol) {
+  public PipelineCommandsTestBase(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
     this.protocol = protocol;
+    this.clientType = clientType;
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
-    pipe = jedis.pipelined();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
+    pipe = (Pipeline) jedis.pipelined();
   }
 
   @AfterEach
   public void tearDown() {
     pipe.close();
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
+    PooledCommandsTestHelper.clearData();
   }
+
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pipeline/SetPipelineCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pipeline/SetPipelineCommandsTest.java
index d86f0c302b..33485dac51 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pipeline/SetPipelineCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pipeline/SetPipelineCommandsTest.java
@@ -24,13 +24,14 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.Response;
 import redis.clients.jedis.params.ScanParams;
 import redis.clients.jedis.resps.ScanResult;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class SetPipelineCommandsTest extends PipelineCommandsTestBase {
 
   final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
@@ -47,8 +48,8 @@ public class SetPipelineCommandsTest extends PipelineCommandsTestBase {
   final byte[] bbar3 = { 0x05, 0x06, 0x07, 0x08, 0x0C };
   final byte[] bbarstar = { 0x05, 0x06, 0x07, 0x08, '*' };
 
-  public SetPipelineCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public SetPipelineCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pipeline/SortedSetPipelineCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pipeline/SortedSetPipelineCommandsTest.java
index 602f963959..1d027bbbc3 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pipeline/SortedSetPipelineCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pipeline/SortedSetPipelineCommandsTest.java
@@ -24,6 +24,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.Response;
 import redis.clients.jedis.args.SortedSetOption;
@@ -39,7 +40,7 @@
 import redis.clients.jedis.util.SafeEncoder;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class SortedSetPipelineCommandsTest extends PipelineCommandsTestBase {
 
   final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
@@ -58,8 +59,8 @@ public class SortedSetPipelineCommandsTest extends PipelineCommandsTestBase {
   final byte[] bbar3 = { 0x05, 0x06, 0x07, 0x08, 0x0C };
   final byte[] bbarstar = { 0x05, 0x06, 0x07, 0x08, '*' };
 
-  public SortedSetPipelineCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public SortedSetPipelineCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pipeline/StreamsPipelineCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pipeline/StreamsPipelineCommandsTest.java
index 5790200205..cf366fad02 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pipeline/StreamsPipelineCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pipeline/StreamsPipelineCommandsTest.java
@@ -34,9 +34,11 @@
 import org.junit.jupiter.params.provider.MethodSource;
 import redis.clients.jedis.util.RedisVersionUtil;
 import org.hamcrest.Matchers;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.BuilderFactory;
 import redis.clients.jedis.Pipeline;
 import redis.clients.jedis.RedisProtocol;
+import redis.clients.jedis.UnifiedJedis;
 import redis.clients.jedis.Response;
 import redis.clients.jedis.StreamEntryID;
 import redis.clients.jedis.exceptions.JedisDataException;
@@ -59,11 +61,11 @@
 import redis.clients.jedis.util.SafeEncoder;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class StreamsPipelineCommandsTest extends PipelineCommandsTestBase {
 
-  public StreamsPipelineCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public StreamsPipelineCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Test
@@ -474,7 +476,7 @@ public void xreadBlockZero() throws InterruptedException {
       @Override
       public void run() {
         long startTime = System.currentTimeMillis();
-        Pipeline blockPipe = jedis.pipelined();
+        Pipeline blockPipe = (Pipeline) jedis.pipelined();
         Map<String, StreamEntryID> streamQuery = singletonMap("block0-stream", new StreamEntryID());
         Response<List<Entry<String, List<StreamEntry>>>> read =
             blockPipe.xread(XReadParams.xReadParams().block(0), streamQuery);
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledAllKindOfValuesCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledAllKindOfValuesCommandsTest.java
index 42eb4eed02..4f8ca6ec81 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledAllKindOfValuesCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledAllKindOfValuesCommandsTest.java
@@ -6,13 +6,14 @@
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.AllKindOfValuesCommandsTestBase;
 import redis.clients.jedis.util.EnabledOnCommandCondition;
 import redis.clients.jedis.util.RedisVersionCondition;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledAllKindOfValuesCommandsTest extends AllKindOfValuesCommandsTestBase {
 
   @RegisterExtension
@@ -20,18 +21,21 @@ public class PooledAllKindOfValuesCommandsTest extends AllKindOfValuesCommandsTe
   @RegisterExtension
   public EnabledOnCommandCondition enabledOnCommandCondition = new EnabledOnCommandCondition(PooledCommandsTestHelper.nodeInfo);
 
-  public PooledAllKindOfValuesCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledAllKindOfValuesCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
   public void cleanUp() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledBinaryValuesCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledBinaryValuesCommandsTest.java
index 6d5d26551a..e576a268fd 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledBinaryValuesCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledBinaryValuesCommandsTest.java
@@ -5,25 +5,29 @@
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.BinaryValuesCommandsTestBase;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledBinaryValuesCommandsTest extends BinaryValuesCommandsTestBase {
 
-  public PooledBinaryValuesCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledBinaryValuesCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
   public void cleanUp() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledBitCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledBitCommandsTest.java
index cff9ff3317..9e68b7b238 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledBitCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledBitCommandsTest.java
@@ -8,11 +8,12 @@
 import redis.clients.jedis.util.EnabledOnCommandCondition;
 import redis.clients.jedis.util.RedisVersionCondition;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.BitCommandsTestBase;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledBitCommandsTest extends BitCommandsTestBase {
 
   @RegisterExtension
@@ -20,18 +21,21 @@ public class PooledBitCommandsTest extends BitCommandsTestBase {
   @RegisterExtension
   public EnabledOnCommandCondition enabledOnCommandCondition = new EnabledOnCommandCondition(PooledCommandsTestHelper.nodeInfo);
 
-  public PooledBitCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledBitCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
   public void cleanUp() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledCommandsTestHelper.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledCommandsTestHelper.java
index 86e1f666de..573288389b 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledCommandsTestHelper.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledCommandsTestHelper.java
@@ -1,14 +1,32 @@
 package redis.clients.jedis.commands.unified.pooled;
 
+import java.util.stream.Stream;
+
+import org.junit.jupiter.params.provider.Arguments;
 import redis.clients.jedis.*;
 
 public class PooledCommandsTestHelper {
 
   public static final EndpointConfig nodeInfo = HostAndPorts.getRedisEndpoint("standalone0");
 
-  public static JedisPooled getPooled(RedisProtocol redisProtocol) {
-    return new JedisPooled(nodeInfo.getHostAndPort(), nodeInfo.getClientConfigBuilder()
-        .protocol(redisProtocol).build());
+  public static BaseRedisClient getCleanClient(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    clearData();
+
+    DefaultJedisClientConfig conf = DefaultJedisClientConfig.builder()
+        .password(nodeInfo.getPassword())
+        .protocol(protocol)
+        .build();
+
+    if (clientType == JedisPooled.class) {
+      return new JedisPooled(nodeInfo.getHostAndPort(), conf);
+    } else if (clientType == RedisClient.class) {
+      return RedisClient.builder()
+          .hostAndPort(nodeInfo.getHostAndPort())
+          .config(conf)
+          .build();
+    } else {
+      throw new IllegalArgumentException("Unknown client type: " + clientType);
+    }
   }
 
   public static void clearData() {
@@ -17,4 +35,14 @@ public static void clearData() {
       node.flushAll();
     }
   }
+
+  public static Stream<Arguments> testParamsProvider() {
+    return Stream.of(
+        Arguments.of(RedisProtocol.RESP2, JedisPooled.class),
+        Arguments.of(RedisProtocol.RESP2, RedisClient.class),
+        Arguments.of(RedisProtocol.RESP3, JedisPooled.class),
+        Arguments.of(RedisProtocol.RESP3, RedisClient.class)
+    );
+  }
+
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledGeoCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledGeoCommandsTest.java
index 99ffb201c1..315f36c00a 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledGeoCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledGeoCommandsTest.java
@@ -5,25 +5,29 @@
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.GeoCommandsTestBase;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledGeoCommandsTest extends GeoCommandsTestBase {
 
-  public PooledGeoCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledGeoCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
   public void cleanUp() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledHashesCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledHashesCommandsTest.java
index 2629301f2b..ef47df93e3 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledHashesCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledHashesCommandsTest.java
@@ -6,13 +6,14 @@
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.HashesCommandsTestBase;
 import redis.clients.jedis.util.EnabledOnCommandCondition;
 import redis.clients.jedis.util.RedisVersionCondition;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledHashesCommandsTest extends HashesCommandsTestBase {
 
   @RegisterExtension
@@ -20,18 +21,21 @@ public class PooledHashesCommandsTest extends HashesCommandsTestBase {
   @RegisterExtension
   public EnabledOnCommandCondition enabledOnCommandCondition = new EnabledOnCommandCondition(PooledCommandsTestHelper.nodeInfo);
 
-  public PooledHashesCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledHashesCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
   public void cleanUp() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledHyperLogLogCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledHyperLogLogCommandsTest.java
index bafd451fb1..17c5c47e65 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledHyperLogLogCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledHyperLogLogCommandsTest.java
@@ -4,25 +4,29 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.HyperLogLogCommandsTestBase;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledHyperLogLogCommandsTest extends HyperLogLogCommandsTestBase {
 
-  public PooledHyperLogLogCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledHyperLogLogCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
   public void cleanUp() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledListCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledListCommandsTest.java
index adf0e13a1b..90baf75297 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledListCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledListCommandsTest.java
@@ -6,13 +6,14 @@
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.ListCommandsTestBase;
 import redis.clients.jedis.util.EnabledOnCommandCondition;
 import redis.clients.jedis.util.RedisVersionCondition;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledListCommandsTest extends ListCommandsTestBase {
 
   @RegisterExtension
@@ -20,18 +21,21 @@ public class PooledListCommandsTest extends ListCommandsTestBase {
   @RegisterExtension
   public EnabledOnCommandCondition enabledOnCommandCondition = new EnabledOnCommandCondition(PooledCommandsTestHelper.nodeInfo);
 
-  public PooledListCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledListCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
   public void cleanUp() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledMiscellaneousTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledMiscellaneousTest.java
index 7c2f2487e9..bf704669c0 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledMiscellaneousTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledMiscellaneousTest.java
@@ -20,6 +20,7 @@
 
 import redis.clients.jedis.AbstractPipeline;
 import redis.clients.jedis.AbstractTransaction;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.Response;
 import redis.clients.jedis.commands.unified.UnifiedJedisCommandsTestBase;
@@ -28,7 +29,7 @@
 import redis.clients.jedis.util.RedisVersionCondition;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledMiscellaneousTest extends UnifiedJedisCommandsTestBase {
 
   @RegisterExtension
@@ -36,19 +37,22 @@ public class PooledMiscellaneousTest extends UnifiedJedisCommandsTestBase {
   @RegisterExtension
   public EnabledOnCommandCondition enabledOnCommandCondition = new EnabledOnCommandCondition(PooledCommandsTestHelper.nodeInfo);
 
-  public PooledMiscellaneousTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledMiscellaneousTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
   public void cleanUp() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 
   @Test
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledSetCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledSetCommandsTest.java
index 2daf46aee3..864d1105ba 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledSetCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledSetCommandsTest.java
@@ -6,13 +6,14 @@
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.SetCommandsTestBase;
 import redis.clients.jedis.util.EnabledOnCommandCondition;
 import redis.clients.jedis.util.RedisVersionCondition;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledSetCommandsTest extends SetCommandsTestBase {
 
   @RegisterExtension
@@ -20,18 +21,21 @@ public class PooledSetCommandsTest extends SetCommandsTestBase {
   @RegisterExtension
   public EnabledOnCommandCondition enabledOnCommandCondition = new EnabledOnCommandCondition(PooledCommandsTestHelper.nodeInfo);
 
-  public PooledSetCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledSetCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
-  public void cleanUp() {
-    jedis.close();
+  public void tearDown() {
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledSortedSetCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledSortedSetCommandsTest.java
index e0fe2a745f..e51c425ad8 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledSortedSetCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledSortedSetCommandsTest.java
@@ -6,13 +6,14 @@
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.SortedSetCommandsTestBase;
 import redis.clients.jedis.util.EnabledOnCommandCondition;
 import redis.clients.jedis.util.RedisVersionCondition;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledSortedSetCommandsTest extends SortedSetCommandsTestBase {
 
   @RegisterExtension
@@ -20,18 +21,21 @@ public class PooledSortedSetCommandsTest extends SortedSetCommandsTestBase {
   @RegisterExtension
   public EnabledOnCommandCondition enabledOnCommandCondition = new EnabledOnCommandCondition(PooledCommandsTestHelper.nodeInfo);
 
-  public PooledSortedSetCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledSortedSetCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
   public void cleanUp() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledStreamsBinaryCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledStreamsBinaryCommandsTest.java
index 93f4279b4a..a2cbfed816 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledStreamsBinaryCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledStreamsBinaryCommandsTest.java
@@ -3,25 +3,30 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.StreamsBinaryCommandsTestBase;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledStreamsBinaryCommandsTest extends StreamsBinaryCommandsTestBase {
 
-  public PooledStreamsBinaryCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledStreamsBinaryCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @Override
   public void setUpTestClient() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
   public void tearDown() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 
 }
diff --git a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledStringValuesCommandsTest.java b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledStringValuesCommandsTest.java
index fe45958d39..f0c62e033b 100644
--- a/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledStringValuesCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/commands/unified/pooled/PooledStringValuesCommandsTest.java
@@ -6,13 +6,14 @@
 import org.junit.jupiter.params.ParameterizedClass;
 import org.junit.jupiter.params.provider.MethodSource;
 
+import redis.clients.jedis.BaseRedisClient;
 import redis.clients.jedis.RedisProtocol;
 import redis.clients.jedis.commands.unified.StringValuesCommandsTestBase;
 import redis.clients.jedis.util.EnabledOnCommandCondition;
 import redis.clients.jedis.util.RedisVersionCondition;
 
 @ParameterizedClass
-@MethodSource("redis.clients.jedis.commands.CommandsTestsParameters#respVersions")
+@MethodSource("redis.clients.jedis.commands.unified.pooled.PooledCommandsTestHelper#testParamsProvider")
 public class PooledStringValuesCommandsTest extends StringValuesCommandsTestBase {
 
   @RegisterExtension
@@ -20,18 +21,21 @@ public class PooledStringValuesCommandsTest extends StringValuesCommandsTestBase
   @RegisterExtension
   public EnabledOnCommandCondition enabledOnCommandCondition = new EnabledOnCommandCondition(PooledCommandsTestHelper.nodeInfo);
 
-  public PooledStringValuesCommandsTest(RedisProtocol protocol) {
-    super(protocol);
+  public PooledStringValuesCommandsTest(RedisProtocol protocol, Class<? extends BaseRedisClient> clientType) {
+    super(protocol, clientType);
   }
 
   @BeforeEach
   public void setUp() {
-    jedis = PooledCommandsTestHelper.getPooled(protocol);
-    PooledCommandsTestHelper.clearData();
+    jedis = PooledCommandsTestHelper.getCleanClient(protocol, clientType);
   }
 
   @AfterEach
   public void cleanUp() {
-    jedis.close();
+    try {
+      jedis.close();
+    } catch (Exception e) {
+      logger.warn("Exception while closing jedis", e);
+    }
   }
 }
diff --git a/src/test/java/redis/clients/jedis/util/RedisVersionUtil.java b/src/test/java/redis/clients/jedis/util/RedisVersionUtil.java
index 16b5a0bbb5..a7a78d5383 100644
--- a/src/test/java/redis/clients/jedis/util/RedisVersionUtil.java
+++ b/src/test/java/redis/clients/jedis/util/RedisVersionUtil.java
@@ -22,7 +22,7 @@ public static RedisVersion getRedisVersion(Connection conn) {
     }
   }
 
-  public static RedisVersion getRedisVersion(UnifiedJedis jedis) {
+  public static RedisVersion getRedisVersion(BaseRedisClient jedis) {
     if (forcedVersion != null) {
       return forcedVersion;
     }