From b660d14278cdce799f242e1015412c531e6eeec4 Mon Sep 17 00:00:00 2001
From: Shoham Elias <shohame@amazon.com>
Date: Sun, 7 Jul 2024 09:59:28 +0000
Subject: [PATCH] Java: Rename RedisClient, RedisClusterClient to GlideClient,
 GlideClusterClient

---
 java/DEVELOPER.md                             |   4 +-
 .../clients/glide/GlideAsyncClient.java       |  28 ++---
 .../clients/lettuce/LettuceAsyncClient.java   |  16 +--
 .../src/main/java/glide/api/BaseClient.java   |   2 +-
 .../{RedisClient.java => GlideClient.java}    |  21 ++--
 ...terClient.java => GlideClusterClient.java} |  23 ++--
 .../glide/api/models/ClusterTransaction.java  |   6 +-
 .../java/glide/api/models/Transaction.java    |   6 +-
 .../glide/api/models/commands/FlushMode.java  |  18 +--
 .../ClusterSubscriptionConfiguration.java     |  10 +-
 ...ion.java => GlideClientConfiguration.java} |  10 +-
 ...a => GlideClusterClientConfiguration.java} |  10 +-
 .../StandaloneSubscriptionConfiguration.java  |  10 +-
 .../glide/managers/ConnectionManager.java     |  22 ++--
 .../java/glide/ExceptionHandlingTests.java    |   6 +-
 ...teTest.java => GlideClientCreateTest.java} |  34 +++---
 ...isClientTest.java => GlideClientTest.java} |   6 +-
 ...tTest.java => GlideClusterClientTest.java} |  10 +-
 .../ConnectionWithGlideMockTests.java         |   4 +-
 .../glide/managers/ConnectionManagerTest.java |  32 +++---
 .../main/java/glide/examples/ExamplesApp.java |  10 +-
 .../src/test/java/glide/ConnectionTests.java  |  12 +-
 .../glide/CustomThreadPoolResourceTest.java   |   8 +-
 .../test/java/glide/ErrorHandlingTests.java   |  16 +--
 .../src/test/java/glide/PubSubTests.java      |  52 ++++-----
 .../test/java/glide/SharedClientTests.java    |  12 +-
 .../test/java/glide/SharedCommandTests.java   | 106 +++++++++---------
 .../src/test/java/glide/TestUtilities.java    |  24 ++--
 .../glide/cluster/ClusterClientTests.java     |  32 +++---
 .../cluster/ClusterTransactionTests.java      |  10 +-
 .../test/java/glide/cluster/CommandTests.java |  18 +--
 .../java/glide/standalone/CommandTests.java   |  14 +--
 .../standalone/StandaloneClientTests.java     |  26 ++---
 .../glide/standalone/TransactionTests.java    |   6 +-
 34 files changed, 310 insertions(+), 314 deletions(-)
 rename java/client/src/main/java/glide/api/{RedisClient.java => GlideClient.java} (97%)
 rename java/client/src/main/java/glide/api/{RedisClusterClient.java => GlideClusterClient.java} (98%)
 rename java/client/src/main/java/glide/api/models/configuration/{RedisClientConfiguration.java => GlideClientConfiguration.java} (84%)
 rename java/client/src/main/java/glide/api/models/configuration/{RedisClusterClientConfiguration.java => GlideClusterClientConfiguration.java} (80%)
 rename java/client/src/test/java/glide/api/{RedisClientCreateTest.java => GlideClientCreateTest.java} (83%)
 rename java/client/src/test/java/glide/api/{RedisClientTest.java => GlideClientTest.java} (99%)
 rename java/client/src/test/java/glide/api/{RedisClusterClientTest.java => GlideClusterClientTest.java} (99%)

diff --git a/java/DEVELOPER.md b/java/DEVELOPER.md
index f7e78ef8e5..23ad073c77 100644
--- a/java/DEVELOPER.md
+++ b/java/DEVELOPER.md
@@ -223,8 +223,8 @@ The return types of these methods are in the form of a `CompletableFuture`, whic
 When implementing a command, include both a unit test and an integration test.
 
 Implement unit tests in the following files:
-- [RedisClientTest.java](https://github.com/aws/glide-for-redis/blob/main/java/client/src/test/java/glide/api/RedisClientTest.java) for standalone commands.
-- [RedisClusterClientTest.java](https://github.com/aws/glide-for-redis/blob/main/java/client/src/test/java/glide/api/RedisClusterClientTest.java) for cluster commands.
+- [GlideClientTest.java](https://github.com/aws/glide-for-redis/blob/main/java/client/src/test/java/glide/api/GlideClientTest.java) for standalone commands.
+- [GlideClusterClientTest.java](https://github.com/aws/glide-for-redis/blob/main/java/client/src/test/java/glide/api/GlideClusterClientTest.java) for cluster commands.
 These files are found in the java/client/src/test/java/glide/api path.
 
 Implement integration tests in the following files:
diff --git a/java/benchmarks/src/main/java/glide/benchmarks/clients/glide/GlideAsyncClient.java b/java/benchmarks/src/main/java/glide/benchmarks/clients/glide/GlideAsyncClient.java
index 68cd5882d8..2b252376b4 100644
--- a/java/benchmarks/src/main/java/glide/benchmarks/clients/glide/GlideAsyncClient.java
+++ b/java/benchmarks/src/main/java/glide/benchmarks/clients/glide/GlideAsyncClient.java
@@ -4,11 +4,11 @@
 import static java.util.concurrent.TimeUnit.SECONDS;
 
 import glide.api.BaseClient;
-import glide.api.RedisClient;
-import glide.api.RedisClusterClient;
+import glide.api.GlideClient;
+import glide.api.GlideClusterClient;
+import glide.api.models.configuration.GlideClientConfiguration;
+import glide.api.models.configuration.GlideClusterClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
-import glide.api.models.configuration.RedisClientConfiguration;
-import glide.api.models.configuration.RedisClusterClientConfiguration;
 import glide.benchmarks.clients.AsyncClient;
 import glide.benchmarks.utils.ConnectionSettings;
 import java.util.concurrent.CompletableFuture;
@@ -17,14 +17,14 @@
 
 /** A Glide client with async capabilities */
 public class GlideAsyncClient implements AsyncClient<String> {
-    private BaseClient redisClient;
+    private BaseClient glideClient;
 
     @Override
     public void connectToRedis(ConnectionSettings connectionSettings) {
 
         if (connectionSettings.clusterMode) {
-            RedisClusterClientConfiguration config =
-                    RedisClusterClientConfiguration.builder()
+            GlideClusterClientConfiguration config =
+                    GlideClusterClientConfiguration.builder()
                             .address(
                                     NodeAddress.builder()
                                             .host(connectionSettings.host)
@@ -33,14 +33,14 @@ public void connectToRedis(ConnectionSettings connectionSettings) {
                             .useTLS(connectionSettings.useSsl)
                             .build();
             try {
-                redisClient = RedisClusterClient.createClient(config).get(10, SECONDS);
+                glideClient = GlideClusterClient.createClient(config).get(10, SECONDS);
             } catch (InterruptedException | ExecutionException | TimeoutException e) {
                 throw new RuntimeException(e);
             }
 
         } else {
-            RedisClientConfiguration config =
-                    RedisClientConfiguration.builder()
+            GlideClientConfiguration config =
+                    GlideClientConfiguration.builder()
                             .address(
                                     NodeAddress.builder()
                                             .host(connectionSettings.host)
@@ -50,7 +50,7 @@ public void connectToRedis(ConnectionSettings connectionSettings) {
                             .build();
 
             try {
-                redisClient = RedisClient.createClient(config).get(10, SECONDS);
+                glideClient = GlideClient.createClient(config).get(10, SECONDS);
             } catch (InterruptedException | ExecutionException | TimeoutException e) {
                 throw new RuntimeException(e);
             }
@@ -59,18 +59,18 @@ public void connectToRedis(ConnectionSettings connectionSettings) {
 
     @Override
     public CompletableFuture<String> asyncSet(String key, String value) {
-        return redisClient.set(key, value);
+        return glideClient.set(key, value);
     }
 
     @Override
     public CompletableFuture<String> asyncGet(String key) {
-        return redisClient.get(key);
+        return glideClient.get(key);
     }
 
     @Override
     public void closeConnection() {
         try {
-            redisClient.close();
+            glideClient.close();
         } catch (ExecutionException e) {
             throw new RuntimeException(e);
         }
diff --git a/java/benchmarks/src/main/java/glide/benchmarks/clients/lettuce/LettuceAsyncClient.java b/java/benchmarks/src/main/java/glide/benchmarks/clients/lettuce/LettuceAsyncClient.java
index d141582939..6231d9be71 100644
--- a/java/benchmarks/src/main/java/glide/benchmarks/clients/lettuce/LettuceAsyncClient.java
+++ b/java/benchmarks/src/main/java/glide/benchmarks/clients/lettuce/LettuceAsyncClient.java
@@ -3,14 +3,14 @@
 
 import glide.benchmarks.clients.AsyncClient;
 import glide.benchmarks.utils.ConnectionSettings;
-import io.lettuce.core.AbstractRedisClient;
-import io.lettuce.core.RedisClient;
+import io.lettuce.core.AbstractGlideClient;
+import io.lettuce.core.GlideClient;
 import io.lettuce.core.RedisFuture;
 import io.lettuce.core.RedisURI;
 import io.lettuce.core.api.StatefulConnection;
 import io.lettuce.core.api.StatefulRedisConnection;
 import io.lettuce.core.api.async.RedisStringAsyncCommands;
-import io.lettuce.core.cluster.RedisClusterClient;
+import io.lettuce.core.cluster.GlideClusterClient;
 import io.lettuce.core.cluster.api.StatefulRedisClusterConnection;
 import java.time.Duration;
 
@@ -18,7 +18,7 @@
 public class LettuceAsyncClient implements AsyncClient<String> {
     static final int ASYNC_OPERATION_TIMEOUT_SEC = 1;
 
-    private AbstractRedisClient client;
+    private AbstractGlideClient client;
     private RedisStringAsyncCommands<String, String> asyncCommands;
     private StatefulConnection<String, String> connection;
 
@@ -31,12 +31,12 @@ public void connectToRedis(ConnectionSettings connectionSettings) {
                         .withSsl(connectionSettings.useSsl)
                         .build();
         if (!connectionSettings.clusterMode) {
-            client = RedisClient.create(uri);
-            connection = ((RedisClient) client).connect();
+            client = GlideClient.create(uri);
+            connection = ((GlideClient) client).connect();
             asyncCommands = ((StatefulRedisConnection<String, String>) connection).async();
         } else {
-            client = RedisClusterClient.create(uri);
-            connection = ((RedisClusterClient) client).connect();
+            client = GlideClusterClient.create(uri);
+            connection = ((GlideClusterClient) client).connect();
             asyncCommands = ((StatefulRedisClusterConnection<String, String>) connection).async();
         }
         connection.setTimeout(Duration.ofSeconds(ASYNC_OPERATION_TIMEOUT_SEC));
diff --git a/java/client/src/main/java/glide/api/BaseClient.java b/java/client/src/main/java/glide/api/BaseClient.java
index f2b56f5c02..7d01001ce3 100644
--- a/java/client/src/main/java/glide/api/BaseClient.java
+++ b/java/client/src/main/java/glide/api/BaseClient.java
@@ -341,7 +341,7 @@ protected static class ClientBuilder {
      * @param config Redis client Configuration.
      * @param constructor Redis client constructor reference.
      * @param <T> Client type.
-     * @return a Future to connect and return a RedisClient.
+     * @return a Future to connect and return a client.
      */
     protected static <T extends BaseClient> CompletableFuture<T> createClient(
             @NonNull BaseClientConfiguration config, Function<ClientBuilder, T> constructor) {
diff --git a/java/client/src/main/java/glide/api/RedisClient.java b/java/client/src/main/java/glide/api/GlideClient.java
similarity index 97%
rename from java/client/src/main/java/glide/api/RedisClient.java
rename to java/client/src/main/java/glide/api/GlideClient.java
index 2460f1ee24..f0eb988199 100644
--- a/java/client/src/main/java/glide/api/RedisClient.java
+++ b/java/client/src/main/java/glide/api/GlideClient.java
@@ -55,7 +55,7 @@
 import glide.api.models.commands.SortOptionsBinary;
 import glide.api.models.commands.function.FunctionRestorePolicy;
 import glide.api.models.commands.scan.ScanOptions;
-import glide.api.models.configuration.RedisClientConfiguration;
+import glide.api.models.configuration.GlideClientConfiguration;
 import glide.utils.ArgsBuilder;
 import java.util.Arrays;
 import java.util.Map;
@@ -64,10 +64,9 @@
 import org.apache.commons.lang3.ArrayUtils;
 
 /**
- * Async (non-blocking) client for Redis in Standalone mode. Use {@link #createClient} to request a
- * client to Redis.
+ * Async (non-blocking) client for Standalone mode. Use {@link #createClient} to request a client.
  */
-public class RedisClient extends BaseClient
+public class GlideClient extends BaseClient
         implements GenericCommands,
                 ServerManagementCommands,
                 ConnectionManagementCommands,
@@ -77,19 +76,19 @@ public class RedisClient extends BaseClient
     /**
      * A constructor. Use {@link #createClient} to get a client. Made protected to simplify testing.
      */
-    protected RedisClient(ClientBuilder builder) {
+    protected GlideClient(ClientBuilder builder) {
         super(builder);
     }
 
     /**
-     * Async request for an async (non-blocking) Redis client in Standalone mode.
+     * Async request for an async (non-blocking) client in Standalone mode.
      *
-     * @param config Redis client Configuration.
-     * @return A Future to connect and return a RedisClient.
+     * @param config Glide client Configuration.
+     * @return A Future to connect and return a GlideClient.
      */
-    public static CompletableFuture<RedisClient> createClient(
-            @NonNull RedisClientConfiguration config) {
-        return createClient(config, RedisClient::new);
+    public static CompletableFuture<GlideClient> createClient(
+            @NonNull GlideClientConfiguration config) {
+        return createClient(config, GlideClient::new);
     }
 
     @Override
diff --git a/java/client/src/main/java/glide/api/RedisClusterClient.java b/java/client/src/main/java/glide/api/GlideClusterClient.java
similarity index 98%
rename from java/client/src/main/java/glide/api/RedisClusterClient.java
rename to java/client/src/main/java/glide/api/GlideClusterClient.java
index 2c68f06284..cd61a335d3 100644
--- a/java/client/src/main/java/glide/api/RedisClusterClient.java
+++ b/java/client/src/main/java/glide/api/GlideClusterClient.java
@@ -59,7 +59,7 @@
 import glide.api.models.commands.function.FunctionRestorePolicy;
 import glide.api.models.commands.scan.ClusterScanCursor;
 import glide.api.models.commands.scan.ScanOptions;
-import glide.api.models.configuration.RedisClusterClientConfiguration;
+import glide.api.models.configuration.GlideClusterClientConfiguration;
 import glide.api.models.configuration.RequestRoutingConfiguration.Route;
 import glide.api.models.configuration.RequestRoutingConfiguration.SingleNodeRoute;
 import glide.ffi.resolvers.ClusterScanCursorResolver;
@@ -74,11 +74,8 @@
 import org.apache.commons.lang3.ArrayUtils;
 import response.ResponseOuterClass.Response;
 
-/**
- * Async (non-blocking) client for Redis in Cluster mode. Use {@link #createClient} to request a
- * client to Redis.
- */
-public class RedisClusterClient extends BaseClient
+/** Async (non-blocking) client for Cluster mode. Use {@link #createClient} to request a client. */
+public class GlideClusterClient extends BaseClient
         implements ConnectionManagementClusterCommands,
                 GenericClusterCommands,
                 ServerManagementClusterCommands,
@@ -87,19 +84,19 @@ public class RedisClusterClient extends BaseClient
                 PubSubClusterCommands {
 
     /** A private constructor. Use {@link #createClient} to get a client. */
-    RedisClusterClient(ClientBuilder builder) {
+    GlideClusterClient(ClientBuilder builder) {
         super(builder);
     }
 
     /**
-     * Async request for an async (non-blocking) Redis client in Cluster mode.
+     * Async request for an async (non-blocking) client in Cluster mode.
      *
-     * @param config Redis cluster client Configuration.
-     * @return A Future to connect and return a RedisClusterClient.
+     * @param config Glide cluster client Configuration.
+     * @return A Future to connect and return a GlideClusterClient.
      */
-    public static CompletableFuture<RedisClusterClient> createClient(
-            @NonNull RedisClusterClientConfiguration config) {
-        return createClient(config, RedisClusterClient::new);
+    public static CompletableFuture<GlideClusterClient> createClient(
+            @NonNull GlideClusterClientConfiguration config) {
+        return createClient(config, GlideClusterClient::new);
     }
 
     @Override
diff --git a/java/client/src/main/java/glide/api/models/ClusterTransaction.java b/java/client/src/main/java/glide/api/models/ClusterTransaction.java
index 4390626cec..9aba9bf58b 100644
--- a/java/client/src/main/java/glide/api/models/ClusterTransaction.java
+++ b/java/client/src/main/java/glide/api/models/ClusterTransaction.java
@@ -6,16 +6,16 @@
 import static command_request.CommandRequestOuterClass.RequestType.SortReadOnly;
 import static glide.api.models.commands.SortBaseOptions.STORE_COMMAND_STRING;
 
-import glide.api.RedisClusterClient;
+import glide.api.GlideClusterClient;
 import glide.api.models.commands.SortClusterOptions;
 import lombok.NonNull;
 
 /**
- * Transaction implementation for cluster {@link RedisClusterClient}. Transactions allow the
+ * Transaction implementation for cluster {@link GlideClusterClient}. Transactions allow the
  * execution of a group of commands in a single step.
  *
  * <p>Transaction Response: An <code>array</code> of command responses is returned by the client
- * {@link RedisClusterClient#exec} command, in the order they were given. Each element in the array
+ * {@link GlideClusterClient#exec} command, in the order they were given. Each element in the array
  * represents a command given to the {@link ClusterTransaction}. The response for each command
  * depends on the executed Redis command. Specific response types are documented alongside each
  * method.
diff --git a/java/client/src/main/java/glide/api/models/Transaction.java b/java/client/src/main/java/glide/api/models/Transaction.java
index ef2334f6c4..34c7fafe32 100644
--- a/java/client/src/main/java/glide/api/models/Transaction.java
+++ b/java/client/src/main/java/glide/api/models/Transaction.java
@@ -11,17 +11,17 @@
 import static glide.api.commands.GenericCommands.DB_REDIS_API;
 import static glide.api.models.commands.SortBaseOptions.STORE_COMMAND_STRING;
 
-import glide.api.RedisClient;
+import glide.api.GlideClient;
 import glide.api.models.commands.SortOptions;
 import glide.api.models.commands.scan.ScanOptions;
 import lombok.NonNull;
 
 /**
- * Transaction implementation for standalone {@link RedisClient}. Transactions allow the execution
+ * Transaction implementation for standalone {@link GlideClient}. Transactions allow the execution
  * of a group of commands in a single step.
  *
  * <p>Transaction Response: An <code>array</code> of command responses is returned by the client
- * {@link RedisClient#exec} API, in the order they were given. Each element in the array represents
+ * {@link GlideClient#exec} API, in the order they were given. Each element in the array represents
  * a command given to the {@link Transaction}. The response for each command depends on the executed
  * Valkey command. Specific response types are documented alongside each method.
  *
diff --git a/java/client/src/main/java/glide/api/models/commands/FlushMode.java b/java/client/src/main/java/glide/api/models/commands/FlushMode.java
index 9ba5c2938c..1643a97271 100644
--- a/java/client/src/main/java/glide/api/models/commands/FlushMode.java
+++ b/java/client/src/main/java/glide/api/models/commands/FlushMode.java
@@ -1,8 +1,8 @@
 /** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
 package glide.api.models.commands;
 
-import glide.api.RedisClient;
-import glide.api.RedisClusterClient;
+import glide.api.GlideClient;
+import glide.api.GlideClusterClient;
 import glide.api.models.configuration.RequestRoutingConfiguration.Route;
 import glide.api.models.configuration.RequestRoutingConfiguration.SingleNodeRoute;
 
@@ -11,15 +11,15 @@
  * Defines flushing mode for:
  *
  * <ul>
- *   <li><code>FLUSHALL</code> command implemented by {@link RedisClient#flushall(FlushMode)},
- *       {@link RedisClusterClient#flushall(FlushMode)}, and {@link
- *       RedisClusterClient#flushall(FlushMode, SingleNodeRoute)}.
- *   <li><code>FLUSHDB</code> command implemented by {@link RedisClient#flushdb(FlushMode)}, {@link
- *       RedisClusterClient#flushdb(FlushMode)}, and {@link RedisClusterClient#flushdb(FlushMode,
+ *   <li><code>FLUSHALL</code> command implemented by {@link GlideClient#flushall(FlushMode)},
+ *       {@link GlideClusterClient#flushall(FlushMode)}, and {@link
+ *       GlideClusterClient#flushall(FlushMode, SingleNodeRoute)}.
+ *   <li><code>FLUSHDB</code> command implemented by {@link GlideClient#flushdb(FlushMode)}, {@link
+ *       GlideClusterClient#flushdb(FlushMode)}, and {@link GlideClusterClient#flushdb(FlushMode,
  *       SingleNodeRoute)}.
  *   <li><code>FUNCTION FLUSH</code> command implemented by {@link
- *       RedisClient#functionFlush(FlushMode)}, {@link RedisClusterClient#functionFlush(FlushMode)},
- *       and {@link RedisClusterClient#functionFlush(FlushMode, Route)}.
+ *       GlideClient#functionFlush(FlushMode)}, {@link GlideClusterClient#functionFlush(FlushMode)},
+ *       and {@link GlideClusterClient#functionFlush(FlushMode, Route)}.
  * </ul>
  *
  * @see <a href="https://valkey.io/commands/flushall/">flushall</a>, <a
diff --git a/java/client/src/main/java/glide/api/models/configuration/ClusterSubscriptionConfiguration.java b/java/client/src/main/java/glide/api/models/configuration/ClusterSubscriptionConfiguration.java
index 31a169b8c6..2843317dc5 100644
--- a/java/client/src/main/java/glide/api/models/configuration/ClusterSubscriptionConfiguration.java
+++ b/java/client/src/main/java/glide/api/models/configuration/ClusterSubscriptionConfiguration.java
@@ -1,7 +1,7 @@
 /** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
 package glide.api.models.configuration;
 
-import glide.api.RedisClusterClient;
+import glide.api.GlideClusterClient;
 import glide.api.models.GlideString;
 import java.util.HashMap;
 import java.util.Map;
@@ -10,7 +10,7 @@
 import lombok.Getter;
 
 /**
- * Subscription configuration for {@link RedisClusterClient}.
+ * Subscription configuration for {@link GlideClusterClient}.
  *
  * @example
  *     <pre>{@code
@@ -22,9 +22,9 @@
  *         .subscription(SHARDED, "data")
  *         .callback(callback)
  *         .build();
- * // Now it could be supplied to `RedisClusterClientConfiguration`:
- * RedisClusterClientConfiguration clientConfiguration =
- *     RedisClusterClientConfiguration.builder()
+ * // Now it could be supplied to `GlideClusterClientConfiguration`:
+ * GlideClusterClientConfiguration clientConfiguration =
+ *     GlideClusterClientConfiguration.builder()
  *         .address(NodeAddress.builder().port(6379).build())
  *         .subscriptionConfiguration(subscriptionConfiguration)
  *         .build();
diff --git a/java/client/src/main/java/glide/api/models/configuration/RedisClientConfiguration.java b/java/client/src/main/java/glide/api/models/configuration/GlideClientConfiguration.java
similarity index 84%
rename from java/client/src/main/java/glide/api/models/configuration/RedisClientConfiguration.java
rename to java/client/src/main/java/glide/api/models/configuration/GlideClientConfiguration.java
index 2714c62216..5c0f04c945 100644
--- a/java/client/src/main/java/glide/api/models/configuration/RedisClientConfiguration.java
+++ b/java/client/src/main/java/glide/api/models/configuration/GlideClientConfiguration.java
@@ -1,17 +1,17 @@
 /** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
 package glide.api.models.configuration;
 
-import glide.api.RedisClient;
+import glide.api.GlideClient;
 import lombok.Getter;
 import lombok.experimental.SuperBuilder;
 
 /**
- * Represents the configuration settings for a Standalone {@link RedisClient}.
+ * Represents the configuration settings for a Standalone {@link GlideClient}.
  *
  * @example
  *     <pre>{@code
- * RedisClientConfiguration redisClientConfiguration =
- *     RedisClientConfiguration.builder()
+ * GlideClientConfiguration glideClientConfiguration =
+ *     GlideClientConfiguration.builder()
  *         .address(node1address)
  *         .address(node2address)
  *         .useTLS(true)
@@ -27,7 +27,7 @@
  */
 @Getter
 @SuperBuilder
-public class RedisClientConfiguration extends BaseClientConfiguration {
+public class GlideClientConfiguration extends BaseClientConfiguration {
     /** Strategy used to determine how and when to reconnect, in case of connection failures. */
     private final BackoffStrategy reconnectStrategy;
 
diff --git a/java/client/src/main/java/glide/api/models/configuration/RedisClusterClientConfiguration.java b/java/client/src/main/java/glide/api/models/configuration/GlideClusterClientConfiguration.java
similarity index 80%
rename from java/client/src/main/java/glide/api/models/configuration/RedisClusterClientConfiguration.java
rename to java/client/src/main/java/glide/api/models/configuration/GlideClusterClientConfiguration.java
index f5a81346ac..f75f970dd8 100644
--- a/java/client/src/main/java/glide/api/models/configuration/RedisClusterClientConfiguration.java
+++ b/java/client/src/main/java/glide/api/models/configuration/GlideClusterClientConfiguration.java
@@ -1,19 +1,19 @@
 /** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
 package glide.api.models.configuration;
 
-import glide.api.RedisClusterClient;
+import glide.api.GlideClusterClient;
 import lombok.Getter;
 import lombok.experimental.SuperBuilder;
 
 /**
- * Represents the configuration settings for a Cluster Redis client {@link RedisClusterClient}.
+ * Represents the configuration settings for a Cluster Redis client {@link GlideClusterClient}.
  *
  * @apiNote Currently, the reconnection strategy in cluster mode is not configurable, and
  *     exponential backoff with fixed values is used.
  * @example
  *     <pre>{@code
- * RedisClientConfiguration redisClientConfiguration =
- *     RedisClientConfiguration.builder()
+ * GlideClientConfiguration glideClientConfiguration =
+ *     GlideClientConfiguration.builder()
  *         .address(node1address)
  *         .address(node2address)
  *         .useTLS(true)
@@ -27,7 +27,7 @@
  */
 @SuperBuilder
 @Getter
-public class RedisClusterClientConfiguration extends BaseClientConfiguration {
+public class GlideClusterClientConfiguration extends BaseClientConfiguration {
 
     /** Subscription configuration for the current client. */
     private final ClusterSubscriptionConfiguration subscriptionConfiguration;
diff --git a/java/client/src/main/java/glide/api/models/configuration/StandaloneSubscriptionConfiguration.java b/java/client/src/main/java/glide/api/models/configuration/StandaloneSubscriptionConfiguration.java
index 0f9bdd88ff..bcc2229976 100644
--- a/java/client/src/main/java/glide/api/models/configuration/StandaloneSubscriptionConfiguration.java
+++ b/java/client/src/main/java/glide/api/models/configuration/StandaloneSubscriptionConfiguration.java
@@ -1,7 +1,7 @@
 /** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
 package glide.api.models.configuration;
 
-import glide.api.RedisClient;
+import glide.api.GlideClient;
 import glide.api.models.GlideString;
 import java.util.LinkedHashMap;
 import java.util.Map;
@@ -10,7 +10,7 @@
 import lombok.Getter;
 
 /**
- * Subscription configuration for {@link RedisClient}.
+ * Subscription configuration for {@link GlideClient}.
  *
  * @example
  *     <pre>{@code
@@ -21,9 +21,9 @@
  *         .subscription(PATTERN, "news.*")
  *         .callback(callback, messageConsumer)
  *         .build();
- * // Now it could be supplied to `RedisClientConfiguration`:
- * RedisClientConfiguration clientConfiguration =
- *     RedisClientConfiguration.builder()
+ * // Now it could be supplied to `GlideClientConfiguration`:
+ * GlideClientConfiguration clientConfiguration =
+ *     GlideClientConfiguration.builder()
  *         .address(NodeAddress.builder().port(6379).build())
  *         .subscriptionConfiguration(subscriptionConfiguration)
  *         .build();
diff --git a/java/client/src/main/java/glide/managers/ConnectionManager.java b/java/client/src/main/java/glide/managers/ConnectionManager.java
index c8f866fe78..1045c3f9ef 100644
--- a/java/client/src/main/java/glide/managers/ConnectionManager.java
+++ b/java/client/src/main/java/glide/managers/ConnectionManager.java
@@ -9,10 +9,10 @@
 import connection_request.ConnectionRequestOuterClass.PubSubSubscriptions;
 import connection_request.ConnectionRequestOuterClass.TlsMode;
 import glide.api.models.configuration.BaseClientConfiguration;
+import glide.api.models.configuration.GlideClientConfiguration;
+import glide.api.models.configuration.GlideClusterClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
 import glide.api.models.configuration.ReadFrom;
-import glide.api.models.configuration.RedisClientConfiguration;
-import glide.api.models.configuration.RedisClusterClientConfiguration;
 import glide.api.models.exceptions.ClosingException;
 import glide.connectors.handlers.ChannelHandler;
 import java.util.concurrent.CompletableFuture;
@@ -28,7 +28,7 @@
 public class ConnectionManager {
 
     // TODO: consider making connection manager static, and moving the ChannelHandler to the
-    // RedisClient.
+    // GlideClient.
 
     /** UDS connection representation. */
     private final ChannelHandler channel;
@@ -69,13 +69,13 @@ private Response exceptionHandler(Throwable e) {
      * @return ConnectionRequest protobuf message
      */
     private ConnectionRequest createConnectionRequest(BaseClientConfiguration configuration) {
-        if (configuration instanceof RedisClusterClientConfiguration) {
-            return setupConnectionRequestBuilderRedisClusterClient(
-                            (RedisClusterClientConfiguration) configuration)
+        if (configuration instanceof GlideClusterClientConfiguration) {
+            return setupConnectionRequestBuilderGlideClusterClient(
+                            (GlideClusterClientConfiguration) configuration)
                     .build();
         }
 
-        return setupConnectionRequestBuilderRedisClient((RedisClientConfiguration) configuration)
+        return setupConnectionRequestBuilderGlideClient((GlideClientConfiguration) configuration)
                 .build();
     }
 
@@ -126,8 +126,8 @@ private ConnectionRequest.Builder setupConnectionRequestBuilderBaseConfiguration
      *
      * @param configuration Connection Request Configuration
      */
-    private ConnectionRequest.Builder setupConnectionRequestBuilderRedisClient(
-            RedisClientConfiguration configuration) {
+    private ConnectionRequest.Builder setupConnectionRequestBuilderGlideClient(
+            GlideClientConfiguration configuration) {
         ConnectionRequest.Builder connectionRequestBuilder =
                 setupConnectionRequestBuilderBaseConfiguration(configuration);
         connectionRequestBuilder.setClusterModeEnabled(false);
@@ -166,8 +166,8 @@ private ConnectionRequest.Builder setupConnectionRequestBuilderRedisClient(
      *
      * @param configuration
      */
-    private ConnectionRequest.Builder setupConnectionRequestBuilderRedisClusterClient(
-            RedisClusterClientConfiguration configuration) {
+    private ConnectionRequest.Builder setupConnectionRequestBuilderGlideClusterClient(
+            GlideClusterClientConfiguration configuration) {
         ConnectionRequest.Builder connectionRequestBuilder =
                 setupConnectionRequestBuilderBaseConfiguration(configuration);
         connectionRequestBuilder.setClusterModeEnabled(true);
diff --git a/java/client/src/test/java/glide/ExceptionHandlingTests.java b/java/client/src/test/java/glide/ExceptionHandlingTests.java
index ae02b30b46..f3e21317bb 100644
--- a/java/client/src/test/java/glide/ExceptionHandlingTests.java
+++ b/java/client/src/test/java/glide/ExceptionHandlingTests.java
@@ -16,7 +16,7 @@
 import command_request.CommandRequestOuterClass.CommandRequest;
 import connection_request.ConnectionRequestOuterClass;
 import glide.api.logging.Logger;
-import glide.api.models.configuration.RedisClientConfiguration;
+import glide.api.models.configuration.GlideClientConfiguration;
 import glide.api.models.exceptions.ClosingException;
 import glide.api.models.exceptions.ConnectionException;
 import glide.api.models.exceptions.ExecAbortException;
@@ -288,8 +288,8 @@ public void response_resolver_does_not_expect_errors() {
     // TODO add tests for error handling in MessageHandler
 
     /** Create a config which causes connection failure. */
-    private static RedisClientConfiguration createDummyConfig() {
-        return RedisClientConfiguration.builder().build();
+    private static GlideClientConfiguration createDummyConfig() {
+        return GlideClientConfiguration.builder().build();
     }
 
     /** Test ChannelHandler extension which allows to validate whether the channel was closed. */
diff --git a/java/client/src/test/java/glide/api/RedisClientCreateTest.java b/java/client/src/test/java/glide/api/GlideClientCreateTest.java
similarity index 83%
rename from java/client/src/test/java/glide/api/RedisClientCreateTest.java
rename to java/client/src/test/java/glide/api/GlideClientCreateTest.java
index 9b0d3cd7e4..2e2e193c9e 100644
--- a/java/client/src/test/java/glide/api/RedisClientCreateTest.java
+++ b/java/client/src/test/java/glide/api/GlideClientCreateTest.java
@@ -3,9 +3,9 @@
 
 import static glide.api.BaseClient.buildChannelHandler;
 import static glide.api.BaseClient.buildMessageHandler;
-import static glide.api.RedisClient.buildCommandManager;
-import static glide.api.RedisClient.buildConnectionManager;
-import static glide.api.RedisClient.createClient;
+import static glide.api.GlideClient.buildCommandManager;
+import static glide.api.GlideClient.buildConnectionManager;
+import static glide.api.GlideClient.createClient;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.mockito.ArgumentMatchers.any;
@@ -14,7 +14,7 @@
 import static org.mockito.Mockito.mockStatic;
 import static org.mockito.Mockito.when;
 
-import glide.api.models.configuration.RedisClientConfiguration;
+import glide.api.models.configuration.GlideClientConfiguration;
 import glide.api.models.exceptions.ClosingException;
 import glide.connectors.handlers.ChannelHandler;
 import glide.connectors.handlers.MessageHandler;
@@ -30,7 +30,7 @@
 import org.junit.jupiter.api.Test;
 import org.mockito.MockedStatic;
 
-public class RedisClientCreateTest {
+public class GlideClientCreateTest {
 
     private MockedStatic<BaseClient> mockedClient;
     private ChannelHandler channelHandler;
@@ -69,17 +69,17 @@ public void teardown() {
 
     @Test
     @SneakyThrows
-    public void createClient_with_default_config_successfully_returns_RedisClient() {
+    public void createClient_with_default_config_successfully_returns_GlideClient() {
         // setup
         CompletableFuture<Void> connectToRedisFuture = new CompletableFuture<>();
         connectToRedisFuture.complete(null);
-        RedisClientConfiguration config = RedisClientConfiguration.builder().build();
+        GlideClientConfiguration config = GlideClientConfiguration.builder().build();
 
         when(connectionManager.connectToRedis(eq(config))).thenReturn(connectToRedisFuture);
 
         // exercise
-        CompletableFuture<RedisClient> result = createClient(config);
-        RedisClient client = result.get();
+        CompletableFuture<GlideClient> result = createClient(config);
+        GlideClient client = result.get();
 
         // verify
         assertEquals(connectionManager, client.connectionManager);
@@ -88,18 +88,18 @@ public void createClient_with_default_config_successfully_returns_RedisClient()
 
     @Test
     @SneakyThrows
-    public void createClient_with_custom_config_successfully_returns_RedisClient() {
+    public void createClient_with_custom_config_successfully_returns_GlideClient() {
         // setup
         CompletableFuture<Void> connectToRedisFuture = new CompletableFuture<>();
         connectToRedisFuture.complete(null);
-        RedisClientConfiguration config =
-                RedisClientConfiguration.builder().threadPoolResource(threadPoolResource).build();
+        GlideClientConfiguration config =
+                GlideClientConfiguration.builder().threadPoolResource(threadPoolResource).build();
 
         when(connectionManager.connectToRedis(eq(config))).thenReturn(connectToRedisFuture);
 
         // exercise
-        CompletableFuture<RedisClient> result = createClient(config);
-        RedisClient client = result.get();
+        CompletableFuture<GlideClient> result = createClient(config);
+        GlideClient client = result.get();
 
         // verify
         assertEquals(connectionManager, client.connectionManager);
@@ -113,13 +113,13 @@ public void createClient_error_on_connection_throws_ExecutionException() {
         CompletableFuture<Void> connectToRedisFuture = new CompletableFuture<>();
         ClosingException exception = new ClosingException("disconnected");
         connectToRedisFuture.completeExceptionally(exception);
-        RedisClientConfiguration config =
-                RedisClientConfiguration.builder().threadPoolResource(threadPoolResource).build();
+        GlideClientConfiguration config =
+                GlideClientConfiguration.builder().threadPoolResource(threadPoolResource).build();
 
         when(connectionManager.connectToRedis(eq(config))).thenReturn(connectToRedisFuture);
 
         // exercise
-        CompletableFuture<RedisClient> result = createClient(config);
+        CompletableFuture<GlideClient> result = createClient(config);
 
         ExecutionException executionException = assertThrows(ExecutionException.class, result::get);
 
diff --git a/java/client/src/test/java/glide/api/RedisClientTest.java b/java/client/src/test/java/glide/api/GlideClientTest.java
similarity index 99%
rename from java/client/src/test/java/glide/api/RedisClientTest.java
rename to java/client/src/test/java/glide/api/GlideClientTest.java
index ebfb49f63a..ee57f31dd2 100644
--- a/java/client/src/test/java/glide/api/RedisClientTest.java
+++ b/java/client/src/test/java/glide/api/GlideClientTest.java
@@ -376,19 +376,19 @@
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-public class RedisClientTest {
+public class GlideClientTest {
 
     // bypass import conflict between Set (collection) and Set (enum variant)
     private static final RequestType pSet = RequestType.Set;
 
-    RedisClient service;
+    GlideClient service;
 
     CommandManager commandManager;
 
     @BeforeEach
     public void setUp() {
         commandManager = mock(CommandManager.class);
-        service = new RedisClient(new BaseClient.ClientBuilder(null, commandManager, null, null));
+        service = new GlideClient(new BaseClient.ClientBuilder(null, commandManager, null, null));
     }
 
     @SneakyThrows
diff --git a/java/client/src/test/java/glide/api/RedisClusterClientTest.java b/java/client/src/test/java/glide/api/GlideClusterClientTest.java
similarity index 99%
rename from java/client/src/test/java/glide/api/RedisClusterClientTest.java
rename to java/client/src/test/java/glide/api/GlideClusterClientTest.java
index ceaf691bfa..4177521adf 100644
--- a/java/client/src/test/java/glide/api/RedisClusterClientTest.java
+++ b/java/client/src/test/java/glide/api/GlideClusterClientTest.java
@@ -82,9 +82,9 @@
 import response.ResponseOuterClass.ConstantResponse;
 import response.ResponseOuterClass.Response;
 
-public class RedisClusterClientTest {
+public class GlideClusterClientTest {
 
-    RedisClusterClient service;
+    GlideClusterClient service;
 
     CommandManager commandManager;
 
@@ -94,7 +94,7 @@ public class RedisClusterClientTest {
     public void setUp() {
         commandManager = mock(CommandManager.class);
         service =
-                new RedisClusterClient(new BaseClient.ClientBuilder(null, commandManager, null, null));
+                new GlideClusterClient(new BaseClient.ClientBuilder(null, commandManager, null, null));
     }
 
     @Test
@@ -158,7 +158,7 @@ public void custom_command_returns_single_value_on_constant_response() {
         }
     }
 
-    private static class TestClient extends RedisClusterClient {
+    private static class TestClient extends GlideClusterClient {
 
         private final Object object;
 
@@ -771,7 +771,7 @@ public void configResetStat_with_route_returns_success() {
         assertEquals(OK, payload);
     }
 
-    // TODO copy/move tests from RedisClientTest which call super for coverage
+    // TODO copy/move tests from GlideClientTest which call super for coverage
     @SneakyThrows
     @Test
     public void configGet_returns_success() {
diff --git a/java/client/src/test/java/glide/connection/ConnectionWithGlideMockTests.java b/java/client/src/test/java/glide/connection/ConnectionWithGlideMockTests.java
index d0acd024cb..2c4d1e2bae 100644
--- a/java/client/src/test/java/glide/connection/ConnectionWithGlideMockTests.java
+++ b/java/client/src/test/java/glide/connection/ConnectionWithGlideMockTests.java
@@ -11,7 +11,7 @@
 import command_request.CommandRequestOuterClass.CommandRequest;
 import connection_request.ConnectionRequestOuterClass.ConnectionRequest;
 import connection_request.ConnectionRequestOuterClass.NodeAddress;
-import glide.api.RedisClient;
+import glide.api.GlideClient;
 import glide.api.logging.Logger;
 import glide.api.models.exceptions.ClosingException;
 import glide.connectors.handlers.CallbackDispatcher;
@@ -187,7 +187,7 @@ public void rethrow_error_if_UDS_channel_closed() {
         }
     }
 
-    private static class TestClient extends RedisClient {
+    private static class TestClient extends GlideClient {
 
         public TestClient(ChannelHandler channelHandler) {
             super(
diff --git a/java/client/src/test/java/glide/managers/ConnectionManagerTest.java b/java/client/src/test/java/glide/managers/ConnectionManagerTest.java
index 9b89fce2c9..c697475024 100644
--- a/java/client/src/test/java/glide/managers/ConnectionManagerTest.java
+++ b/java/client/src/test/java/glide/managers/ConnectionManagerTest.java
@@ -25,10 +25,10 @@
 import connection_request.ConnectionRequestOuterClass.PubSubSubscriptions;
 import connection_request.ConnectionRequestOuterClass.TlsMode;
 import glide.api.models.configuration.BackoffStrategy;
+import glide.api.models.configuration.GlideClientConfiguration;
+import glide.api.models.configuration.GlideClusterClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
 import glide.api.models.configuration.ReadFrom;
-import glide.api.models.configuration.RedisClientConfiguration;
-import glide.api.models.configuration.RedisClusterClientConfiguration;
 import glide.api.models.configuration.RedisCredentials;
 import glide.api.models.configuration.StandaloneSubscriptionConfiguration;
 import glide.api.models.exceptions.ClosingException;
@@ -77,7 +77,7 @@ public void setUp() {
     @Test
     public void connection_request_protobuf_generation_default_standalone_configuration() {
         // setup
-        RedisClientConfiguration redisClientConfiguration = RedisClientConfiguration.builder().build();
+        GlideClientConfiguration glideClientConfiguration = GlideClientConfiguration.builder().build();
         ConnectionRequest expectedProtobufConnectionRequest =
                 ConnectionRequest.newBuilder()
                         .setTlsMode(TlsMode.NoTls)
@@ -90,7 +90,7 @@ public void connection_request_protobuf_generation_default_standalone_configurat
 
         // execute
         when(channel.connect(eq(expectedProtobufConnectionRequest))).thenReturn(completedFuture);
-        CompletableFuture<Void> result = connectionManager.connectToRedis(redisClientConfiguration);
+        CompletableFuture<Void> result = connectionManager.connectToRedis(glideClientConfiguration);
 
         // verify
         // no exception
@@ -101,8 +101,8 @@ public void connection_request_protobuf_generation_default_standalone_configurat
     @Test
     public void connection_request_protobuf_generation_default_cluster_configuration() {
         // setup
-        RedisClusterClientConfiguration redisClusterClientConfiguration =
-                RedisClusterClientConfiguration.builder().build();
+        GlideClusterClientConfiguration glideClusterClientConfiguration =
+                GlideClusterClientConfiguration.builder().build();
         ConnectionRequest expectedProtobufConnectionRequest =
                 ConnectionRequest.newBuilder()
                         .setTlsMode(TlsMode.NoTls)
@@ -116,7 +116,7 @@ public void connection_request_protobuf_generation_default_cluster_configuration
         // execute
         when(channel.connect(eq(expectedProtobufConnectionRequest))).thenReturn(completedFuture);
         CompletableFuture<Void> result =
-                connectionManager.connectToRedis(redisClusterClientConfiguration);
+                connectionManager.connectToRedis(glideClusterClientConfiguration);
 
         // verify
         assertNull(result.get());
@@ -127,8 +127,8 @@ public void connection_request_protobuf_generation_default_cluster_configuration
     @Test
     public void connection_request_protobuf_generation_with_all_fields_set() {
         // setup
-        RedisClientConfiguration redisClientConfiguration =
-                RedisClientConfiguration.builder()
+        GlideClientConfiguration glideClientConfiguration =
+                GlideClientConfiguration.builder()
                         .address(NodeAddress.builder().host(HOST).port(PORT).build())
                         .address(NodeAddress.builder().host(DEFAULT_HOST).port(DEFAULT_PORT).build())
                         .useTLS(true)
@@ -200,7 +200,7 @@ public void connection_request_protobuf_generation_with_all_fields_set() {
 
         // execute
         when(channel.connect(eq(expectedProtobufConnectionRequest))).thenReturn(completedFuture);
-        CompletableFuture<Void> result = connectionManager.connectToRedis(redisClientConfiguration);
+        CompletableFuture<Void> result = connectionManager.connectToRedis(glideClientConfiguration);
 
         // verify
         assertNull(result.get());
@@ -211,14 +211,14 @@ public void connection_request_protobuf_generation_with_all_fields_set() {
     @Test
     public void response_validation_on_constant_response_returns_successfully() {
         // setup
-        RedisClientConfiguration redisClientConfiguration = RedisClientConfiguration.builder().build();
+        GlideClientConfiguration glideClientConfiguration = GlideClientConfiguration.builder().build();
         CompletableFuture<Response> completedFuture = new CompletableFuture<>();
         Response response = Response.newBuilder().setConstantResponse(ConstantResponse.OK).build();
         completedFuture.complete(response);
 
         // execute
         when(channel.connect(any())).thenReturn(completedFuture);
-        CompletableFuture<Void> result = connectionManager.connectToRedis(redisClientConfiguration);
+        CompletableFuture<Void> result = connectionManager.connectToRedis(glideClientConfiguration);
 
         // verify
         assertNull(result.get());
@@ -228,7 +228,7 @@ public void response_validation_on_constant_response_returns_successfully() {
     @Test
     public void connection_on_empty_response_throws_ClosingException() {
         // setup
-        RedisClientConfiguration redisClientConfiguration = RedisClientConfiguration.builder().build();
+        GlideClientConfiguration glideClientConfiguration = GlideClientConfiguration.builder().build();
         CompletableFuture<Response> completedFuture = new CompletableFuture<>();
         Response response = Response.newBuilder().build();
         completedFuture.complete(response);
@@ -238,7 +238,7 @@ public void connection_on_empty_response_throws_ClosingException() {
         ExecutionException executionException =
                 assertThrows(
                         ExecutionException.class,
-                        () -> connectionManager.connectToRedis(redisClientConfiguration).get());
+                        () -> connectionManager.connectToRedis(glideClientConfiguration).get());
 
         assertTrue(executionException.getCause() instanceof ClosingException);
         assertEquals("Unexpected empty data in response", executionException.getCause().getMessage());
@@ -248,7 +248,7 @@ public void connection_on_empty_response_throws_ClosingException() {
     @Test
     public void connection_on_resp_pointer_throws_ClosingException() {
         // setup
-        RedisClientConfiguration redisClientConfiguration = RedisClientConfiguration.builder().build();
+        GlideClientConfiguration glideClientConfiguration = GlideClientConfiguration.builder().build();
         CompletableFuture<Response> completedFuture = new CompletableFuture<>();
         Response response = Response.newBuilder().setRespPointer(42).build();
         completedFuture.complete(response);
@@ -258,7 +258,7 @@ public void connection_on_resp_pointer_throws_ClosingException() {
         ExecutionException executionException =
                 assertThrows(
                         ExecutionException.class,
-                        () -> connectionManager.connectToRedis(redisClientConfiguration).get());
+                        () -> connectionManager.connectToRedis(glideClientConfiguration).get());
 
         assertTrue(executionException.getCause() instanceof ClosingException);
         assertEquals("Unexpected data in response", executionException.getCause().getMessage());
diff --git a/java/examples/src/main/java/glide/examples/ExamplesApp.java b/java/examples/src/main/java/glide/examples/ExamplesApp.java
index 4d8b660ff8..4a686786eb 100644
--- a/java/examples/src/main/java/glide/examples/ExamplesApp.java
+++ b/java/examples/src/main/java/glide/examples/ExamplesApp.java
@@ -1,9 +1,9 @@
 /** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
 package glide.examples;
 
-import glide.api.RedisClient;
+import glide.api.GlideClient;
+import glide.api.models.configuration.GlideClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
-import glide.api.models.configuration.RedisClientConfiguration;
 import java.util.concurrent.ExecutionException;
 
 public class ExamplesApp {
@@ -18,13 +18,13 @@ private static void runGlideExamples() {
         Integer port = 6379;
         boolean useSsl = false;
 
-        RedisClientConfiguration config =
-                RedisClientConfiguration.builder()
+        GlideClientConfiguration config =
+                GlideClientConfiguration.builder()
                         .address(NodeAddress.builder().host(host).port(port).build())
                         .useTLS(useSsl)
                         .build();
 
-        try (RedisClient client = RedisClient.createClient(config).get()) {
+        try (GlideClient client = GlideClient.createClient(config).get()) {
 
             System.out.println("PING: " + client.ping().get());
             System.out.println("PING(found you): " + client.ping("found you").get());
diff --git a/java/integTest/src/test/java/glide/ConnectionTests.java b/java/integTest/src/test/java/glide/ConnectionTests.java
index 6a13daaa5c..9bca84c108 100644
--- a/java/integTest/src/test/java/glide/ConnectionTests.java
+++ b/java/integTest/src/test/java/glide/ConnectionTests.java
@@ -1,9 +1,9 @@
 /** Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0 */
 package glide;
 
-import glide.api.RedisClient;
+import glide.api.GlideClient;
+import glide.api.models.configuration.GlideClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
-import glide.api.models.configuration.RedisClientConfiguration;
 import lombok.SneakyThrows;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
@@ -15,8 +15,8 @@ public class ConnectionTests {
     @SneakyThrows
     public void basic_client() {
         var regularClient =
-                RedisClient.createClient(
-                                RedisClientConfiguration.builder()
+                GlideClient.createClient(
+                                GlideClientConfiguration.builder()
                                         .address(
                                                 NodeAddress.builder().port(TestConfiguration.STANDALONE_PORTS[0]).build())
                                         .build())
@@ -28,8 +28,8 @@ public void basic_client() {
     @SneakyThrows
     public void cluster_client() {
         var regularClient =
-                RedisClient.createClient(
-                                RedisClientConfiguration.builder()
+                GlideClient.createClient(
+                                GlideClientConfiguration.builder()
                                         .address(NodeAddress.builder().port(TestConfiguration.CLUSTER_PORTS[0]).build())
                                         .build())
                         .get();
diff --git a/java/integTest/src/test/java/glide/CustomThreadPoolResourceTest.java b/java/integTest/src/test/java/glide/CustomThreadPoolResourceTest.java
index 46667989d7..ce1817022a 100644
--- a/java/integTest/src/test/java/glide/CustomThreadPoolResourceTest.java
+++ b/java/integTest/src/test/java/glide/CustomThreadPoolResourceTest.java
@@ -3,9 +3,9 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-import glide.api.RedisClient;
+import glide.api.GlideClient;
+import glide.api.models.configuration.GlideClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
-import glide.api.models.configuration.RedisClientConfiguration;
 import glide.connectors.resources.EpollResource;
 import glide.connectors.resources.KQueuePoolResource;
 import glide.connectors.resources.Platform;
@@ -32,8 +32,8 @@ public void standalone_client_with_custom_threadPoolResource() {
         }
 
         var regularClient =
-                RedisClient.createClient(
-                                RedisClientConfiguration.builder()
+                GlideClient.createClient(
+                                GlideClientConfiguration.builder()
                                         .address(
                                                 NodeAddress.builder().port(TestConfiguration.STANDALONE_PORTS[0]).build())
                                         .threadPoolResource(customThreadPoolResource)
diff --git a/java/integTest/src/test/java/glide/ErrorHandlingTests.java b/java/integTest/src/test/java/glide/ErrorHandlingTests.java
index a8f2404c78..a3a56a16ac 100644
--- a/java/integTest/src/test/java/glide/ErrorHandlingTests.java
+++ b/java/integTest/src/test/java/glide/ErrorHandlingTests.java
@@ -5,9 +5,9 @@
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import glide.api.RedisClient;
+import glide.api.GlideClient;
+import glide.api.models.configuration.GlideClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
-import glide.api.models.configuration.RedisClientConfiguration;
 import glide.api.models.exceptions.ClosingException;
 import glide.api.models.exceptions.RequestException;
 import java.net.ServerSocket;
@@ -26,8 +26,8 @@ public void basic_client_tries_to_connect_to_wrong_address() {
                 assertThrows(
                         ExecutionException.class,
                         () ->
-                                RedisClient.createClient(
-                                                RedisClientConfiguration.builder()
+                                GlideClient.createClient(
+                                                GlideClientConfiguration.builder()
                                                         .address(NodeAddress.builder().port(getFreePort()).build())
                                                         .build())
                                         .get());
@@ -40,8 +40,8 @@ public void basic_client_tries_to_connect_to_wrong_address() {
     @SneakyThrows
     public void basic_client_tries_wrong_command() {
         try (var regularClient =
-                RedisClient.createClient(
-                                RedisClientConfiguration.builder()
+                GlideClient.createClient(
+                                GlideClientConfiguration.builder()
                                         .address(
                                                 NodeAddress.builder().port(TestConfiguration.STANDALONE_PORTS[0]).build())
                                         .build())
@@ -60,8 +60,8 @@ public void basic_client_tries_wrong_command() {
     @SneakyThrows
     public void basic_client_tries_wrong_command_arguments() {
         try (var regularClient =
-                RedisClient.createClient(
-                                RedisClientConfiguration.builder()
+                GlideClient.createClient(
+                                GlideClientConfiguration.builder()
                                         .address(
                                                 NodeAddress.builder().port(TestConfiguration.STANDALONE_PORTS[0]).build())
                                         .build())
diff --git a/java/integTest/src/test/java/glide/PubSubTests.java b/java/integTest/src/test/java/glide/PubSubTests.java
index dfb520d554..235de50b51 100644
--- a/java/integTest/src/test/java/glide/PubSubTests.java
+++ b/java/integTest/src/test/java/glide/PubSubTests.java
@@ -17,8 +17,8 @@
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
 import glide.api.BaseClient;
-import glide.api.RedisClient;
-import glide.api.RedisClusterClient;
+import glide.api.GlideClient;
+import glide.api.GlideClusterClient;
 import glide.api.models.ClusterTransaction;
 import glide.api.models.GlideString;
 import glide.api.models.PubSubMessage;
@@ -79,7 +79,7 @@ private <M extends ChannelMode> BaseClient createClientWithSubscriptions(
             if (callback.isPresent()) {
                 subConfigBuilder.callback(callback.get(), context.get());
             }
-            return RedisClient.createClient(
+            return GlideClient.createClient(
                             commonClientConfig()
                                     .requestTimeout(5000)
                                     .subscriptionConfiguration(subConfigBuilder.build())
@@ -94,7 +94,7 @@ private <M extends ChannelMode> BaseClient createClientWithSubscriptions(
                 subConfigBuilder.callback(callback.get(), context.get());
             }
 
-            return RedisClusterClient.createClient(
+            return GlideClusterClient.createClient(
                             commonClusterClientConfig()
                                     .requestTimeout(5000)
                                     .subscriptionConfiguration(subConfigBuilder.build())
@@ -112,9 +112,9 @@ private <M extends ChannelMode> BaseClient createClientWithSubscriptions(
     @SneakyThrows
     private BaseClient createClient(boolean standalone) {
         if (standalone) {
-            return RedisClient.createClient(commonClientConfig().build()).get();
+            return GlideClient.createClient(commonClientConfig().build()).get();
         }
-        return RedisClusterClient.createClient(commonClusterClientConfig().build()).get();
+        return GlideClusterClient.createClient(commonClusterClientConfig().build()).get();
     }
 
     /**
@@ -132,13 +132,13 @@ private BaseClient createClient(boolean standalone) {
     @SneakyThrows
     public void cleanup() {
         for (var client : clients) {
-            if (client instanceof RedisClusterClient) {
-                ((RedisClusterClient) client).customCommand(new String[] {"unsubscribe"}, ALL_NODES).get();
-                ((RedisClusterClient) client).customCommand(new String[] {"punsubscribe"}, ALL_NODES).get();
-                ((RedisClusterClient) client).customCommand(new String[] {"sunsubscribe"}, ALL_NODES).get();
+            if (client instanceof GlideClusterClient) {
+                ((GlideClusterClient) client).customCommand(new String[] {"unsubscribe"}, ALL_NODES).get();
+                ((GlideClusterClient) client).customCommand(new String[] {"punsubscribe"}, ALL_NODES).get();
+                ((GlideClusterClient) client).customCommand(new String[] {"sunsubscribe"}, ALL_NODES).get();
             } else {
-                ((RedisClient) client).customCommand(new String[] {"unsubscribe"}).get();
-                ((RedisClient) client).customCommand(new String[] {"punsubscribe"}).get();
+                ((GlideClient) client).customCommand(new String[] {"unsubscribe"}).get();
+                ((GlideClient) client).customCommand(new String[] {"punsubscribe"}).get();
             }
             client.close();
         }
@@ -295,7 +295,7 @@ public void sharded_pubsub(MessageReadMethod method) {
         var subscriptions = Map.of(PubSubClusterChannelMode.SHARDED, Set.of(channel));
 
         var listener = createListener(false, method == MessageReadMethod.Callback, 1, subscriptions);
-        var sender = (RedisClusterClient) createClient(false);
+        var sender = (GlideClusterClient) createClient(false);
         clients.addAll(List.of(listener, sender));
 
         sender.publish(pubsubMessage, channel, true).get();
@@ -329,7 +329,7 @@ public void sharded_pubsub_many_channels(MessageReadMethod method) {
         }
 
         var listener = createListener(false, method == MessageReadMethod.Callback, 1, subscriptions);
-        var sender = (RedisClusterClient) createClient(false);
+        var sender = (GlideClusterClient) createClient(false);
         clients.addAll(List.of(listener, sender));
 
         for (var pubsubMessage : pubsubMessages) {
@@ -586,7 +586,7 @@ public void combined_exact_pattern_and_sharded_one_client(MessageReadMethod meth
         }
 
         var listener = createListener(false, method == MessageReadMethod.Callback, 1, subscriptions);
-        var sender = (RedisClusterClient) createClient(false);
+        var sender = (GlideClusterClient) createClient(false);
         clients.addAll(List.of(listener, sender));
 
         for (var pubsubMessage : messages) {
@@ -643,7 +643,7 @@ public void coexistense_of_sync_and_async_read() {
         }
 
         var listener = createListener(false, false, 1, subscriptions);
-        var sender = (RedisClusterClient) createClient(false);
+        var sender = (GlideClusterClient) createClient(false);
         clients.addAll(List.of(listener, sender));
 
         for (var pubsubMessage : messages) {
@@ -746,7 +746,7 @@ public void combined_exact_pattern_and_sharded_multi_client(MessageReadMethod me
                         PubSubClusterChannelMode.SHARDED.ordinal(),
                         subscriptionsSharded);
 
-        var sender = (RedisClusterClient) createClient(false);
+        var sender = (GlideClusterClient) createClient(false);
         clients.addAll(List.of(listenerExact, listenerPattern, listenerSharded, sender));
 
         for (var pubsubMessage : exactMessages) {
@@ -823,22 +823,22 @@ public void three_publishing_clients_same_name_with_sharded(MessageReadMethod me
 
         var listenerExact =
                 method == MessageReadMethod.Callback
-                        ? (RedisClusterClient)
+                        ? (GlideClusterClient)
                                 createListener(
                                         false, true, PubSubClusterChannelMode.EXACT.ordinal(), subscriptionsExact)
-                        : (RedisClusterClient) createClientWithSubscriptions(false, subscriptionsExact);
+                        : (GlideClusterClient) createClientWithSubscriptions(false, subscriptionsExact);
 
         var listenerPattern =
                 method == MessageReadMethod.Callback
                         ? createListener(
                                 false, true, PubSubClusterChannelMode.PATTERN.ordinal(), subscriptionsPattern)
-                        : (RedisClusterClient) createClientWithSubscriptions(false, subscriptionsPattern);
+                        : (GlideClusterClient) createClientWithSubscriptions(false, subscriptionsPattern);
 
         var listenerSharded =
                 method == MessageReadMethod.Callback
                         ? createListener(
                                 false, true, PubSubClusterChannelMode.SHARDED.ordinal(), subscriptionsSharded)
-                        : (RedisClusterClient) createClientWithSubscriptions(false, subscriptionsSharded);
+                        : (GlideClusterClient) createClientWithSubscriptions(false, subscriptionsSharded);
 
         clients.addAll(List.of(listenerExact, listenerPattern, listenerSharded));
 
@@ -904,7 +904,7 @@ public void error_cases() {
         client.close();
 
         // using sharded channels from different slots in a transaction causes a cross slot error
-        var clusterClient = (RedisClusterClient) createClient(false);
+        var clusterClient = (GlideClusterClient) createClient(false);
         var transaction =
                 new ClusterTransaction()
                         .publish("one", "abc", true)
@@ -959,14 +959,14 @@ public void transaction_with_all_types_of_messages(boolean standalone, MessageRe
                     new Transaction()
                             .publish(exactMessage.getMessage(), exactMessage.getChannel())
                             .publish(patternMessage.getMessage(), patternMessage.getChannel());
-            ((RedisClient) sender).exec(transaction).get();
+            ((GlideClient) sender).exec(transaction).get();
         } else {
             var transaction =
                     new ClusterTransaction()
                             .publish(shardedMessage.getMessage(), shardedMessage.getChannel(), true)
                             .publish(exactMessage.getMessage(), exactMessage.getChannel())
                             .publish(patternMessage.getMessage(), patternMessage.getChannel());
-            ((RedisClusterClient) sender).exec(transaction).get();
+            ((GlideClusterClient) sender).exec(transaction).get();
         }
 
         Thread.sleep(MESSAGE_DELIVERY_DELAY); // deliver the messages
@@ -1038,7 +1038,7 @@ public void pubsub_sharded_max_size_message(boolean standalone) {
         clients.addAll(Arrays.asList(listener, sender));
 
         assertEquals(OK, sender.publish(message, channel).get());
-        assertEquals(OK, ((RedisClusterClient) sender).publish(message2, channel, true).get());
+        assertEquals(OK, ((GlideClusterClient) sender).publish(message2, channel, true).get());
 
         // Allow the message to propagate.
         Thread.sleep(MESSAGE_DELIVERY_DELAY);
@@ -1136,7 +1136,7 @@ public void pubsub_sharded_max_size_message_callback(boolean standalone) {
         var sender = createClient(standalone);
         clients.addAll(Arrays.asList(listener, sender));
 
-        assertEquals(OK, ((RedisClusterClient) sender).publish(message, channel, true).get());
+        assertEquals(OK, ((GlideClusterClient) sender).publish(message, channel, true).get());
 
         // Allow the message to propagate.
         Thread.sleep(MESSAGE_DELIVERY_DELAY);
diff --git a/java/integTest/src/test/java/glide/SharedClientTests.java b/java/integTest/src/test/java/glide/SharedClientTests.java
index 8648394d3c..bf106f1ff4 100644
--- a/java/integTest/src/test/java/glide/SharedClientTests.java
+++ b/java/integTest/src/test/java/glide/SharedClientTests.java
@@ -8,8 +8,8 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import glide.api.BaseClient;
-import glide.api.RedisClient;
-import glide.api.RedisClusterClient;
+import glide.api.GlideClient;
+import glide.api.GlideClusterClient;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
@@ -28,17 +28,17 @@
 @Timeout(25) // seconds
 public class SharedClientTests {
 
-    private static RedisClient standaloneClient = null;
-    private static RedisClusterClient clusterClient = null;
+    private static GlideClient standaloneClient = null;
+    private static GlideClusterClient clusterClient = null;
 
     @Getter private static List<Arguments> clients;
 
     @BeforeAll
     @SneakyThrows
     public static void init() {
-        standaloneClient = RedisClient.createClient(commonClientConfig().build()).get();
+        standaloneClient = GlideClient.createClient(commonClientConfig().build()).get();
         clusterClient =
-                RedisClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
+                GlideClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
                         .get();
 
         clients = List.of(Arguments.of(standaloneClient), Arguments.of(clusterClient));
diff --git a/java/integTest/src/test/java/glide/SharedCommandTests.java b/java/integTest/src/test/java/glide/SharedCommandTests.java
index 0693d3a51a..0c07985dba 100644
--- a/java/integTest/src/test/java/glide/SharedCommandTests.java
+++ b/java/integTest/src/test/java/glide/SharedCommandTests.java
@@ -30,8 +30,8 @@
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
 import glide.api.BaseClient;
-import glide.api.RedisClient;
-import glide.api.RedisClusterClient;
+import glide.api.GlideClient;
+import glide.api.GlideClusterClient;
 import glide.api.models.GlideString;
 import glide.api.models.Script;
 import glide.api.models.commands.ConditionalChange;
@@ -99,9 +99,9 @@
 import glide.api.models.commands.stream.StreamReadOptions;
 import glide.api.models.commands.stream.StreamTrimOptions.MaxLen;
 import glide.api.models.commands.stream.StreamTrimOptions.MinId;
+import glide.api.models.configuration.GlideClientConfiguration;
+import glide.api.models.configuration.GlideClusterClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
-import glide.api.models.configuration.RedisClientConfiguration;
-import glide.api.models.configuration.RedisClusterClientConfiguration;
 import glide.api.models.exceptions.RequestException;
 import java.time.Instant;
 import java.util.Arrays;
@@ -131,8 +131,8 @@
 @Timeout(10) // seconds
 public class SharedCommandTests {
 
-    private static RedisClient standaloneClient = null;
-    private static RedisClusterClient clusterClient = null;
+    private static GlideClient standaloneClient = null;
+    private static GlideClusterClient clusterClient = null;
 
     @Getter private static List<Arguments> clients;
 
@@ -144,16 +144,16 @@ public class SharedCommandTests {
     @SneakyThrows
     public static void init() {
         standaloneClient =
-                RedisClient.createClient(
-                                RedisClientConfiguration.builder()
+                GlideClient.createClient(
+                                GlideClientConfiguration.builder()
                                         .address(NodeAddress.builder().port(STANDALONE_PORTS[0]).build())
                                         .requestTimeout(5000)
                                         .build())
                         .get();
 
         clusterClient =
-                RedisClusterClient.createClient(
-                                RedisClusterClientConfiguration.builder()
+                GlideClusterClient.createClient(
+                                GlideClusterClientConfiguration.builder()
                                         .address(NodeAddress.builder().port(CLUSTER_PORTS[0]).build())
                                         .requestTimeout(5000)
                                         .build())
@@ -3411,9 +3411,9 @@ public void bzpopmin_timeout_check(BaseClient client) {
         String key = UUID.randomUUID().toString();
         // create new client with default request timeout (250 millis)
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands doesn't time out even if timeout > request timeout
             assertNull(testClient.bzpopmin(new String[] {key}, 1).get());
@@ -3433,9 +3433,9 @@ public void bzpopmin_binary_timeout_check(BaseClient client) {
         GlideString key = gs(UUID.randomUUID().toString());
         // create new client with default request timeout (250 millis)
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands doesn't time out even if timeout > request timeout
             assertNull(testClient.bzpopmin(new GlideString[] {key}, 1).get());
@@ -3562,9 +3562,9 @@ public void bzpopmax_timeout_check(BaseClient client) {
         String key = UUID.randomUUID().toString();
         // create new client with default request timeout (250 millis)
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands doesn't time out even if timeout > request timeout
             assertNull(testClient.bzpopmax(new String[] {key}, 1).get());
@@ -3584,9 +3584,9 @@ public void bzpopmax_binary_timeout_check(BaseClient client) {
         GlideString key = gs(UUID.randomUUID().toString());
         // create new client with default request timeout (250 millis)
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands doesn't time out even if timeout > request timeout
             assertNull(testClient.bzpopmax(new GlideString[] {key}, 1).get());
@@ -4856,9 +4856,9 @@ public void bzmpop_timeout_check(BaseClient client) {
         String key = UUID.randomUUID().toString();
         // create new client with default request timeout (250 millis)
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands doesn't time out even if timeout > request timeout
             assertNull(testClient.bzmpop(new String[] {key}, MAX, 1).get());
@@ -4880,9 +4880,9 @@ public void bzmpop_binary_timeout_check(BaseClient client) {
         GlideString key = gs(UUID.randomUUID().toString());
         // create new client with default request timeout (250 millis)
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands doesn't time out even if timeout > request timeout
             assertNull(testClient.bzmpop(new GlideString[] {key}, MAX, 1).get());
@@ -5221,9 +5221,9 @@ public void xread_return_failures(BaseClient client) {
         assertInstanceOf(RequestException.class, executionException.getCause());
 
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands doesn't time out even if timeout > request timeout
             long oneSecondInMS = 1000L;
@@ -6426,9 +6426,9 @@ public void xreadgroup_return_failures(BaseClient client) {
         assertEquals(0, emptyResult.get(key).size());
 
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
             String timeoutKey = "{key}:2" + UUID.randomUUID();
             String timeoutGroupName = "group" + UUID.randomUUID();
             String timeoutConsumerName = "consumer" + UUID.randomUUID();
@@ -9166,9 +9166,9 @@ public void getbit(BaseClient client) {
         assertEquals(1, client.getbit(gs(key1), 1).get());
         assertEquals(0, client.getbit(gs(key1), 1000).get());
         assertEquals(0, client.getbit(gs(missingKey), 1).get());
-        if (client instanceof RedisClient) {
+        if (client instanceof GlideClient) {
             assertEquals(
-                    1L, ((RedisClient) client).customCommand(new String[] {"SETBIT", key1, "5", "0"}).get());
+                    1L, ((GlideClient) client).customCommand(new String[] {"SETBIT", key1, "5", "0"}).get());
             assertEquals(0, client.getbit(key1, 5).get());
         }
 
@@ -9504,9 +9504,9 @@ public void blmpop_timeout_check(BaseClient client) {
         String key = UUID.randomUUID().toString();
         // create new client with default request timeout (250 millis)
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands doesn't time out even if timeout > request timeout
             assertNull(testClient.blmpop(new String[] {key}, ListDirection.LEFT, 1).get());
@@ -9530,9 +9530,9 @@ public void blmpop_binary_timeout_check(BaseClient client) {
         GlideString key = gs(UUID.randomUUID().toString());
         // create new client with default request timeout (250 millis)
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands doesn't time out even if timeout > request timeout
             assertNull(testClient.blmpop(new GlideString[] {key}, ListDirection.LEFT, 1).get());
@@ -9878,9 +9878,9 @@ public void blmove_timeout_check(BaseClient client) {
         String key2 = "{key}-2" + UUID.randomUUID();
         // create new client with default request timeout (250 millis)
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands doesn't time out even if timeout > request timeout
             assertNull(testClient.blmove(key1, key2, ListDirection.LEFT, ListDirection.LEFT, 1).get());
@@ -9906,9 +9906,9 @@ public void blmove_binary_timeout_check(BaseClient client) {
         GlideString key2 = gs("{key}-2" + UUID.randomUUID());
         // create new client with default request timeout (250 millis)
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands doesn't time out even if timeout > request timeout
             assertNull(testClient.blmove(key1, key2, ListDirection.LEFT, ListDirection.LEFT, 1).get());
@@ -13533,7 +13533,7 @@ public void waitTest(BaseClient client) {
 
         // assert that wait returns 0 under standalone and 1 under cluster mode.
         assertEquals(OK, client.set(key, "value").get());
-        assertTrue(client.wait(numreplicas, timeout).get() >= (client instanceof RedisClient ? 0 : 1));
+        assertTrue(client.wait(numreplicas, timeout).get() >= (client instanceof GlideClient ? 0 : 1));
 
         // command should fail on a negative timeout value
         ExecutionException executionException =
@@ -13548,13 +13548,13 @@ public void wait_timeout_check(BaseClient client) {
         String key = UUID.randomUUID().toString();
         // create new client with default request timeout (250 millis)
         try (var testClient =
-                client instanceof RedisClient
-                        ? RedisClient.createClient(commonClientConfig().build()).get()
-                        : RedisClusterClient.createClient(commonClusterClientConfig().build()).get()) {
+                client instanceof GlideClient
+                        ? GlideClient.createClient(commonClientConfig().build()).get()
+                        : GlideClusterClient.createClient(commonClusterClientConfig().build()).get()) {
 
             // ensure that commands do not time out, even if timeout > request timeout
             assertEquals(OK, testClient.set(key, "value").get());
-            assertEquals((client instanceof RedisClient ? 0 : 1), testClient.wait(1L, 1000L).get());
+            assertEquals((client instanceof GlideClient ? 0 : 1), testClient.wait(1L, 1000L).get());
 
             // with 0 timeout (no timeout) wait should block indefinitely,
             // but we wrap the test with timeout to avoid test failing or being stuck forever
diff --git a/java/integTest/src/test/java/glide/TestUtilities.java b/java/integTest/src/test/java/glide/TestUtilities.java
index 16fba4e320..796600567f 100644
--- a/java/integTest/src/test/java/glide/TestUtilities.java
+++ b/java/integTest/src/test/java/glide/TestUtilities.java
@@ -10,13 +10,13 @@
 import static org.junit.jupiter.api.Assertions.fail;
 
 import glide.api.BaseClient;
-import glide.api.RedisClient;
-import glide.api.RedisClusterClient;
+import glide.api.GlideClient;
+import glide.api.GlideClusterClient;
 import glide.api.models.ClusterValue;
 import glide.api.models.GlideString;
+import glide.api.models.configuration.GlideClientConfiguration;
+import glide.api.models.configuration.GlideClusterClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
-import glide.api.models.configuration.RedisClientConfiguration;
-import glide.api.models.configuration.RedisClusterClientConfiguration;
 import java.security.SecureRandom;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -77,15 +77,15 @@ public static Map<String, String> parseInfoResponseToMap(String serverInfo) {
                                 HashMap::new));
     }
 
-    public static RedisClientConfiguration.RedisClientConfigurationBuilder<?, ?>
+    public static GlideClientConfiguration.GlideClientConfigurationBuilder<?, ?>
             commonClientConfig() {
-        return RedisClientConfiguration.builder()
+        return GlideClientConfiguration.builder()
                 .address(NodeAddress.builder().port(STANDALONE_PORTS[0]).build());
     }
 
-    public static RedisClusterClientConfiguration.RedisClusterClientConfigurationBuilder<?, ?>
+    public static GlideClusterClientConfiguration.GlideClusterClientConfigurationBuilder<?, ?>
             commonClusterClientConfig() {
-        return RedisClusterClientConfiguration.builder()
+        return GlideClusterClientConfiguration.builder()
                 .address(NodeAddress.builder().port(CLUSTER_PORTS[0]).build());
     }
 
@@ -358,10 +358,10 @@ public static void waitForNotBusy(BaseClient client) {
         boolean isBusy = true;
         do {
             try {
-                if (client instanceof RedisClusterClient) {
-                    ((RedisClusterClient) client).functionKill().get();
-                } else if (client instanceof RedisClient) {
-                    ((RedisClient) client).functionKill().get();
+                if (client instanceof GlideClusterClient) {
+                    ((GlideClusterClient) client).functionKill().get();
+                } else if (client instanceof GlideClient) {
+                    ((GlideClient) client).functionKill().get();
                 }
             } catch (Exception busy) {
                 // should throw `notbusy` error, because the function should be killed before
diff --git a/java/integTest/src/test/java/glide/cluster/ClusterClientTests.java b/java/integTest/src/test/java/glide/cluster/ClusterClientTests.java
index 27a213d5ce..8c461d96c9 100644
--- a/java/integTest/src/test/java/glide/cluster/ClusterClientTests.java
+++ b/java/integTest/src/test/java/glide/cluster/ClusterClientTests.java
@@ -10,7 +10,7 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
-import glide.api.RedisClusterClient;
+import glide.api.GlideClusterClient;
 import glide.api.models.configuration.RedisCredentials;
 import glide.api.models.exceptions.ClosingException;
 import glide.api.models.exceptions.RequestException;
@@ -30,8 +30,8 @@ public void register_client_name_and_version() {
                 SERVER_VERSION.isGreaterThanOrEqualTo(minVersion),
                 "Redis version required >= " + minVersion);
 
-        RedisClusterClient client =
-                RedisClusterClient.createClient(commonClusterClientConfig().build()).get();
+        GlideClusterClient client =
+                GlideClusterClient.createClient(commonClusterClientConfig().build()).get();
 
         String info =
                 (String) client.customCommand(new String[] {"CLIENT", "INFO"}).get().getSingleValue();
@@ -44,8 +44,8 @@ public void register_client_name_and_version() {
     @SneakyThrows
     @Test
     public void can_connect_with_auth_requirepass() {
-        RedisClusterClient client =
-                RedisClusterClient.createClient(commonClusterClientConfig().build()).get();
+        GlideClusterClient client =
+                GlideClusterClient.createClient(commonClusterClientConfig().build()).get();
 
         String password = "TEST_AUTH";
         client.customCommand(new String[] {"CONFIG", "SET", "requirepass", password}).get();
@@ -54,12 +54,12 @@ public void can_connect_with_auth_requirepass() {
         ExecutionException exception =
                 assertThrows(
                         ExecutionException.class,
-                        () -> RedisClusterClient.createClient(commonClusterClientConfig().build()).get());
+                        () -> GlideClusterClient.createClient(commonClusterClientConfig().build()).get());
         assertTrue(exception.getCause() instanceof ClosingException);
 
         // Creation of a new client with credentials
-        RedisClusterClient auth_client =
-                RedisClusterClient.createClient(
+        GlideClusterClient auth_client =
+                GlideClusterClient.createClient(
                                 commonClusterClientConfig()
                                         .credentials(RedisCredentials.builder().password(password).build())
                                         .build())
@@ -81,8 +81,8 @@ public void can_connect_with_auth_requirepass() {
     @SneakyThrows
     @Test
     public void can_connect_with_auth_acl() {
-        RedisClusterClient client =
-                RedisClusterClient.createClient(commonClusterClientConfig().build()).get();
+        GlideClusterClient client =
+                GlideClusterClient.createClient(commonClusterClientConfig().build()).get();
 
         String username = "testuser";
         String password = "TEST_AUTH";
@@ -112,8 +112,8 @@ public void can_connect_with_auth_acl() {
         assertEquals(OK, client.set(key, value).get());
 
         // Creation of a new cluster client with credentials
-        RedisClusterClient testUserClient =
-                RedisClusterClient.createClient(
+        GlideClusterClient testUserClient =
+                GlideClusterClient.createClient(
                                 commonClusterClientConfig()
                                         .credentials(
                                                 RedisCredentials.builder().username(username).password(password).build())
@@ -135,8 +135,8 @@ public void can_connect_with_auth_acl() {
     @SneakyThrows
     @Test
     public void client_name() {
-        RedisClusterClient client =
-                RedisClusterClient.createClient(
+        GlideClusterClient client =
+                GlideClusterClient.createClient(
                                 commonClusterClientConfig().clientName("TEST_CLIENT_NAME").build())
                         .get();
 
@@ -150,8 +150,8 @@ public void client_name() {
     @Test
     @SneakyThrows
     public void closed_client_throws_ExecutionException_with_ClosingException_as_cause() {
-        RedisClusterClient client =
-                RedisClusterClient.createClient(commonClusterClientConfig().build()).get();
+        GlideClusterClient client =
+                GlideClusterClient.createClient(commonClusterClientConfig().build()).get();
 
         client.close();
         ExecutionException executionException =
diff --git a/java/integTest/src/test/java/glide/cluster/ClusterTransactionTests.java b/java/integTest/src/test/java/glide/cluster/ClusterTransactionTests.java
index 54e8d2d9d1..f2b6462d1d 100644
--- a/java/integTest/src/test/java/glide/cluster/ClusterTransactionTests.java
+++ b/java/integTest/src/test/java/glide/cluster/ClusterTransactionTests.java
@@ -18,14 +18,14 @@
 
 import glide.TestConfiguration;
 import glide.TransactionTestUtilities.TransactionBuilder;
-import glide.api.RedisClusterClient;
+import glide.api.GlideClusterClient;
 import glide.api.models.ClusterTransaction;
 import glide.api.models.GlideString;
 import glide.api.models.commands.SortClusterOptions;
 import glide.api.models.commands.function.FunctionRestorePolicy;
 import glide.api.models.commands.stream.StreamAddOptions;
+import glide.api.models.configuration.GlideClusterClientConfiguration;
 import glide.api.models.configuration.NodeAddress;
-import glide.api.models.configuration.RedisClusterClientConfiguration;
 import glide.api.models.configuration.RequestRoutingConfiguration.SingleNodeRoute;
 import glide.api.models.configuration.RequestRoutingConfiguration.SlotIdRoute;
 import glide.api.models.configuration.RequestRoutingConfiguration.SlotType;
@@ -45,14 +45,14 @@
 @Timeout(10) // seconds
 public class ClusterTransactionTests {
 
-    private static RedisClusterClient clusterClient = null;
+    private static GlideClusterClient clusterClient = null;
 
     @BeforeAll
     @SneakyThrows
     public static void init() {
         clusterClient =
-                RedisClusterClient.createClient(
-                                RedisClusterClientConfiguration.builder()
+                GlideClusterClient.createClient(
+                                GlideClusterClientConfiguration.builder()
                                         .address(NodeAddress.builder().port(TestConfiguration.CLUSTER_PORTS[0]).build())
                                         .requestTimeout(5000)
                                         .build())
diff --git a/java/integTest/src/test/java/glide/cluster/CommandTests.java b/java/integTest/src/test/java/glide/cluster/CommandTests.java
index cf7cacf968..45603070ee 100644
--- a/java/integTest/src/test/java/glide/cluster/CommandTests.java
+++ b/java/integTest/src/test/java/glide/cluster/CommandTests.java
@@ -49,7 +49,7 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
-import glide.api.RedisClusterClient;
+import glide.api.GlideClusterClient;
 import glide.api.models.ClusterTransaction;
 import glide.api.models.ClusterValue;
 import glide.api.models.GlideString;
@@ -102,7 +102,7 @@
 @Timeout(10) // seconds
 public class CommandTests {
 
-    private static RedisClusterClient clusterClient = null;
+    private static GlideClusterClient clusterClient = null;
 
     private static final String INITIAL_VALUE = "VALUE";
 
@@ -154,7 +154,7 @@ public class CommandTests {
     @SneakyThrows
     public static void init() {
         clusterClient =
-                RedisClusterClient.createClient(commonClusterClientConfig().requestTimeout(7000).build())
+                GlideClusterClient.createClient(commonClusterClientConfig().requestTimeout(7000).build())
                         .get();
     }
 
@@ -1735,7 +1735,7 @@ public void functionKill_no_write_without_route() {
         assertEquals(libName, clusterClient.functionLoad(code, true).get());
 
         try (var testClient =
-                RedisClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
+                GlideClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
                         .get()) {
             try {
                 // call the function without await
@@ -1790,7 +1790,7 @@ public void functionKillBinary_no_write_without_route() {
         assertEquals(libName, clusterClient.functionLoad(code, true).get());
 
         try (var testClient =
-                RedisClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
+                GlideClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
                         .get()) {
             try {
                 // call the function without await
@@ -1847,7 +1847,7 @@ public void functionKill_no_write_with_route(boolean singleNodeRoute) {
         assertEquals(libName, clusterClient.functionLoad(code, true, route).get());
 
         try (var testClient =
-                RedisClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
+                GlideClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
                         .get()) {
             try {
                 // call the function without await
@@ -1900,7 +1900,7 @@ public void functionKillBinary_no_write_with_route(boolean singleNodeRoute) {
         assertEquals(libName, clusterClient.functionLoad(code, true, route).get());
 
         try (var testClient =
-                RedisClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
+                GlideClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
                         .get()) {
             try {
                 // call the function without await
@@ -1954,7 +1954,7 @@ public void functionKill_key_based_write_function() {
         assertEquals(libName, clusterClient.functionLoad(code, true, route).get());
 
         try (var testClient =
-                RedisClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
+                GlideClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
                         .get()) {
             try {
                 // call the function without await
@@ -2022,7 +2022,7 @@ public void functionKillBinary_key_based_write_function() {
         assertEquals(libName, clusterClient.functionLoad(code, true, route).get());
 
         try (var testClient =
-                RedisClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
+                GlideClusterClient.createClient(commonClusterClientConfig().requestTimeout(10000).build())
                         .get()) {
             try {
                 // call the function without await
diff --git a/java/integTest/src/test/java/glide/standalone/CommandTests.java b/java/integTest/src/test/java/glide/standalone/CommandTests.java
index f5e66eba70..bec2d50c83 100644
--- a/java/integTest/src/test/java/glide/standalone/CommandTests.java
+++ b/java/integTest/src/test/java/glide/standalone/CommandTests.java
@@ -46,7 +46,7 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
-import glide.api.RedisClient;
+import glide.api.GlideClient;
 import glide.api.models.GlideString;
 import glide.api.models.commands.InfoOptions;
 import glide.api.models.commands.SortOptions;
@@ -77,13 +77,13 @@ public class CommandTests {
 
     private static final String INITIAL_VALUE = "VALUE";
 
-    private static RedisClient regularClient = null;
+    private static GlideClient regularClient = null;
 
     @BeforeAll
     @SneakyThrows
     public static void init() {
         regularClient =
-                RedisClient.createClient(commonClientConfig().requestTimeout(7000).build()).get();
+                GlideClient.createClient(commonClientConfig().requestTimeout(7000).build()).get();
     }
 
     @AfterAll
@@ -754,7 +754,7 @@ public void functionKill_no_write() {
         assertEquals(libName, regularClient.functionLoad(code, true).get());
 
         try (var testClient =
-                RedisClient.createClient(commonClientConfig().requestTimeout(10000).build()).get()) {
+                GlideClient.createClient(commonClientConfig().requestTimeout(10000).build()).get()) {
             try {
                 // call the function without await
                 testClient.fcall(funcName);
@@ -805,7 +805,7 @@ public void functionKillBinary_no_write() {
         assertEquals(libName, regularClient.functionLoad(code, true).get());
 
         try (var testClient =
-                RedisClient.createClient(commonClientConfig().requestTimeout(10000).build()).get()) {
+                GlideClient.createClient(commonClientConfig().requestTimeout(10000).build()).get()) {
             try {
                 // call the function without await
                 testClient.fcall(funcName);
@@ -858,7 +858,7 @@ public void functionKill_write_function() {
         assertEquals(libName, regularClient.functionLoad(code, true).get());
 
         try (var testClient =
-                RedisClient.createClient(commonClientConfig().requestTimeout(10000).build()).get()) {
+                GlideClient.createClient(commonClientConfig().requestTimeout(10000).build()).get()) {
             try {
                 // call the function without await
                 promise = testClient.fcall(funcName, new String[] {key}, new String[0]);
@@ -924,7 +924,7 @@ public void functionKillBinary_write_function() {
         assertEquals(libName, regularClient.functionLoad(code, true).get());
 
         try (var testClient =
-                RedisClient.createClient(commonClientConfig().requestTimeout(10000).build()).get()) {
+                GlideClient.createClient(commonClientConfig().requestTimeout(10000).build()).get()) {
             try {
                 // call the function without await
                 promise = testClient.fcall(funcName, new GlideString[] {key}, new GlideString[0]);
diff --git a/java/integTest/src/test/java/glide/standalone/StandaloneClientTests.java b/java/integTest/src/test/java/glide/standalone/StandaloneClientTests.java
index ce575cb4d1..34ee1da8e3 100644
--- a/java/integTest/src/test/java/glide/standalone/StandaloneClientTests.java
+++ b/java/integTest/src/test/java/glide/standalone/StandaloneClientTests.java
@@ -10,7 +10,7 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
-import glide.api.RedisClient;
+import glide.api.GlideClient;
 import glide.api.models.configuration.RedisCredentials;
 import glide.api.models.exceptions.ClosingException;
 import glide.api.models.exceptions.RequestException;
@@ -30,7 +30,7 @@ public void register_client_name_and_version() {
                 SERVER_VERSION.isGreaterThanOrEqualTo(minVersion),
                 "Redis version required >= " + minVersion);
 
-        RedisClient client = RedisClient.createClient(commonClientConfig().build()).get();
+        GlideClient client = GlideClient.createClient(commonClientConfig().build()).get();
 
         String info = (String) client.customCommand(new String[] {"CLIENT", "INFO"}).get();
         assertTrue(info.contains("lib-name=GlideJava"));
@@ -42,7 +42,7 @@ public void register_client_name_and_version() {
     @SneakyThrows
     @Test
     public void can_connect_with_auth_require_pass() {
-        RedisClient client = RedisClient.createClient(commonClientConfig().build()).get();
+        GlideClient client = GlideClient.createClient(commonClientConfig().build()).get();
 
         String password = "TEST_AUTH";
         client.customCommand(new String[] {"CONFIG", "SET", "requirepass", password}).get();
@@ -51,12 +51,12 @@ public void can_connect_with_auth_require_pass() {
         ExecutionException exception =
                 assertThrows(
                         ExecutionException.class,
-                        () -> RedisClient.createClient(commonClientConfig().build()).get());
+                        () -> GlideClient.createClient(commonClientConfig().build()).get());
         assertTrue(exception.getCause() instanceof ClosingException);
 
         // Creation of a new client with credentials
-        RedisClient auth_client =
-                RedisClient.createClient(
+        GlideClient auth_client =
+                GlideClient.createClient(
                                 commonClientConfig()
                                         .credentials(RedisCredentials.builder().password(password).build())
                                         .build())
@@ -78,7 +78,7 @@ public void can_connect_with_auth_require_pass() {
     @SneakyThrows
     @Test
     public void can_connect_with_auth_acl() {
-        RedisClient client = RedisClient.createClient(commonClientConfig().build()).get();
+        GlideClient client = GlideClient.createClient(commonClientConfig().build()).get();
 
         String username = "testuser";
         String password = "TEST_AUTH";
@@ -107,8 +107,8 @@ public void can_connect_with_auth_acl() {
         assertEquals(OK, client.set(key, value).get());
 
         // Creation of a new client with credentials
-        RedisClient testUserClient =
-                RedisClient.createClient(
+        GlideClient testUserClient =
+                GlideClient.createClient(
                                 commonClientConfig()
                                         .credentials(
                                                 RedisCredentials.builder().username(username).password(password).build())
@@ -129,7 +129,7 @@ public void can_connect_with_auth_acl() {
     @SneakyThrows
     @Test
     public void select_standalone_database_id() {
-        RedisClient client = RedisClient.createClient(commonClientConfig().databaseId(4).build()).get();
+        GlideClient client = GlideClient.createClient(commonClientConfig().databaseId(4).build()).get();
 
         String clientInfo = (String) client.customCommand(new String[] {"CLIENT", "INFO"}).get();
         assertTrue(clientInfo.contains("db=4"));
@@ -140,8 +140,8 @@ public void select_standalone_database_id() {
     @SneakyThrows
     @Test
     public void client_name() {
-        RedisClient client =
-                RedisClient.createClient(commonClientConfig().clientName("TEST_CLIENT_NAME").build()).get();
+        GlideClient client =
+                GlideClient.createClient(commonClientConfig().clientName("TEST_CLIENT_NAME").build()).get();
 
         String clientInfo = (String) client.customCommand(new String[] {"CLIENT", "INFO"}).get();
         assertTrue(clientInfo.contains("name=TEST_CLIENT_NAME"));
@@ -152,7 +152,7 @@ public void client_name() {
     @Test
     @SneakyThrows
     public void closed_client_throws_ExecutionException_with_ClosingException_as_cause() {
-        RedisClient client = RedisClient.createClient(commonClientConfig().build()).get();
+        GlideClient client = GlideClient.createClient(commonClientConfig().build()).get();
 
         client.close();
         ExecutionException executionException =
diff --git a/java/integTest/src/test/java/glide/standalone/TransactionTests.java b/java/integTest/src/test/java/glide/standalone/TransactionTests.java
index 3cf1d664c7..e78f027c29 100644
--- a/java/integTest/src/test/java/glide/standalone/TransactionTests.java
+++ b/java/integTest/src/test/java/glide/standalone/TransactionTests.java
@@ -25,7 +25,7 @@
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
 import glide.TransactionTestUtilities.TransactionBuilder;
-import glide.api.RedisClient;
+import glide.api.GlideClient;
 import glide.api.models.GlideString;
 import glide.api.models.Transaction;
 import glide.api.models.commands.InfoOptions;
@@ -52,12 +52,12 @@
 @Timeout(10) // seconds
 public class TransactionTests {
 
-    private static RedisClient client = null;
+    private static GlideClient client = null;
 
     @BeforeAll
     @SneakyThrows
     public static void init() {
-        client = RedisClient.createClient(commonClientConfig().requestTimeout(7000).build()).get();
+        client = GlideClient.createClient(commonClientConfig().requestTimeout(7000).build()).get();
     }
 
     @AfterAll