diff --git a/src/main/java/redis/clients/jedis/UnifiedJedis.java b/src/main/java/redis/clients/jedis/UnifiedJedis.java
index 4b2e38faac..5bdc78f1f5 100644
--- a/src/main/java/redis/clients/jedis/UnifiedJedis.java
+++ b/src/main/java/redis/clients/jedis/UnifiedJedis.java
@@ -45,9 +45,54 @@
 import redis.clients.jedis.util.JedisURIHelper;
 import redis.clients.jedis.util.KeyValue;
 
-public class UnifiedJedis implements JedisCommands, JedisBinaryCommands,
-    SampleKeyedCommands, SampleBinaryKeyedCommands, RedisModuleCommands,
-    AutoCloseable {
+/**
+ * UnifiedJedis provides a single interface for multiple Redis deployment types. Supports standalone
+ * Redis servers, Redis Sentinel, Redis Cluster, and sharded Redis deployments. Implements multiple
+ * command interfaces for Redis operations.
+ * <p>
+ * Features:
+ * <ul>
+ * <li>Redis commands across different Redis versions</li>
+ * <li>Connection management for different Redis topologies</li>
+ * <li>Connection pooling</li>
+ * <li>Redis modules (RedisJSON, RediSearch, RedisTimeSeries)</li>
+ * <li>Client-side caching</li>
+ * <li>Pipeline and transaction operations</li>
+ * </ul>
+ * <p>
+ * Basic usage with default connection (localhost:6379):
+ *
+ * <pre>
+ * UnifiedJedis jedis = new UnifiedJedis();
+ * jedis.set("key", "value");
+ * String value = jedis.get("key");
+ * jedis.close();
+ * </pre>
+ * <p>
+ * Usage with specific host and port:
+ *
+ * <pre>
+ * UnifiedJedis jedis = new UnifiedJedis(new HostAndPort("localhost", 6379));
+ * jedis.set("key", "value");
+ * String value = jedis.get("key");
+ * jedis.close();
+ * </pre>
+ * <p>
+ * Usage with URI (including authentication):
+ *
+ * <pre>
+ * UnifiedJedis jedis = new UnifiedJedis(URI.create("redis://user:password@localhost:6379/0"));
+ * jedis.set("key", "value");
+ * String value = jedis.get("key");
+ * jedis.close();
+ * </pre>
+ * <p>
+ * Production usage requires configuration of connection timeouts and connection pooling.
+ * @see JedisCluster For dedicated Redis Cluster support
+ * @see JedisSentineled For dedicated Redis Sentinel support
+ */
+public class UnifiedJedis implements JedisCommands, JedisBinaryCommands, SampleKeyedCommands,
+    SampleBinaryKeyedCommands, RedisModuleCommands, AutoCloseable {
 
   @Deprecated
   protected RedisProtocol protocol = null;
@@ -57,34 +102,49 @@ public class UnifiedJedis implements JedisCommands, JedisBinaryCommands,
   private JedisBroadcastAndRoundRobinConfig broadcastAndRoundRobinConfig = null;
   private final Cache cache;
 
+  /**
+   * Creates a UnifiedJedis instance with default host and port (localhost:6379).
+   */
   public UnifiedJedis() {
     this(new HostAndPort(Protocol.DEFAULT_HOST, Protocol.DEFAULT_PORT));
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified host and port.
+   * @param hostAndPort The host and port of the Redis server
+   */
   public UnifiedJedis(HostAndPort hostAndPort) {
     this(new PooledConnectionProvider(hostAndPort), (RedisProtocol) null);
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified URL.
+   * @param url The URL of the Redis server (e.g., "redis://localhost:6379")
+   */
   public UnifiedJedis(final String url) {
     this(URI.create(url));
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified URI. The URI can include authentication
+   * information, database index, and SSL configuration.
+   * @param uri The URI of the Redis server (e.g., "redis://user:password@localhost:6379/1")
+   */
   public UnifiedJedis(final URI uri) {
-    this(JedisURIHelper.getHostAndPort(uri), DefaultJedisClientConfig.builder()
-        .user(JedisURIHelper.getUser(uri)).password(JedisURIHelper.getPassword(uri))
-        .database(JedisURIHelper.getDBIndex(uri)).protocol(JedisURIHelper.getRedisProtocol(uri))
-        .ssl(JedisURIHelper.isRedisSSLScheme(uri)).build());
+    this(JedisURIHelper.getHostAndPort(uri),
+        DefaultJedisClientConfig.builder().user(JedisURIHelper.getUser(uri))
+            .password(JedisURIHelper.getPassword(uri)).database(JedisURIHelper.getDBIndex(uri))
+            .protocol(JedisURIHelper.getRedisProtocol(uri))
+            .ssl(JedisURIHelper.isRedisSSLScheme(uri)).build());
   }
 
   /**
-   * Create a new UnifiedJedis with the provided URI and JedisClientConfig object. Note that all fields
-   * that can be parsed from the URI will be used instead of the corresponding configuration values. This includes
-   * the following fields: user, password, database, protocol version, and whether to use SSL.
-   *
-   * For example, if the URI is "redis://user:password@localhost:6379/1", the user and password fields will be set
-   * to "user" and "password" respectively, the database field will be set to 1. Those fields will be ignored
-   * from the JedisClientConfig object.
-   *
+   * Create a new UnifiedJedis with the provided URI and JedisClientConfig object. Note that all
+   * fields that can be parsed from the URI will be used instead of the corresponding configuration
+   * values. This includes the following fields: user, password, database, protocol version, and
+   * whether to use SSL. For example, if the URI is "redis://user:password@localhost:6379/1", the
+   * user and password fields will be set to "user" and "password" respectively, the database field
+   * will be set to 1. Those fields will be ignored from the JedisClientConfig object.
    * @param uri The URI to connect to
    * @param config The JedisClientConfig object to use
    */
@@ -95,33 +155,70 @@ public UnifiedJedis(final URI uri, JedisClientConfig config) {
         .blockingSocketTimeoutMillis(config.getBlockingSocketTimeoutMillis())
         .user(JedisURIHelper.getUser(uri)).password(JedisURIHelper.getPassword(uri))
         .database(JedisURIHelper.getDBIndex(uri)).clientName(config.getClientName())
-        .protocol(JedisURIHelper.getRedisProtocol(uri))
-        .ssl(JedisURIHelper.isRedisSSLScheme(uri)).sslSocketFactory(config.getSslSocketFactory())
-        .sslParameters(config.getSslParameters()).hostnameVerifier(config.getHostnameVerifier()).build());
+        .protocol(JedisURIHelper.getRedisProtocol(uri)).ssl(JedisURIHelper.isRedisSSLScheme(uri))
+        .sslSocketFactory(config.getSslSocketFactory()).sslParameters(config.getSslParameters())
+        .hostnameVerifier(config.getHostnameVerifier()).build());
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified host, port, and client configuration.
+   * @param hostAndPort The host and port of the Redis server
+   * @param clientConfig The client configuration
+   */
   public UnifiedJedis(HostAndPort hostAndPort, JedisClientConfig clientConfig) {
     this(new PooledConnectionProvider(hostAndPort, clientConfig), clientConfig.getRedisProtocol());
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified host, port, client configuration, and cache
+   * configuration. This constructor enables client-side caching.
+   * @param hostAndPort The host and port of the Redis server
+   * @param clientConfig The client configuration
+   * @param cacheConfig The cache configuration
+   */
   @Experimental
-  public UnifiedJedis(HostAndPort hostAndPort, JedisClientConfig clientConfig, CacheConfig cacheConfig) {
+  public UnifiedJedis(HostAndPort hostAndPort, JedisClientConfig clientConfig,
+      CacheConfig cacheConfig) {
     this(hostAndPort, clientConfig, CacheFactory.getCache(cacheConfig));
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified host, port, client configuration, and cache.
+   * This constructor enables client-side caching with a pre-configured cache.
+   * @param hostAndPort The host and port of the Redis server
+   * @param clientConfig The client configuration
+   * @param cache The pre-configured cache
+   */
   @Experimental
   public UnifiedJedis(HostAndPort hostAndPort, JedisClientConfig clientConfig, Cache cache) {
-    this(new PooledConnectionProvider(hostAndPort, clientConfig, cache), clientConfig.getRedisProtocol(), cache);
+    this(new PooledConnectionProvider(hostAndPort, clientConfig, cache),
+        clientConfig.getRedisProtocol(), cache);
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified connection provider.
+   * @param provider The connection provider
+   */
   public UnifiedJedis(ConnectionProvider provider) {
     this(new DefaultCommandExecutor(provider), provider);
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified connection provider and Redis protocol.
+   * @param provider The connection provider
+   * @param protocol The Redis protocol version
+   */
   protected UnifiedJedis(ConnectionProvider provider, RedisProtocol protocol) {
     this(new DefaultCommandExecutor(provider), provider, new CommandObjects(), protocol);
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified connection provider, Redis protocol, and
+   * cache. This constructor enables client-side caching.
+   * @param provider The connection provider
+   * @param protocol The Redis protocol version
+   * @param cache The cache
+   */
   @Experimental
   protected UnifiedJedis(ConnectionProvider provider, RedisProtocol protocol, Cache cache) {
     this(new DefaultCommandExecutor(provider), provider, new CommandObjects(), protocol, cache);
@@ -168,54 +265,113 @@ public UnifiedJedis(Connection connection) {
     }
   }
 
+  /**
+   * Creates a UnifiedJedis instance for a Redis Cluster with the specified nodes, client
+   * configuration, and retry attempts.
+   * @param jedisClusterNodes The set of cluster nodes
+   * @param clientConfig The client configuration
+   * @param maxAttempts The maximum number of retry attempts
+   * @deprecated Use constructor with explicit maxTotalRetriesDuration parameter
+   */
   @Deprecated
-  public UnifiedJedis(Set<HostAndPort> jedisClusterNodes, JedisClientConfig clientConfig, int maxAttempts) {
+  public UnifiedJedis(Set<HostAndPort> jedisClusterNodes, JedisClientConfig clientConfig,
+      int maxAttempts) {
     this(jedisClusterNodes, clientConfig, maxAttempts,
         Duration.ofMillis(maxAttempts * clientConfig.getSocketTimeoutMillis()));
   }
 
+  /**
+   * Creates a UnifiedJedis instance for a Redis Cluster with the specified nodes, client
+   * configuration, and retry parameters.
+   * @param jedisClusterNodes The set of cluster nodes
+   * @param clientConfig The client configuration
+   * @param maxAttempts The maximum number of retry attempts
+   * @param maxTotalRetriesDuration The maximum total duration for retries
+   * @deprecated Use constructor with ClusterConnectionProvider
+   */
   @Deprecated
-  public UnifiedJedis(Set<HostAndPort> jedisClusterNodes, JedisClientConfig clientConfig, int maxAttempts,
-      Duration maxTotalRetriesDuration) {
-    this(new ClusterConnectionProvider(jedisClusterNodes, clientConfig), maxAttempts, maxTotalRetriesDuration,
-        clientConfig.getRedisProtocol());
+  public UnifiedJedis(Set<HostAndPort> jedisClusterNodes, JedisClientConfig clientConfig,
+      int maxAttempts, Duration maxTotalRetriesDuration) {
+    this(new ClusterConnectionProvider(jedisClusterNodes, clientConfig), maxAttempts,
+        maxTotalRetriesDuration, clientConfig.getRedisProtocol());
   }
 
+  /**
+   * Creates a UnifiedJedis instance for a Redis Cluster with the specified nodes, client
+   * configuration, pool configuration, and retry parameters.
+   * @param jedisClusterNodes The set of cluster nodes
+   * @param clientConfig The client configuration
+   * @param poolConfig The connection pool configuration
+   * @param maxAttempts The maximum number of retry attempts
+   * @param maxTotalRetriesDuration The maximum total duration for retries
+   * @deprecated Use constructor with ClusterConnectionProvider
+   */
   @Deprecated
   public UnifiedJedis(Set<HostAndPort> jedisClusterNodes, JedisClientConfig clientConfig,
-      GenericObjectPoolConfig<Connection> poolConfig, int maxAttempts, Duration maxTotalRetriesDuration) {
+      GenericObjectPoolConfig<Connection> poolConfig, int maxAttempts,
+      Duration maxTotalRetriesDuration) {
     this(new ClusterConnectionProvider(jedisClusterNodes, clientConfig, poolConfig), maxAttempts,
         maxTotalRetriesDuration, clientConfig.getRedisProtocol());
   }
 
-  // Uses a fetched connection to process protocol. Should be avoided if possible.
-  public UnifiedJedis(ClusterConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration) {
+  /**
+   * Creates a UnifiedJedis instance for a Redis Cluster with the specified connection provider and
+   * retry parameters. Uses a fetched connection to process protocol. Should be avoided if possible.
+   * @param provider The cluster connection provider
+   * @param maxAttempts The maximum number of retry attempts
+   * @param maxTotalRetriesDuration The maximum total duration for retries
+   */
+  public UnifiedJedis(ClusterConnectionProvider provider, int maxAttempts,
+      Duration maxTotalRetriesDuration) {
     this(new ClusterCommandExecutor(provider, maxAttempts, maxTotalRetriesDuration), provider,
         new ClusterCommandObjects());
   }
 
-  protected UnifiedJedis(ClusterConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration,
-      RedisProtocol protocol) {
+  /**
+   * Creates a UnifiedJedis instance for a Redis Cluster with the specified connection provider,
+   * retry parameters, and protocol.
+   * @param provider The cluster connection provider
+   * @param maxAttempts The maximum number of retry attempts
+   * @param maxTotalRetriesDuration The maximum total duration for retries
+   * @param protocol The Redis protocol version
+   */
+  protected UnifiedJedis(ClusterConnectionProvider provider, int maxAttempts,
+      Duration maxTotalRetriesDuration, RedisProtocol protocol) {
     this(new ClusterCommandExecutor(provider, maxAttempts, maxTotalRetriesDuration), provider,
         new ClusterCommandObjects(), protocol);
   }
 
+  /**
+   * Creates a UnifiedJedis instance for a Redis Cluster with the specified connection provider,
+   * retry parameters, protocol, and cache. This constructor enables client-side caching.
+   * @param provider The cluster connection provider
+   * @param maxAttempts The maximum number of retry attempts
+   * @param maxTotalRetriesDuration The maximum total duration for retries
+   * @param protocol The Redis protocol version
+   * @param cache The cache
+   */
   @Experimental
-  protected UnifiedJedis(ClusterConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration,
-      RedisProtocol protocol, Cache cache) {
+  protected UnifiedJedis(ClusterConnectionProvider provider, int maxAttempts,
+      Duration maxTotalRetriesDuration, RedisProtocol protocol, Cache cache) {
     this(new ClusterCommandExecutor(provider, maxAttempts, maxTotalRetriesDuration), provider,
         new ClusterCommandObjects(), protocol, cache);
   }
 
   /**
+   * Creates a UnifiedJedis instance with a sharded connection provider.
+   * @param provider The sharded connection provider
    * @deprecated Sharding/Sharded feature will be removed in next major release.
    */
   @Deprecated
   public UnifiedJedis(ShardedConnectionProvider provider) {
-    this(new DefaultCommandExecutor(provider), provider, new ShardedCommandObjects(provider.getHashingAlgo()));
+    this(new DefaultCommandExecutor(provider), provider,
+        new ShardedCommandObjects(provider.getHashingAlgo()));
   }
 
   /**
+   * Creates a UnifiedJedis instance with a sharded connection provider and tag pattern.
+   * @param provider The sharded connection provider
+   * @param tagPattern The pattern for extracting key tags
    * @deprecated Sharding/Sharded feature will be removed in next major release.
    */
   @Deprecated
@@ -224,16 +380,25 @@ public UnifiedJedis(ShardedConnectionProvider provider, Pattern tagPattern) {
         new ShardedCommandObjects(provider.getHashingAlgo(), tagPattern));
   }
 
-  public UnifiedJedis(ConnectionProvider provider, int maxAttempts, Duration maxTotalRetriesDuration) {
+  /**
+   * Creates a UnifiedJedis instance with the specified connection provider and retry parameters.
+   * @param provider The connection provider
+   * @param maxAttempts The maximum number of retry attempts
+   * @param maxTotalRetriesDuration The maximum total duration for retries
+   */
+  public UnifiedJedis(ConnectionProvider provider, int maxAttempts,
+      Duration maxTotalRetriesDuration) {
     this(new RetryableCommandExecutor(provider, maxAttempts, maxTotalRetriesDuration), provider);
   }
 
   /**
-   * Constructor which supports multiple cluster/database endpoints each with their own isolated connection pool.
-   * <p>
-   * With this Constructor users can seamlessly failover to Disaster Recovery (DR), Backup, and Active-Active cluster(s)
-   * by using simple configuration which is passed through from Resilience4j - https://resilience4j.readme.io/docs
+   * Constructor which supports multiple cluster/database endpoints each with their own isolated
+   * connection pool.
    * <p>
+   * With this Constructor users can seamlessly failover to Disaster Recovery (DR), Backup, and
+   * Active-Active cluster(s) by using simple configuration which is passed through from
+   * Resilience4j - https://resilience4j.readme.io/docs
+   * @param provider The multi-cluster pooled connection provider
    */
   @Experimental
   public UnifiedJedis(MultiClusterPooledConnectionProvider provider) {
@@ -250,13 +415,25 @@ public UnifiedJedis(CommandExecutor executor) {
     this(executor, (ConnectionProvider) null);
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified command executor and connection provider.
+   * @param executor The command executor
+   * @param provider The connection provider
+   */
   private UnifiedJedis(CommandExecutor executor, ConnectionProvider provider) {
     this(executor, provider, new CommandObjects());
   }
 
-  // Uses a fetched connection to process protocol. Should be avoided if possible.
+  /**
+   * Creates a UnifiedJedis instance with the specified command executor, connection provider, and
+   * command objects. Uses a fetched connection to process protocol. Should be avoided if possible.
+   * @param executor The command executor
+   * @param provider The connection provider
+   * @param commandObjects The command objects
+   */
   @VisibleForTesting
-  public UnifiedJedis(CommandExecutor executor, ConnectionProvider provider, CommandObjects commandObjects) {
+  public UnifiedJedis(CommandExecutor executor, ConnectionProvider provider,
+      CommandObjects commandObjects) {
     this(executor, provider, commandObjects, null, null);
     if (this.provider != null) {
       try (Connection conn = this.provider.getConnection()) {
@@ -271,15 +448,33 @@ public UnifiedJedis(CommandExecutor executor, ConnectionProvider provider, Comma
     }
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified command executor, connection provider,
+   * command objects, and protocol.
+   * @param executor The command executor
+   * @param provider The connection provider
+   * @param commandObjects The command objects
+   * @param protocol The Redis protocol version
+   */
   @Experimental
-  private UnifiedJedis(CommandExecutor executor, ConnectionProvider provider, CommandObjects commandObjects,
-      RedisProtocol protocol) {
+  private UnifiedJedis(CommandExecutor executor, ConnectionProvider provider,
+      CommandObjects commandObjects, RedisProtocol protocol) {
     this(executor, provider, commandObjects, protocol, (Cache) null);
   }
 
+  /**
+   * Creates a UnifiedJedis instance with the specified command executor, connection provider,
+   * command objects, protocol, and cache. This constructor enables client-side caching.
+   * @param executor The command executor
+   * @param provider The connection provider
+   * @param commandObjects The command objects
+   * @param protocol The Redis protocol version
+   * @param cache The cache
+   * @throws IllegalArgumentException if cache is provided but protocol is not RESP3
+   */
   @Experimental
-  private UnifiedJedis(CommandExecutor executor, ConnectionProvider provider, CommandObjects commandObjects,
-      RedisProtocol protocol, Cache cache) {
+  private UnifiedJedis(CommandExecutor executor, ConnectionProvider provider,
+      CommandObjects commandObjects, RedisProtocol protocol, Cache cache) {
 
     if (cache != null && protocol != RedisProtocol.RESP3) {
       throw new IllegalArgumentException("Client-side caching is only supported with RESP3.");
@@ -322,8 +517,8 @@ private <T> T checkAndBroadcastCommand(CommandObject<T> commandObject) {
     } else if (commandObject.getArguments().getCommand() instanceof SearchProtocol.SearchCommand
         && broadcastAndRoundRobinConfig
             .getRediSearchModeInCluster() == JedisBroadcastAndRoundRobinConfig.RediSearchMode.LIGHT) {
-      broadcast = false;
-    }
+              broadcast = false;
+            }
 
     return broadcast ? broadcastCommand(commandObject) : executeCommand(commandObject);
   }
@@ -1413,7 +1608,8 @@ public String lmove(String srcKey, String dstKey, ListDirection from, ListDirect
   }
 
   @Override
-  public String blmove(String srcKey, String dstKey, ListDirection from, ListDirection to, double timeout) {
+  public String blmove(String srcKey, String dstKey, ListDirection from, ListDirection to,
+      double timeout) {
     return executeCommand(commandObjects.blmove(srcKey, dstKey, from, to, timeout));
   }
 
@@ -1423,7 +1619,8 @@ public byte[] lmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirect
   }
 
   @Override
-  public byte[] blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to, double timeout) {
+  public byte[] blmove(byte[] srcKey, byte[] dstKey, ListDirection from, ListDirection to,
+      double timeout) {
     return executeCommand(commandObjects.blmove(srcKey, dstKey, from, to, timeout));
   }
 
@@ -1438,12 +1635,14 @@ public KeyValue<String, List<String>> lmpop(ListDirection direction, int count,
   }
 
   @Override
-  public KeyValue<String, List<String>> blmpop(double timeout, ListDirection direction, String... keys) {
+  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) {
+  public KeyValue<String, List<String>> blmpop(double timeout, ListDirection direction, int count,
+      String... keys) {
     return executeCommand(commandObjects.blmpop(timeout, direction, count, keys));
   }
 
@@ -1458,12 +1657,14 @@ public KeyValue<byte[], List<byte[]>> lmpop(ListDirection direction, int count,
   }
 
   @Override
-  public KeyValue<byte[], List<byte[]>> blmpop(double timeout, ListDirection direction, byte[]... keys) {
+  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) {
+  public KeyValue<byte[], List<byte[]>> blmpop(double timeout, ListDirection direction, int count,
+      byte[]... keys) {
     return executeCommand(commandObjects.blmpop(timeout, direction, count, keys));
   }
   // List commands
@@ -1481,19 +1682,19 @@ public long hset(String key, Map<String, String> hash) {
 
   @Override
   public long hsetex(String key, HSetExParams params, String field, String value) {
-   return executeCommand(commandObjects.hsetex(key, params, field, 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));
@@ -1531,7 +1732,7 @@ public long hset(byte[] key, Map<byte[], byte[]> hash) {
 
   @Override
   public long hsetex(byte[] key, HSetExParams params, byte[] field, byte[] value) {
-   return executeCommand(commandObjects.hsetex(key, params, field, value));
+    return executeCommand(commandObjects.hsetex(key, params, field, value));
   }
 
   @Override
@@ -1548,7 +1749,7 @@ public byte[] hget(byte[] key, byte[] field) {
   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));
@@ -1725,7 +1926,8 @@ public List<Long> hpexpire(String key, long milliseconds, String... fields) {
   }
 
   @Override
-  public List<Long> hpexpire(String key, long milliseconds, ExpiryOption condition, String... fields) {
+  public List<Long> hpexpire(String key, long milliseconds, ExpiryOption condition,
+      String... fields) {
     return executeCommand(commandObjects.hpexpire(key, milliseconds, condition, fields));
   }
 
@@ -1735,7 +1937,8 @@ public List<Long> hexpireAt(String key, long unixTimeSeconds, String... fields)
   }
 
   @Override
-  public List<Long> hexpireAt(String key, long unixTimeSeconds, ExpiryOption condition, String... fields) {
+  public List<Long> hexpireAt(String key, long unixTimeSeconds, ExpiryOption condition,
+      String... fields) {
     return executeCommand(commandObjects.hexpireAt(key, unixTimeSeconds, condition, fields));
   }
 
@@ -1745,7 +1948,8 @@ public List<Long> hpexpireAt(String key, long unixTimeMillis, String... fields)
   }
 
   @Override
-  public List<Long> hpexpireAt(String key, long unixTimeMillis, ExpiryOption condition, String... fields) {
+  public List<Long> hpexpireAt(String key, long unixTimeMillis, ExpiryOption condition,
+      String... fields) {
     return executeCommand(commandObjects.hpexpireAt(key, unixTimeMillis, condition, fields));
   }
 
@@ -1765,7 +1969,8 @@ public List<Long> hpexpire(byte[] key, long milliseconds, byte[]... fields) {
   }
 
   @Override
-  public List<Long> hpexpire(byte[] key, long milliseconds, ExpiryOption condition, byte[]... fields) {
+  public List<Long> hpexpire(byte[] key, long milliseconds, ExpiryOption condition,
+      byte[]... fields) {
     return executeCommand(commandObjects.hpexpire(key, milliseconds, condition, fields));
   }
 
@@ -1775,7 +1980,8 @@ public List<Long> hexpireAt(byte[] key, long unixTimeSeconds, byte[]... fields)
   }
 
   @Override
-  public List<Long> hexpireAt(byte[] key, long unixTimeSeconds, ExpiryOption condition, byte[]... fields) {
+  public List<Long> hexpireAt(byte[] key, long unixTimeSeconds, ExpiryOption condition,
+      byte[]... fields) {
     return executeCommand(commandObjects.hexpireAt(key, unixTimeSeconds, condition, fields));
   }
 
@@ -1785,7 +1991,8 @@ public List<Long> hpexpireAt(byte[] key, long unixTimeMillis, byte[]... fields)
   }
 
   @Override
-  public List<Long> hpexpireAt(byte[] key, long unixTimeMillis, ExpiryOption condition, byte[]... fields) {
+  public List<Long> hpexpireAt(byte[] key, long unixTimeMillis, ExpiryOption condition,
+      byte[]... fields) {
     return executeCommand(commandObjects.hpexpireAt(key, unixTimeMillis, condition, fields));
   }
 
@@ -2364,7 +2571,8 @@ public List<Tuple> zrevrangeByScoreWithScores(String key, double max, double min
   }
 
   @Override
-  public List<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count) {
+  public List<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset,
+      int count) {
     return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
   }
 
@@ -2384,17 +2592,20 @@ public List<Tuple> zrevrangeByScoreWithScores(String key, String max, String min
   }
 
   @Override
-  public List<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset, int count) {
+  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) {
+  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) {
+  public List<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, int offset,
+      int count) {
     return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
   }
 
@@ -2479,7 +2690,8 @@ public List<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min
   }
 
   @Override
-  public List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset, int count) {
+  public List<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max, int offset,
+      int count) {
     return executeCommand(commandObjects.zrangeByScoreWithScores(key, min, max, offset, count));
   }
 
@@ -2499,17 +2711,20 @@ public List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min
   }
 
   @Override
-  public List<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max, int offset, int count) {
+  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) {
+  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) {
+  public List<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset,
+      int count) {
     return executeCommand(commandObjects.zrevrangeByScoreWithScores(key, max, min, offset, count));
   }
 
@@ -2786,12 +3001,14 @@ public KeyValue<String, List<Tuple>> zmpop(SortedSetOption option, int count, St
   }
 
   @Override
-  public KeyValue<String, List<Tuple>> bzmpop(double timeout, SortedSetOption option, String... keys) {
+  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) {
+  public KeyValue<String, List<Tuple>> bzmpop(double timeout, SortedSetOption option, int count,
+      String... keys) {
     return executeCommand(commandObjects.bzmpop(timeout, option, count, keys));
   }
 
@@ -2806,12 +3023,14 @@ public KeyValue<byte[], List<Tuple>> zmpop(SortedSetOption option, int count, by
   }
 
   @Override
-  public KeyValue<byte[], List<Tuple>> bzmpop(double timeout, SortedSetOption option, byte[]... keys) {
+  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) {
+  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
@@ -2828,7 +3047,8 @@ public long geoadd(String key, Map<String, GeoCoordinate> memberCoordinateMap) {
   }
 
   @Override
-  public long geoadd(String key, GeoAddParams params, Map<String, GeoCoordinate> memberCoordinateMap) {
+  public long geoadd(String key, GeoAddParams params,
+      Map<String, GeoCoordinate> memberCoordinateMap) {
     return executeCommand(commandObjects.geoadd(key, params, memberCoordinateMap));
   }
 
@@ -2863,7 +3083,8 @@ public long geoadd(byte[] key, Map<byte[], GeoCoordinate> memberCoordinateMap) {
   }
 
   @Override
-  public long geoadd(byte[] key, GeoAddParams params, Map<byte[], GeoCoordinate> memberCoordinateMap) {
+  public long geoadd(byte[] key, GeoAddParams params,
+      Map<byte[], GeoCoordinate> memberCoordinateMap) {
     return executeCommand(commandObjects.geoadd(key, params, memberCoordinateMap));
   }
 
@@ -2888,53 +3109,67 @@ public List<GeoCoordinate> geopos(byte[] key, byte[]... members) {
   }
 
   @Override
-  public List<GeoRadiusResponse> georadius(String key, double longitude, double latitude, double radius, GeoUnit unit) {
+  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) {
+  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) {
+  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));
+  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) {
+  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) {
+  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) {
+  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));
+  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));
+  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));
+  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
@@ -2943,17 +3178,20 @@ public List<GeoRadiusResponse> geosearch(String key, String member, double radiu
   }
 
   @Override
-  public List<GeoRadiusResponse> geosearch(String key, GeoCoordinate coord, double radius, GeoUnit unit) {
+  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) {
+  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) {
+  public List<GeoRadiusResponse> geosearch(String key, GeoCoordinate coord, double width,
+      double height, GeoUnit unit) {
     return executeCommand(commandObjects.geosearch(key, coord, width, height, unit));
   }
 
@@ -2968,17 +3206,20 @@ public long geosearchStore(String dest, String src, String member, double radius
   }
 
   @Override
-  public long geosearchStore(String dest, String src, GeoCoordinate coord, double radius, GeoUnit unit) {
+  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) {
+  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) {
+  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));
   }
 
@@ -2993,53 +3234,67 @@ public long geosearchStoreStoreDist(String dest, String src, GeoSearchParam para
   }
 
   @Override
-  public List<GeoRadiusResponse> georadius(byte[] key, double longitude, double latitude, double radius, GeoUnit unit) {
+  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) {
+  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) {
+  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));
+  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) {
+  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) {
+  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) {
+  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));
+  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));
+  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));
+  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
@@ -3048,17 +3303,20 @@ public List<GeoRadiusResponse> geosearch(byte[] key, byte[] member, double radiu
   }
 
   @Override
-  public List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double radius, GeoUnit unit) {
+  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) {
+  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) {
+  public List<GeoRadiusResponse> geosearch(byte[] key, GeoCoordinate coord, double width,
+      double height, GeoUnit unit) {
     return executeCommand(commandObjects.geosearch(key, coord, width, height, unit));
   }
 
@@ -3073,17 +3331,20 @@ public long geosearchStore(byte[] dest, byte[] src, byte[] member, double radius
   }
 
   @Override
-  public long geosearchStore(byte[] dest, byte[] src, GeoCoordinate coord, double radius, GeoUnit unit) {
+  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) {
+  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) {
+  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));
   }
 
@@ -3172,7 +3433,8 @@ public List<StreamEntry> xrevrange(String key, StreamEntryID end, StreamEntryID
   }
 
   @Override
-  public List<StreamEntry> xrevrange(String key, StreamEntryID end, StreamEntryID start, int count) {
+  public List<StreamEntry> xrevrange(String key, StreamEntryID end, StreamEntryID start,
+      int count) {
     return executeCommand(commandObjects.xrevrange(key, end, start, count));
   }
 
@@ -3252,23 +3514,31 @@ public long xtrim(String key, XTrimParams 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));
+  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));
+  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));
+  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));
+  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
@@ -3302,23 +3572,29 @@ public List<StreamConsumerInfo> xinfoConsumers2(String key, String group) {
   }
 
   @Override
-  public List<Map.Entry<String, List<StreamEntry>>> xread(XReadParams xReadParams, Map<String, StreamEntryID> streams) {
+  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) {
+  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));
+  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));
+  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
@@ -3407,23 +3683,31 @@ public List<Object> xpending(byte[] key, byte[] groupName, XPendingParams 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));
+  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));
+  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));
+  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));
+  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
@@ -3457,8 +3741,10 @@ public List<Object> xread(XReadParams xReadParams, Map.Entry<byte[], byte[]>...
   }
 
   @Override
-  public List<Object> xreadGroup(byte[] groupName, byte[] consumer, XReadGroupParams xReadGroupParams, Map.Entry<byte[], byte[]>... streams) {
-    return executeCommand(commandObjects.xreadGroup(groupName, consumer, xReadGroupParams, streams));
+  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
 
@@ -3748,12 +4034,14 @@ public long waitReplicas(byte[] sampleKey, int replicas, long timeout) {
   }
 
   @Override
-  public KeyValue<Long, Long> waitAOF(String sampleKey, long numLocal, long numReplicas, long timeout) {
+  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) {
+  public KeyValue<Long, Long> waitAOF(byte[] sampleKey, long numLocal, long numReplicas,
+      long timeout) {
     return executeCommand(commandObjects.waitAOF(sampleKey, numLocal, numReplicas, timeout));
   }
 
@@ -3907,7 +4195,8 @@ public String ftCreate(String indexName, IndexOptions indexOptions, Schema schem
   }
 
   @Override
-  public String ftCreate(String indexName, FTCreateParams createParams, Iterable<SchemaField> schemaFields) {
+  public String ftCreate(String indexName, FTCreateParams createParams,
+      Iterable<SchemaField> schemaFields) {
     return checkAndBroadcastCommand(commandObjects.ftCreate(indexName, createParams, schemaFields));
   }
 
@@ -3958,15 +4247,16 @@ public SearchResult ftSearch(String indexName, String query, FTSearchParams para
 
   /**
    * {@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);
+  public FtSearchIteration ftSearchIteration(int batchSize, String indexName, String query,
+      FTSearchParams params) {
+    return new FtSearchIteration(provider, commandObjects.getProtocol(), batchSize, indexName,
+        query, params);
   }
 
   @Override
@@ -3982,7 +4272,8 @@ public SearchResult ftSearch(String indexName, Query query) {
    * @return search iteration
    */
   public FtSearchIteration ftSearchIteration(int batchSize, String indexName, Query query) {
-    return new FtSearchIteration(provider, commandObjects.getProtocol(), batchSize, indexName, query);
+    return new FtSearchIteration(provider, commandObjects.getProtocol(), batchSize, indexName,
+        query);
   }
 
   @Override
@@ -4041,7 +4332,8 @@ public Map.Entry<SearchResult, ProfilingInfo> ftProfileSearch(String indexName,
   @Override
   public Map.Entry<SearchResult, ProfilingInfo> ftProfileSearch(String indexName,
       FTProfileParams profileParams, String query, FTSearchParams searchParams) {
-    return executeCommand(commandObjects.ftProfileSearch(indexName, profileParams, query, searchParams));
+    return executeCommand(
+      commandObjects.ftProfileSearch(indexName, profileParams, query, searchParams));
   }
 
   @Override
@@ -4646,7 +4938,8 @@ public List<TSElement> tsRevRange(String key, TSRangeParams rangeParams) {
   }
 
   @Override
-  public Map<String, TSMRangeElements> tsMRange(long fromTimestamp, long toTimestamp, String... filters) {
+  public Map<String, TSMRangeElements> tsMRange(long fromTimestamp, long toTimestamp,
+      String... filters) {
     return executeCommand(commandObjects.tsMRange(fromTimestamp, toTimestamp, filters));
   }
 
@@ -4656,7 +4949,8 @@ public Map<String, TSMRangeElements> tsMRange(TSMRangeParams multiRangeParams) {
   }
 
   @Override
-  public Map<String, TSMRangeElements> tsMRevRange(long fromTimestamp, long toTimestamp, String... filters) {
+  public Map<String, TSMRangeElements> tsMRevRange(long fromTimestamp, long toTimestamp,
+      String... filters) {
     return executeCommand(commandObjects.tsMRevRange(fromTimestamp, toTimestamp, filters));
   }
 
@@ -4681,14 +4975,17 @@ public Map<String, TSMGetElement> tsMGet(TSMGetParams multiGetParams, String...
   }
 
   @Override
-  public String tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType, long timeBucket) {
-    return executeCommand(commandObjects.tsCreateRule(sourceKey, destKey, aggregationType, timeBucket));
+  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));
+  public String tsCreateRule(String sourceKey, String destKey, AggregationType aggregationType,
+      long bucketDuration, long alignTimestamp) {
+    return executeCommand(commandObjects.tsCreateRule(sourceKey, destKey, aggregationType,
+      bucketDuration, alignTimestamp));
   }
 
   @Override
@@ -4719,7 +5016,8 @@ public String bfReserve(String key, double errorRate, long capacity) {
   }
 
   @Override
-  public String bfReserve(String key, double errorRate, long capacity, BFReserveParams reserveParams) {
+  public String bfReserve(String key, double errorRate, long capacity,
+      BFReserveParams reserveParams) {
     return executeCommand(commandObjects.bfReserve(key, errorRate, capacity, reserveParams));
   }
 
@@ -4944,7 +5242,8 @@ public String tdigestMerge(String destinationKey, String... sourceKeys) {
   }
 
   @Override
-  public String tdigestMerge(TDigestMergeParams mergeParams, String destinationKey, String... sourceKeys) {
+  public String tdigestMerge(TDigestMergeParams mergeParams, String destinationKey,
+      String... sourceKeys) {
     return executeCommand(commandObjects.tdigestMerge(mergeParams, destinationKey, sourceKeys));
   }
 
@@ -5009,9 +5308,11 @@ public List<Double> tdigestByRevRank(String key, long... ranks) {
    */
   public PipelineBase pipelined() {
     if (provider == null) {
-      throw new IllegalStateException("It is not allowed to create Pipeline from this " + getClass());
+      throw new IllegalStateException(
+          "It is not allowed to create Pipeline from this " + getClass());
     } else if (provider instanceof MultiClusterPooledConnectionProvider) {
-      return new MultiClusterPipeline((MultiClusterPooledConnectionProvider) provider, commandObjects);
+      return new MultiClusterPipeline((MultiClusterPooledConnectionProvider) provider,
+          commandObjects);
     } else {
       return new Pipeline(provider.getConnection(), true, commandObjects);
     }
@@ -5030,9 +5331,11 @@ public AbstractTransaction multi() {
    */
   public AbstractTransaction transaction(boolean doMulti) {
     if (provider == null) {
-      throw new IllegalStateException("It is not allowed to create Transaction from this " + getClass());
+      throw new IllegalStateException(
+          "It is not allowed to create Transaction from this " + getClass());
     } else if (provider instanceof MultiClusterPooledConnectionProvider) {
-      return new MultiClusterTransaction((MultiClusterPooledConnectionProvider) provider, doMulti, commandObjects);
+      return new MultiClusterTransaction((MultiClusterPooledConnectionProvider) provider, doMulti,
+          commandObjects);
     } else {
       return new Transaction(provider.getConnection(), doMulti, true, commandObjects);
     }
@@ -5047,7 +5350,8 @@ public Object sendCommand(ProtocolCommand cmd, byte[]... args) {
   }
 
   public Object sendBlockingCommand(ProtocolCommand cmd, byte[]... args) {
-    return executeCommand(commandObjects.commandArguments(cmd).addObjects((Object[]) args).blocking());
+    return executeCommand(
+      commandObjects.commandArguments(cmd).addObjects((Object[]) args).blocking());
   }
 
   public Object sendCommand(ProtocolCommand cmd, String... args) {
@@ -5055,25 +5359,28 @@ public Object sendCommand(ProtocolCommand cmd, String... args) {
   }
 
   public Object sendBlockingCommand(ProtocolCommand cmd, String... args) {
-    return executeCommand(commandObjects.commandArguments(cmd).addObjects((Object[]) args).blocking());
+    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));
+    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));
+    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));
+    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));
+    return executeCommand(commandObjects.commandArguments(cmd).addObjects((Object[]) args)
+        .blocking().processKey(sampleKey));
   }
 
   public Object executeCommand(CommandArguments args) {