diff --git a/redis/_parsers/base.py b/redis/_parsers/base.py
index be7b5cf1d0..928ec0c201 100644
--- a/redis/_parsers/base.py
+++ b/redis/_parsers/base.py
@@ -5,12 +5,12 @@
 from typing import Awaitable, Callable, List, Optional, Protocol, Union
 
 from redis.maintenance_events import (
-    MaintenanceEvent,
-    NodeFailedOverEvent,
-    NodeFailingOverEvent,
-    NodeMigratedEvent,
-    NodeMigratingEvent,
-    NodeMovingEvent,
+    MaintenanceNotification,
+    NodeFailedOverNotification,
+    NodeFailingOverNotification,
+    NodeMigratedNotification,
+    NodeMigratingNotification,
+    NodeMovingNotification,
 )
 
 if sys.version_info.major >= 3 and sys.version_info.minor >= 11:
@@ -175,14 +175,14 @@ class MaintenanceNotificationsParser:
 
     @staticmethod
     def parse_maintenance_start_msg(response, notification_type):
-        # Expected message format is: <event_type> <seq_number> <time>
+        # Expected message format is: <notification_type> <seq_number> <time>
         id = response[1]
         ttl = response[2]
         return notification_type(id, ttl)
 
     @staticmethod
     def parse_maintenance_completed_msg(response, notification_type):
-        # Expected message format is: <event_type> <seq_number>
+        # Expected message format is: <notification_type> <seq_number>
         id = response[1]
         return notification_type(id)
 
@@ -200,7 +200,7 @@ def parse_moving_msg(response):
             host, port = value.split(":")
             port = int(port) if port is not None else None
 
-        return NodeMovingEvent(id, host, port, ttl)
+        return NodeMovingNotification(id, host, port, ttl)
 
 
 _INVALIDATION_MESSAGE = "invalidate"
@@ -217,25 +217,27 @@ def parse_moving_msg(response):
     _FAILED_OVER_MESSAGE,
 )
 
-MSG_TYPE_TO_EVENT_PARSER_MAPPING: dict[str, tuple[type[MaintenanceEvent], Callable]] = {
+MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING: dict[
+    str, tuple[type[MaintenanceNotification], Callable]
+] = {
     _MIGRATING_MESSAGE: (
-        NodeMigratingEvent,
+        NodeMigratingNotification,
         MaintenanceNotificationsParser.parse_maintenance_start_msg,
     ),
     _MIGRATED_MESSAGE: (
-        NodeMigratedEvent,
+        NodeMigratedNotification,
         MaintenanceNotificationsParser.parse_maintenance_completed_msg,
     ),
     _FAILING_OVER_MESSAGE: (
-        NodeFailingOverEvent,
+        NodeFailingOverNotification,
         MaintenanceNotificationsParser.parse_maintenance_start_msg,
     ),
     _FAILED_OVER_MESSAGE: (
-        NodeFailedOverEvent,
+        NodeFailedOverNotification,
         MaintenanceNotificationsParser.parse_maintenance_completed_msg,
     ),
     _MOVING_MESSAGE: (
-        NodeMovingEvent,
+        NodeMovingNotification,
         MaintenanceNotificationsParser.parse_moving_msg,
     ),
 }
@@ -273,14 +275,20 @@ def handle_push_response(self, response, **kwargs):
                 return self.invalidation_push_handler_func(response)
 
             if msg_type == _MOVING_MESSAGE and self.node_moving_push_handler_func:
-                parser_function = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][1]
+                parser_function = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][1]
 
                 notification = parser_function(response)
                 return self.node_moving_push_handler_func(notification)
 
             if msg_type in _MAINTENANCE_MESSAGES and self.maintenance_push_handler_func:
-                parser_function = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][1]
-                notification_type = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][0]
+                parser_function = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][1]
+                notification_type = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][0]
                 notification = parser_function(response, notification_type)
 
                 if notification is not None:
@@ -342,13 +350,19 @@ async def handle_push_response(self, response, **kwargs):
                 msg_type = msg_type.decode()
 
             if msg_type == _MOVING_MESSAGE and self.node_moving_push_handler_func:
-                parser_function = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][1]
+                parser_function = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][1]
                 notification = parser_function(response)
                 return await self.node_moving_push_handler_func(notification)
 
             if msg_type in _MAINTENANCE_MESSAGES and self.maintenance_push_handler_func:
-                parser_function = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][1]
-                notification_type = MSG_TYPE_TO_EVENT_PARSER_MAPPING[msg_type][0]
+                parser_function = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][1]
+                notification_type = MSG_TYPE_TO_MAINT_NOTIFICATION_PARSER_MAPPING[
+                    msg_type
+                ][0]
                 notification = parser_function(response, notification_type)
 
                 if notification is not None:
diff --git a/redis/client.py b/redis/client.py
index 26837b673b..ff92955917 100755
--- a/redis/client.py
+++ b/redis/client.py
@@ -57,8 +57,8 @@
 )
 from redis.lock import Lock
 from redis.maintenance_events import (
-    MaintenanceEventPoolHandler,
-    MaintenanceEventsConfig,
+    MaintNotificationsConfig,
+    MaintNotificationsPoolHandler,
 )
 from redis.retry import Retry
 from redis.utils import (
@@ -248,7 +248,7 @@ def __init__(
         cache: Optional[CacheInterface] = None,
         cache_config: Optional[CacheConfig] = None,
         event_dispatcher: Optional[EventDispatcher] = None,
-        maintenance_events_config: Optional[MaintenanceEventsConfig] = None,
+        maint_notifications_config: Optional[MaintNotificationsConfig] = None,
     ) -> None:
         """
         Initialize a new Redis client.
@@ -373,22 +373,22 @@ def __init__(
         ]:
             raise RedisError("Client caching is only supported with RESP version 3")
 
-        if maintenance_events_config and self.connection_pool.get_protocol() not in [
+        if maint_notifications_config and self.connection_pool.get_protocol() not in [
             3,
             "3",
         ]:
             raise RedisError(
                 "Push handlers on connection are only supported with RESP version 3"
             )
-        if maintenance_events_config and maintenance_events_config.enabled:
-            self.maintenance_events_pool_handler = MaintenanceEventPoolHandler(
-                self.connection_pool, maintenance_events_config
+        if maint_notifications_config and maint_notifications_config.enabled:
+            self.maint_notifications_pool_handler = MaintNotificationsPoolHandler(
+                self.connection_pool, maint_notifications_config
             )
-            self.connection_pool.set_maintenance_events_pool_handler(
-                self.maintenance_events_pool_handler
+            self.connection_pool.set_maint_notifications_pool_handler(
+                self.maint_notifications_pool_handler
             )
         else:
-            self.maintenance_events_pool_handler = None
+            self.maint_notifications_pool_handler = None
 
         self.single_connection_lock = threading.RLock()
         self.connection = None
@@ -587,15 +587,15 @@ def monitor(self):
         return Monitor(self.connection_pool)
 
     def client(self):
-        maintenance_events_config = (
+        maint_notifications_config = (
             None
-            if self.maintenance_events_pool_handler is None
-            else self.maintenance_events_pool_handler.config
+            if self.maint_notifications_pool_handler is None
+            else self.maint_notifications_pool_handler.config
         )
         return self.__class__(
             connection_pool=self.connection_pool,
             single_connection_client=True,
-            maintenance_events_config=maintenance_events_config,
+            maint_notifications_config=maint_notifications_config,
         )
 
     def __enter__(self):
diff --git a/redis/connection.py b/redis/connection.py
index 226d22539c..e31e946d66 100644
--- a/redis/connection.py
+++ b/redis/connection.py
@@ -48,10 +48,10 @@
     TimeoutError,
 )
 from .maintenance_events import (
-    MaintenanceEventConnectionHandler,
-    MaintenanceEventPoolHandler,
-    MaintenanceEventsConfig,
     MaintenanceState,
+    MaintNotificationsConfig,
+    MaintNotificationsConnectionHandler,
+    MaintNotificationsPoolHandler,
 )
 from .retry import Retry
 from .utils import (
@@ -177,7 +177,7 @@ def set_parser(self, parser_class):
         pass
 
     @abstractmethod
-    def set_maintenance_event_pool_handler(self, maintenance_event_pool_handler):
+    def set_maint_notifications_pool_handler(self, maint_notifications_pool_handler):
         pass
 
     @abstractmethod
@@ -289,7 +289,7 @@ def get_resolved_ip(self):
         pass
 
     @abstractmethod
-    def update_current_socket_timeout(self, relax_timeout: Optional[float] = None):
+    def update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None):
         """
         Update the timeout for the current socket.
         """
@@ -299,7 +299,7 @@ def update_current_socket_timeout(self, relax_timeout: Optional[float] = None):
     def set_tmp_settings(
         self,
         tmp_host_address: Optional[str] = None,
-        tmp_relax_timeout: Optional[float] = None,
+        tmp_relaxed_timeout: Optional[float] = None,
     ):
         """
         Updates temporary host address and timeout settings for the connection.
@@ -310,7 +310,7 @@ def set_tmp_settings(
     def reset_tmp_settings(
         self,
         reset_host_address: bool = False,
-        reset_relax_timeout: bool = False,
+        reset_relaxed_timeout: bool = False,
     ):
         """
         Resets temporary host address and timeout settings for the connection.
@@ -345,10 +345,12 @@ def __init__(
         protocol: Optional[int] = 2,
         command_packer: Optional[Callable[[], None]] = None,
         event_dispatcher: Optional[EventDispatcher] = None,
-        maintenance_events_pool_handler: Optional[MaintenanceEventPoolHandler] = None,
-        maintenance_events_config: Optional[MaintenanceEventsConfig] = None,
+        maint_notifications_pool_handler: Optional[
+            MaintNotificationsPoolHandler
+        ] = None,
+        maint_notifications_config: Optional[MaintNotificationsConfig] = None,
         maintenance_state: "MaintenanceState" = MaintenanceState.NONE,
-        maintenance_event_hash: Optional[int] = None,
+        maintenance_notification_hash: Optional[int] = None,
         orig_host_address: Optional[str] = None,
         orig_socket_timeout: Optional[float] = None,
         orig_socket_connect_timeout: Optional[float] = None,
@@ -428,11 +430,11 @@ def __init__(
             parser_class = _RESP3Parser
         self.set_parser(parser_class)
 
-        self.maintenance_events_config = maintenance_events_config
+        self.maint_notifications_config = maint_notifications_config
 
-        # Set up maintenance events if enabled
-        self._configure_maintenance_events(
-            maintenance_events_pool_handler,
+        # Set up maintenance notifications if enabled
+        self._configure_maintenance_notifications(
+            maint_notifications_pool_handler,
             orig_host_address,
             orig_socket_timeout,
             orig_socket_connect_timeout,
@@ -440,7 +442,7 @@ def __init__(
 
         self._should_reconnect = False
         self.maintenance_state = maintenance_state
-        self.maintenance_event_hash = maintenance_event_hash
+        self.maintenance_notification_hash = maintenance_notification_hash
 
         self._command_packer = self._construct_command_packer(command_packer)
 
@@ -497,33 +499,33 @@ def set_parser(self, parser_class):
         """
         self._parser = parser_class(socket_read_size=self._socket_read_size)
 
-    def _configure_maintenance_events(
+    def _configure_maintenance_notifications(
         self,
-        maintenance_events_pool_handler=None,
+        maint_notifications_pool_handler=None,
         orig_host_address=None,
         orig_socket_timeout=None,
         orig_socket_connect_timeout=None,
     ):
-        """Enable maintenance events by setting up handlers and storing original connection parameters."""
+        """Enable maintenance notifications by setting up handlers and storing original connection parameters."""
         if (
-            not self.maintenance_events_config
-            or not self.maintenance_events_config.enabled
+            not self.maint_notifications_config
+            or not self.maint_notifications_config.enabled
         ):
-            self._maintenance_event_connection_handler = None
+            self._maint_notifications_connection_handler = None
             return
 
         # Set up pool handler if available
-        if maintenance_events_pool_handler:
+        if maint_notifications_pool_handler:
             self._parser.set_node_moving_push_handler(
-                maintenance_events_pool_handler.handle_event
+                maint_notifications_pool_handler.handle_notification
             )
 
         # Set up connection handler
-        self._maintenance_event_connection_handler = MaintenanceEventConnectionHandler(
-            self, self.maintenance_events_config
+        self._maint_notifications_connection_handler = (
+            MaintNotificationsConnectionHandler(self, self.maint_notifications_config)
         )
         self._parser.set_maintenance_push_handler(
-            self._maintenance_event_connection_handler.handle_event
+            self._maint_notifications_connection_handler.handle_notification
         )
 
         # Store original connection parameters
@@ -537,27 +539,27 @@ def _configure_maintenance_events(
             else self.socket_connect_timeout
         )
 
-    def set_maintenance_event_pool_handler(
-        self, maintenance_event_pool_handler: MaintenanceEventPoolHandler
+    def set_maint_notifications_pool_handler(
+        self, maint_notifications_pool_handler: MaintNotificationsPoolHandler
     ):
-        maintenance_event_pool_handler.set_connection(self)
+        maint_notifications_pool_handler.set_connection(self)
         self._parser.set_node_moving_push_handler(
-            maintenance_event_pool_handler.handle_event
+            maint_notifications_pool_handler.handle_notification
         )
 
-        # Update maintenance event connection handler if it doesn't exist
-        if not self._maintenance_event_connection_handler:
-            self._maintenance_event_connection_handler = (
-                MaintenanceEventConnectionHandler(
-                    self, maintenance_event_pool_handler.config
+        # Update maintenance notification connection handler if it doesn't exist
+        if not self._maint_notifications_connection_handler:
+            self._maint_notifications_connection_handler = (
+                MaintNotificationsConnectionHandler(
+                    self, maint_notifications_pool_handler.config
                 )
             )
             self._parser.set_maintenance_push_handler(
-                self._maintenance_event_connection_handler.handle_event
+                self._maint_notifications_connection_handler.handle_notification
             )
         else:
-            self._maintenance_event_connection_handler.config = (
-                maintenance_event_pool_handler.config
+            self._maint_notifications_connection_handler.config = (
+                maint_notifications_pool_handler.config
             )
 
     def connect(self):
@@ -684,17 +686,17 @@ def on_connect_check_health(self, check_health: bool = True):
             ):
                 raise ConnectionError("Invalid RESP version")
 
-        # Send maintenance notifications handshake if RESP3 is active and maintenance events are enabled
+        # Send maintenance notifications handshake if RESP3 is active and maintenance notifications are enabled
         # and we have a host to determine the endpoint type from
         if (
             self.protocol not in [2, "2"]
-            and self.maintenance_events_config
-            and self.maintenance_events_config.enabled
-            and self._maintenance_event_connection_handler
+            and self.maint_notifications_config
+            and self.maint_notifications_config.enabled
+            and self._maint_notifications_connection_handler
             and hasattr(self, "host")
         ):
             try:
-                endpoint_type = self.maintenance_events_config.get_endpoint_type(
+                endpoint_type = self.maint_notifications_config.get_endpoint_type(
                     self.host, self
                 )
                 self.send_command(
@@ -1022,9 +1024,9 @@ def mark_for_reconnect(self):
     def should_reconnect(self):
         return self._should_reconnect
 
-    def update_current_socket_timeout(self, relax_timeout: Optional[float] = None):
+    def update_current_socket_timeout(self, relaxed_timeout: Optional[float] = None):
         if self._sock:
-            timeout = relax_timeout if relax_timeout != -1 else self.socket_timeout
+            timeout = relaxed_timeout if relaxed_timeout != -1 else self.socket_timeout
             self._sock.settimeout(timeout)
             self.update_parser_buffer_timeout(timeout)
 
@@ -1035,25 +1037,25 @@ def update_parser_buffer_timeout(self, timeout: Optional[float] = None):
     def set_tmp_settings(
         self,
         tmp_host_address: Optional[Union[str, object]] = SENTINEL,
-        tmp_relax_timeout: Optional[float] = None,
+        tmp_relaxed_timeout: Optional[float] = None,
     ):
         """
         The value of SENTINEL is used to indicate that the property should not be updated.
         """
         if tmp_host_address is not SENTINEL:
             self.host = tmp_host_address
-        if tmp_relax_timeout != -1:
-            self.socket_timeout = tmp_relax_timeout
-            self.socket_connect_timeout = tmp_relax_timeout
+        if tmp_relaxed_timeout != -1:
+            self.socket_timeout = tmp_relaxed_timeout
+            self.socket_connect_timeout = tmp_relaxed_timeout
 
     def reset_tmp_settings(
         self,
         reset_host_address: bool = False,
-        reset_relax_timeout: bool = False,
+        reset_relaxed_timeout: bool = False,
     ):
         if reset_host_address:
             self.host = self.orig_host_address
-        if reset_relax_timeout:
+        if reset_relaxed_timeout:
             self.socket_timeout = self.orig_socket_timeout
             self.socket_connect_timeout = self.orig_socket_connect_timeout
 
@@ -1742,20 +1744,20 @@ def __init__(
         connection_kwargs.pop("cache_config", None)
 
         if self.connection_kwargs.get(
-            "maintenance_events_pool_handler"
-        ) or self.connection_kwargs.get("maintenance_events_config"):
+            "maint_notifications_pool_handler"
+        ) or self.connection_kwargs.get("maint_notifications_config"):
             if self.connection_kwargs.get("protocol") not in [3, "3"]:
                 raise RedisError(
                     "Push handlers on connection are only supported with RESP version 3"
                 )
-            config = self.connection_kwargs.get("maintenance_events_config", None) or (
-                self.connection_kwargs.get("maintenance_events_pool_handler").config
-                if self.connection_kwargs.get("maintenance_events_pool_handler")
+            config = self.connection_kwargs.get("maint_notifications_config", None) or (
+                self.connection_kwargs.get("maint_notifications_pool_handler").config
+                if self.connection_kwargs.get("maint_notifications_pool_handler")
                 else None
             )
 
             if config and config.enabled:
-                self._update_connection_kwargs_for_maintenance_events()
+                self._update_connection_kwargs_for_maint_notifications()
 
         self._event_dispatcher = self.connection_kwargs.get("event_dispatcher", None)
         if self._event_dispatcher is None:
@@ -1791,46 +1793,54 @@ def get_protocol(self):
         """
         return self.connection_kwargs.get("protocol", None)
 
-    def maintenance_events_pool_handler_enabled(self):
+    def maint_notifications_pool_handler_enabled(self):
         """
         Returns:
-            True if the maintenance events pool handler is enabled, False otherwise.
+            True if the maintenance notifications pool handler is enabled, False otherwise.
         """
-        maintenance_events_config = self.connection_kwargs.get(
-            "maintenance_events_config", None
+        maint_notifications_config = self.connection_kwargs.get(
+            "maint_notifications_config", None
         )
 
-        return maintenance_events_config and maintenance_events_config.enabled
+        return maint_notifications_config and maint_notifications_config.enabled
 
-    def set_maintenance_events_pool_handler(
-        self, maintenance_events_pool_handler: MaintenanceEventPoolHandler
+    def set_maint_notifications_pool_handler(
+        self, maint_notifications_pool_handler: MaintNotificationsPoolHandler
     ):
         self.connection_kwargs.update(
             {
-                "maintenance_events_pool_handler": maintenance_events_pool_handler,
-                "maintenance_events_config": maintenance_events_pool_handler.config,
+                "maint_notifications_pool_handler": maint_notifications_pool_handler,
+                "maint_notifications_config": maint_notifications_pool_handler.config,
             }
         )
-        self._update_connection_kwargs_for_maintenance_events()
+        self._update_connection_kwargs_for_maint_notifications()
 
-        self._update_maintenance_events_configs_for_connections(
-            maintenance_events_pool_handler
+        self._update_maint_notifications_configs_for_connections(
+            maint_notifications_pool_handler
         )
 
-    def _update_maintenance_events_configs_for_connections(
-        self, maintenance_events_pool_handler
+    def _update_maint_notifications_configs_for_connections(
+        self, maint_notifications_pool_handler
     ):
-        """Update the maintenance events config for all connections in the pool."""
+        """Update the maintenance notifications config for all connections in the pool."""
         with self._lock:
             for conn in self._available_connections:
-                conn.set_maintenance_event_pool_handler(maintenance_events_pool_handler)
-                conn.maintenance_events_config = maintenance_events_pool_handler.config
+                conn.set_maint_notifications_pool_handler(
+                    maint_notifications_pool_handler
+                )
+                conn.maint_notifications_config = (
+                    maint_notifications_pool_handler.config
+                )
             for conn in self._in_use_connections:
-                conn.set_maintenance_event_pool_handler(maintenance_events_pool_handler)
-                conn.maintenance_events_config = maintenance_events_pool_handler.config
+                conn.set_maint_notifications_pool_handler(
+                    maint_notifications_pool_handler
+                )
+                conn.maint_notifications_config = (
+                    maint_notifications_pool_handler.config
+                )
 
-    def _update_connection_kwargs_for_maintenance_events(self):
-        """Store original connection parameters for maintenance events."""
+    def _update_connection_kwargs_for_maint_notifications(self):
+        """Store original connection parameters for maintenance notifications."""
         if self.connection_kwargs.get("orig_host_address", None) is None:
             # If orig_host_address is None it means we haven't
             # configured the original values yet
@@ -1936,7 +1946,7 @@ def get_connection(self, command_name=None, *keys, **options) -> "Connection":
                 if (
                     connection.can_read()
                     and self.cache is None
-                    and not self.maintenance_events_pool_handler_enabled()
+                    and not self.maint_notifications_pool_handler_enabled()
                 ):
                     raise ConnectionError("Connection has data")
             except (ConnectionError, TimeoutError, OSError):
@@ -2053,13 +2063,13 @@ def _should_update_connection(
         self,
         conn: "Connection",
         matching_pattern: Literal[
-            "connected_address", "configured_address", "event_hash"
+            "connected_address", "configured_address", "notification_hash"
         ] = "connected_address",
         matching_address: Optional[str] = None,
-        matching_event_hash: Optional[int] = None,
+        matching_notification_hash: Optional[int] = None,
     ) -> bool:
         """
-        Check if the connection should be updated based on the matching address.
+        Check if the connection should be updated based on the matching criteria.
         """
         if matching_pattern == "connected_address":
             if matching_address and conn.getpeername() != matching_address:
@@ -2067,10 +2077,10 @@ def _should_update_connection(
         elif matching_pattern == "configured_address":
             if matching_address and conn.host != matching_address:
                 return False
-        elif matching_pattern == "event_hash":
+        elif matching_pattern == "notification_hash":
             if (
-                matching_event_hash
-                and conn.maintenance_event_hash != matching_event_hash
+                matching_notification_hash
+                and conn.maintenance_notification_hash != matching_notification_hash
             ):
                 return False
         return True
@@ -2079,12 +2089,12 @@ def update_connection_settings(
         self,
         conn: "Connection",
         state: Optional["MaintenanceState"] = None,
-        maintenance_event_hash: Optional[int] = None,
+        maintenance_notification_hash: Optional[int] = None,
         host_address: Optional[str] = None,
-        relax_timeout: Optional[float] = None,
-        update_event_hash: bool = False,
+        relaxed_timeout: Optional[float] = None,
+        update_notification_hash: bool = False,
         reset_host_address: bool = False,
-        reset_relax_timeout: bool = False,
+        reset_relaxed_timeout: bool = False,
     ):
         """
         Update the settings for a single connection.
@@ -2092,38 +2102,38 @@ def update_connection_settings(
         if state:
             conn.maintenance_state = state
 
-        if update_event_hash:
-            # update the event hash only if requested
-            conn.maintenance_event_hash = maintenance_event_hash
+        if update_notification_hash:
+            # update the notification hash only if requested
+            conn.maintenance_notification_hash = maintenance_notification_hash
 
         if host_address is not None:
             conn.set_tmp_settings(tmp_host_address=host_address)
 
-        if relax_timeout is not None:
-            conn.set_tmp_settings(tmp_relax_timeout=relax_timeout)
+        if relaxed_timeout is not None:
+            conn.set_tmp_settings(tmp_relaxed_timeout=relaxed_timeout)
 
-        if reset_relax_timeout or reset_host_address:
+        if reset_relaxed_timeout or reset_host_address:
             conn.reset_tmp_settings(
                 reset_host_address=reset_host_address,
-                reset_relax_timeout=reset_relax_timeout,
+                reset_relaxed_timeout=reset_relaxed_timeout,
             )
 
-        conn.update_current_socket_timeout(relax_timeout)
+        conn.update_current_socket_timeout(relaxed_timeout)
 
     def update_connections_settings(
         self,
         state: Optional["MaintenanceState"] = None,
-        maintenance_event_hash: Optional[int] = None,
+        maintenance_notification_hash: Optional[int] = None,
         host_address: Optional[str] = None,
-        relax_timeout: Optional[float] = None,
+        relaxed_timeout: Optional[float] = None,
         matching_address: Optional[str] = None,
-        matching_event_hash: Optional[int] = None,
+        matching_notification_hash: Optional[int] = None,
         matching_pattern: Literal[
-            "connected_address", "configured_address", "event_hash"
+            "connected_address", "configured_address", "notification_hash"
         ] = "connected_address",
-        update_event_hash: bool = False,
+        update_notification_hash: bool = False,
         reset_host_address: bool = False,
-        reset_relax_timeout: bool = False,
+        reset_relaxed_timeout: bool = False,
         include_free_connections: bool = True,
     ):
         """
@@ -2133,16 +2143,16 @@ def update_connections_settings(
         This method does not affect the connection kwargs.
 
         :param state: The maintenance state to set for the connection.
-        :param maintenance_event_hash: The hash of the maintenance event
-                                        to set for the connection.
+        :param maintenance_notification_hash: The hash of the maintenance notification
+                                               to set for the connection.
         :param host_address: The host address to set for the connection.
-        :param relax_timeout: The relax timeout to set for the connection.
+        :param relaxed_timeout: The relaxed timeout to set for the connection.
         :param matching_address: The address to match for the connection.
-        :param matching_event_hash: The event hash to match for the connection.
+        :param matching_notification_hash: The notification hash to match for the connection.
         :param matching_pattern: The pattern to match for the connection.
-        :param update_event_hash: Whether to update the event hash for the connection.
+        :param update_notification_hash: Whether to update the notification hash for the connection.
         :param reset_host_address: Whether to reset the host address to the original address.
-        :param reset_relax_timeout: Whether to reset the relax timeout to the original timeout.
+        :param reset_relaxed_timeout: Whether to reset the relaxed timeout to the original timeout.
         :param include_free_connections: Whether to include free/available connections.
         """
         with self._lock:
@@ -2151,17 +2161,17 @@ def update_connections_settings(
                     conn,
                     matching_pattern,
                     matching_address,
-                    matching_event_hash,
+                    matching_notification_hash,
                 ):
                     self.update_connection_settings(
                         conn,
                         state=state,
-                        maintenance_event_hash=maintenance_event_hash,
+                        maintenance_notification_hash=maintenance_notification_hash,
                         host_address=host_address,
-                        relax_timeout=relax_timeout,
-                        update_event_hash=update_event_hash,
+                        relaxed_timeout=relaxed_timeout,
+                        update_notification_hash=update_notification_hash,
                         reset_host_address=reset_host_address,
-                        reset_relax_timeout=reset_relax_timeout,
+                        reset_relaxed_timeout=reset_relaxed_timeout,
                     )
 
             if include_free_connections:
@@ -2170,17 +2180,17 @@ def update_connections_settings(
                         conn,
                         matching_pattern,
                         matching_address,
-                        matching_event_hash,
+                        matching_notification_hash,
                     ):
                         self.update_connection_settings(
                             conn,
                             state=state,
-                            maintenance_event_hash=maintenance_event_hash,
+                            maintenance_notification_hash=maintenance_notification_hash,
                             host_address=host_address,
-                            relax_timeout=relax_timeout,
-                            update_event_hash=update_event_hash,
+                            relaxed_timeout=relaxed_timeout,
+                            update_notification_hash=update_notification_hash,
                             reset_host_address=reset_host_address,
-                            reset_relax_timeout=reset_relax_timeout,
+                            reset_relaxed_timeout=reset_relaxed_timeout,
                         )
 
     def update_connection_kwargs(
@@ -2472,17 +2482,17 @@ def disconnect(self):
     def update_connections_settings(
         self,
         state: Optional["MaintenanceState"] = None,
-        maintenance_event_hash: Optional[int] = None,
-        relax_timeout: Optional[float] = None,
+        maintenance_notification_hash: Optional[int] = None,
+        relaxed_timeout: Optional[float] = None,
         host_address: Optional[str] = None,
         matching_address: Optional[str] = None,
-        matching_event_hash: Optional[int] = None,
+        matching_notification_hash: Optional[int] = None,
         matching_pattern: Literal[
-            "connected_address", "configured_address", "event_hash"
+            "connected_address", "configured_address", "notification_hash"
         ] = "connected_address",
-        update_event_hash: bool = False,
+        update_notification_hash: bool = False,
         reset_host_address: bool = False,
-        reset_relax_timeout: bool = False,
+        reset_relaxed_timeout: bool = False,
         include_free_connections: bool = True,
     ):
         """
@@ -2495,17 +2505,17 @@ def update_connections_settings(
                         conn,
                         matching_pattern,
                         matching_address,
-                        matching_event_hash,
+                        matching_notification_hash,
                     ):
                         self.update_connection_settings(
                             conn,
                             state=state,
-                            maintenance_event_hash=maintenance_event_hash,
+                            maintenance_notification_hash=maintenance_notification_hash,
                             host_address=host_address,
-                            relax_timeout=relax_timeout,
-                            update_event_hash=update_event_hash,
+                            relaxed_timeout=relaxed_timeout,
+                            update_notification_hash=update_notification_hash,
                             reset_host_address=reset_host_address,
-                            reset_relax_timeout=reset_relax_timeout,
+                            reset_relaxed_timeout=reset_relaxed_timeout,
                         )
             else:
                 connections_in_queue = {conn for conn in self.pool.queue if conn}
@@ -2515,17 +2525,17 @@ def update_connections_settings(
                             conn,
                             matching_pattern,
                             matching_address,
-                            matching_event_hash,
+                            matching_notification_hash,
                         ):
                             self.update_connection_settings(
                                 conn,
                                 state=state,
-                                maintenance_event_hash=maintenance_event_hash,
+                                maintenance_notification_hash=maintenance_notification_hash,
                                 host_address=host_address,
-                                relax_timeout=relax_timeout,
-                                update_event_hash=update_event_hash,
+                                relaxed_timeout=relaxed_timeout,
+                                update_notification_hash=update_notification_hash,
                                 reset_host_address=reset_host_address,
-                                reset_relax_timeout=reset_relax_timeout,
+                                reset_relaxed_timeout=reset_relaxed_timeout,
                             )
 
     def update_active_connections_for_reconnect(
@@ -2569,26 +2579,30 @@ def disconnect_free_connections(
                     ):
                         conn.disconnect()
 
-    def _update_maintenance_events_config_for_connections(
-        self, maintenance_events_config
+    def _update_maint_notifications_config_for_connections(
+        self, maint_notifications_config
     ):
         for conn in tuple(self._connections):
-            conn.maintenance_events_config = maintenance_events_config
+            conn.maint_notifications_config = maint_notifications_config
 
-    def _update_maintenance_events_configs_for_connections(
-        self, maintenance_events_pool_handler
+    def _update_maint_notifications_configs_for_connections(
+        self, maint_notifications_pool_handler
     ):
-        """Update the maintenance events config for all connections in the pool."""
+        """Update the maintenance notifications config for all connections in the pool."""
         with self._lock:
             for conn in tuple(self._connections):
-                conn.set_maintenance_event_pool_handler(maintenance_events_pool_handler)
-                conn.maintenance_events_config = maintenance_events_pool_handler.config
+                conn.set_maint_notifications_pool_handler(
+                    maint_notifications_pool_handler
+                )
+                conn.maint_notifications_config = (
+                    maint_notifications_pool_handler.config
+                )
 
     def set_in_maintenance(self, in_maintenance: bool):
         """
         Sets a flag that this Blocking ConnectionPool is in maintenance mode.
 
         This is used to prevent new connections from being created while we are in maintenance mode.
-        The pool will be in maintenance mode only when we are processing a MOVING event.
+        The pool will be in maintenance mode only when we are processing a MOVING notification.
         """
         self._in_maintenance = in_maintenance
diff --git a/redis/maintenance_events.py b/redis/maintenance_events.py
index a3636019ed..eeb77299ef 100644
--- a/redis/maintenance_events.py
+++ b/redis/maintenance_events.py
@@ -38,25 +38,25 @@ def __str__(self):
     )
 
 
-class MaintenanceEvent(ABC):
+class MaintenanceNotification(ABC):
     """
-    Base class for maintenance events sent through push messages by Redis server.
+    Base class for maintenance notifications sent through push messages by Redis server.
 
-    This class provides common functionality for all maintenance events including
+    This class provides common functionality for all maintenance notifications including
     unique identification and TTL (Time-To-Live) functionality.
 
     Attributes:
-        id (int): Unique identifier for this event
+        id (int): Unique identifier for this notification
         ttl (int): Time-to-live in seconds for this notification
         creation_time (float): Timestamp when the notification was created/read
     """
 
     def __init__(self, id: int, ttl: int):
         """
-        Initialize a new MaintenanceEvent with unique ID and TTL functionality.
+        Initialize a new MaintenanceNotification with unique ID and TTL functionality.
 
         Args:
-            id (int): Unique identifier for this event
+            id (int): Unique identifier for this notification
             ttl (int): Time-to-live in seconds for this notification
         """
         self.id = id
@@ -66,60 +66,60 @@ def __init__(self, id: int, ttl: int):
 
     def is_expired(self) -> bool:
         """
-        Check if this event has expired based on its TTL
+        Check if this notification has expired based on its TTL
         and creation time.
 
         Returns:
-            bool: True if the event has expired, False otherwise
+            bool: True if the notification has expired, False otherwise
         """
         return time.monotonic() > (self.creation_time + self.ttl)
 
     @abstractmethod
     def __repr__(self) -> str:
         """
-        Return a string representation of the maintenance event.
+        Return a string representation of the maintenance notification.
 
         This method must be implemented by all concrete subclasses.
 
         Returns:
-            str: String representation of the event
+            str: String representation of the notification
         """
         pass
 
     @abstractmethod
     def __eq__(self, other) -> bool:
         """
-        Compare two maintenance events for equality.
+        Compare two maintenance notifications for equality.
 
         This method must be implemented by all concrete subclasses.
-        Events are typically considered equal if they have the same id
+        Notifications are typically considered equal if they have the same id
         and are of the same type.
 
         Args:
             other: The other object to compare with
 
         Returns:
-            bool: True if the events are equal, False otherwise
+            bool: True if the notifications are equal, False otherwise
         """
         pass
 
     @abstractmethod
     def __hash__(self) -> int:
         """
-        Return a hash value for the maintenance event.
+        Return a hash value for the maintenance notification.
 
         This method must be implemented by all concrete subclasses to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value for the event
+            int: Hash value for the notification
         """
         pass
 
 
-class NodeMovingEvent(MaintenanceEvent):
+class NodeMovingNotification(MaintenanceNotification):
     """
-    This event is received when a node is replaced with a new node
+    This notification is received when a node is replaced with a new node
     during cluster rebalancing or maintenance operations.
     """
 
@@ -131,10 +131,10 @@ def __init__(
         ttl: int,
     ):
         """
-        Initialize a new NodeMovingEvent.
+        Initialize a new NodeMovingNotification.
 
         Args:
-            id (int): Unique identifier for this event
+            id (int): Unique identifier for this notification
             new_node_host (str): Hostname or IP address of the new replacement node
             new_node_port (int): Port number of the new replacement node
             ttl (int): Time-to-live in seconds for this notification
@@ -162,10 +162,10 @@ def __repr__(self) -> str:
 
     def __eq__(self, other) -> bool:
         """
-        Two NodeMovingEvent events are considered equal if they have the same
+        Two NodeMovingNotification notifications are considered equal if they have the same
         id, new_node_host, and new_node_port.
         """
-        if not isinstance(other, NodeMovingEvent):
+        if not isinstance(other, NodeMovingNotification):
             return False
         return (
             self.id == other.id
@@ -175,11 +175,11 @@ def __eq__(self, other) -> bool:
 
     def __hash__(self) -> int:
         """
-        Return a hash value for the event to allow
+        Return a hash value for the notification to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value based on event type class name, id,
+            int: Hash value based on notification type class name, id,
             new_node_host and new_node_port
         """
         try:
@@ -197,15 +197,15 @@ def __hash__(self) -> int:
         )
 
 
-class NodeMigratingEvent(MaintenanceEvent):
+class NodeMigratingNotification(MaintenanceNotification):
     """
-    Event for when a Redis cluster node is in the process of migrating slots.
+    Notification for when a Redis cluster node is in the process of migrating slots.
 
-    This event is received when a node starts migrating its slots to another node
+    This notification is received when a node starts migrating its slots to another node
     during cluster rebalancing or maintenance operations.
 
     Args:
-        id (int): Unique identifier for this event
+        id (int): Unique identifier for this notification
         ttl (int): Time-to-live in seconds for this notification
     """
 
@@ -228,39 +228,39 @@ def __repr__(self) -> str:
 
     def __eq__(self, other) -> bool:
         """
-        Two NodeMigratingEvent events are considered equal if they have the same
+        Two NodeMigratingNotification notifications are considered equal if they have the same
         id and are of the same type.
         """
-        if not isinstance(other, NodeMigratingEvent):
+        if not isinstance(other, NodeMigratingNotification):
             return False
         return self.id == other.id and type(self) is type(other)
 
     def __hash__(self) -> int:
         """
-        Return a hash value for the event to allow
+        Return a hash value for the notification to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value based on event type and id
+            int: Hash value based on notification type and id
         """
         return hash((self.__class__.__name__, int(self.id)))
 
 
-class NodeMigratedEvent(MaintenanceEvent):
+class NodeMigratedNotification(MaintenanceNotification):
     """
-    Event for when a Redis cluster node has completed migrating slots.
+    Notification for when a Redis cluster node has completed migrating slots.
 
-    This event is received when a node has finished migrating all its slots
+    This notification is received when a node has finished migrating all its slots
     to other nodes during cluster rebalancing or maintenance operations.
 
     Args:
-        id (int): Unique identifier for this event
+        id (int): Unique identifier for this notification
     """
 
     DEFAULT_TTL = 5
 
     def __init__(self, id: int):
-        super().__init__(id, NodeMigratedEvent.DEFAULT_TTL)
+        super().__init__(id, NodeMigratedNotification.DEFAULT_TTL)
 
     def __repr__(self) -> str:
         expiry_time = self.creation_time + self.ttl
@@ -278,33 +278,33 @@ def __repr__(self) -> str:
 
     def __eq__(self, other) -> bool:
         """
-        Two NodeMigratedEvent events are considered equal if they have the same
+        Two NodeMigratedNotification notifications are considered equal if they have the same
         id and are of the same type.
         """
-        if not isinstance(other, NodeMigratedEvent):
+        if not isinstance(other, NodeMigratedNotification):
             return False
         return self.id == other.id and type(self) is type(other)
 
     def __hash__(self) -> int:
         """
-        Return a hash value for the event to allow
+        Return a hash value for the notification to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value based on event type and id
+            int: Hash value based on notification type and id
         """
         return hash((self.__class__.__name__, int(self.id)))
 
 
-class NodeFailingOverEvent(MaintenanceEvent):
+class NodeFailingOverNotification(MaintenanceNotification):
     """
-    Event for when a Redis cluster node is in the process of failing over.
+    Notification for when a Redis cluster node is in the process of failing over.
 
-    This event is received when a node starts a failover process during
+    This notification is received when a node starts a failover process during
     cluster maintenance operations or when handling node failures.
 
     Args:
-        id (int): Unique identifier for this event
+        id (int): Unique identifier for this notification
         ttl (int): Time-to-live in seconds for this notification
     """
 
@@ -327,39 +327,39 @@ def __repr__(self) -> str:
 
     def __eq__(self, other) -> bool:
         """
-        Two NodeFailingOverEvent events are considered equal if they have the same
+        Two NodeFailingOverNotification notifications are considered equal if they have the same
         id and are of the same type.
         """
-        if not isinstance(other, NodeFailingOverEvent):
+        if not isinstance(other, NodeFailingOverNotification):
             return False
         return self.id == other.id and type(self) is type(other)
 
     def __hash__(self) -> int:
         """
-        Return a hash value for the event to allow
+        Return a hash value for the notification to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value based on event type and id
+            int: Hash value based on notification type and id
         """
         return hash((self.__class__.__name__, int(self.id)))
 
 
-class NodeFailedOverEvent(MaintenanceEvent):
+class NodeFailedOverNotification(MaintenanceNotification):
     """
-    Event for when a Redis cluster node has completed a failover.
+    Notification for when a Redis cluster node has completed a failover.
 
-    This event is received when a node has finished the failover process
+    This notification is received when a node has finished the failover process
     during cluster maintenance operations or after handling node failures.
 
     Args:
-        id (int): Unique identifier for this event
+        id (int): Unique identifier for this notification
     """
 
     DEFAULT_TTL = 5
 
     def __init__(self, id: int):
-        super().__init__(id, NodeFailedOverEvent.DEFAULT_TTL)
+        super().__init__(id, NodeFailedOverNotification.DEFAULT_TTL)
 
     def __repr__(self) -> str:
         expiry_time = self.creation_time + self.ttl
@@ -377,20 +377,20 @@ def __repr__(self) -> str:
 
     def __eq__(self, other) -> bool:
         """
-        Two NodeFailedOverEvent events are considered equal if they have the same
+        Two NodeFailedOverNotification notifications are considered equal if they have the same
         id and are of the same type.
         """
-        if not isinstance(other, NodeFailedOverEvent):
+        if not isinstance(other, NodeFailedOverNotification):
             return False
         return self.id == other.id and type(self) is type(other)
 
     def __hash__(self) -> int:
         """
-        Return a hash value for the event to allow
+        Return a hash value for the notification to allow
         instances to be used in sets and as dictionary keys.
 
         Returns:
-            int: Hash value based on event type and id
+            int: Hash value based on notification type and id
         """
         return hash((self.__class__.__name__, int(self.id)))
 
@@ -435,9 +435,9 @@ def _is_private_fqdn(host: str) -> bool:
     return False
 
 
-class MaintenanceEventsConfig:
+class MaintNotificationsConfig:
     """
-    Configuration class for maintenance events handling behaviour. Events are received through
+    Configuration class for maintenance notifications handling behaviour. Notifications are received through
     push notifications.
 
     This class defines how the Redis client should react to different push notifications
@@ -449,19 +449,19 @@ def __init__(
         self,
         enabled: bool = True,
         proactive_reconnect: bool = True,
-        relax_timeout: Optional[Number] = 10,
+        relaxed_timeout: Optional[Number] = 10,
         endpoint_type: Optional[EndpointType] = None,
     ):
         """
-        Initialize a new MaintenanceEventsConfig.
+        Initialize a new MaintNotificationsConfig.
 
         Args:
-            enabled (bool): Whether to enable maintenance events handling.
+            enabled (bool): Whether to enable maintenance notifications handling.
                 Defaults to False.
             proactive_reconnect (bool): Whether to proactively reconnect when a node is replaced.
                 Defaults to True.
-            relax_timeout (Number): The relax timeout to use for the connection during maintenance.
-                If -1 is provided - the relax timeout is disabled. Defaults to 20.
+            relaxed_timeout (Number): The relaxed timeout to use for the connection during maintenance.
+                If -1 is provided - the relaxed timeout is disabled. Defaults to 20.
             endpoint_type (Optional[EndpointType]): Override for the endpoint type to use in CLIENT MAINT_NOTIFICATIONS.
                 If None, the endpoint type will be automatically determined based on the host and TLS configuration.
                 Defaults to None.
@@ -470,7 +470,7 @@ def __init__(
             ValueError: If endpoint_type is provided but is not a valid endpoint type.
         """
         self.enabled = enabled
-        self.relax_timeout = relax_timeout
+        self.relaxed_timeout = relaxed_timeout
         self.proactive_reconnect = proactive_reconnect
         self.endpoint_type = endpoint_type
 
@@ -479,21 +479,21 @@ def __repr__(self) -> str:
             f"{self.__class__.__name__}("
             f"enabled={self.enabled}, "
             f"proactive_reconnect={self.proactive_reconnect}, "
-            f"relax_timeout={self.relax_timeout}, "
+            f"relaxed_timeout={self.relaxed_timeout}, "
             f"endpoint_type={self.endpoint_type!r}"
             f")"
         )
 
-    def is_relax_timeouts_enabled(self) -> bool:
+    def is_relaxed_timeouts_enabled(self) -> bool:
         """
-        Check if the relax_timeout is enabled. The '-1' value is used to disable the relax_timeout.
-        If relax_timeout is set to None, it will make the operation blocking
+        Check if the relaxed_timeout is enabled. The '-1' value is used to disable the relaxed_timeout.
+        If relaxed_timeout is set to None, it will make the operation blocking
         and waiting until any response is received.
 
         Returns:
-            True if the relax_timeout is enabled, False otherwise.
+            True if the relaxed_timeout is enabled, False otherwise.
         """
-        return self.relax_timeout != -1
+        return self.relaxed_timeout != -1
 
     def get_endpoint_type(
         self, host: str, connection: "ConnectionInterface"
@@ -550,15 +550,15 @@ def get_endpoint_type(
         return EndpointType.INTERNAL_FQDN if is_private else EndpointType.EXTERNAL_FQDN
 
 
-class MaintenanceEventPoolHandler:
+class MaintNotificationsPoolHandler:
     def __init__(
         self,
         pool: Union["ConnectionPool", "BlockingConnectionPool"],
-        config: MaintenanceEventsConfig,
+        config: MaintNotificationsConfig,
     ) -> None:
         self.pool = pool
         self.config = config
-        self._processed_events = set()
+        self._processed_notifications = set()
         self._lock = threading.RLock()
         self.connection = None
 
@@ -567,35 +567,35 @@ def set_connection(self, connection: "ConnectionInterface"):
 
     def remove_expired_notifications(self):
         with self._lock:
-            for notification in tuple(self._processed_events):
+            for notification in tuple(self._processed_notifications):
                 if notification.is_expired():
-                    self._processed_events.remove(notification)
+                    self._processed_notifications.remove(notification)
 
-    def handle_event(self, notification: MaintenanceEvent):
+    def handle_notification(self, notification: MaintenanceNotification):
         self.remove_expired_notifications()
 
-        if isinstance(notification, NodeMovingEvent):
-            return self.handle_node_moving_event(notification)
+        if isinstance(notification, NodeMovingNotification):
+            return self.handle_node_moving_notification(notification)
         else:
             logging.error(f"Unhandled notification type: {notification}")
 
-    def handle_node_moving_event(self, event: NodeMovingEvent):
+    def handle_node_moving_notification(self, notification: NodeMovingNotification):
         if (
             not self.config.proactive_reconnect
-            and not self.config.is_relax_timeouts_enabled()
+            and not self.config.is_relaxed_timeouts_enabled()
         ):
             return
         with self._lock:
-            if event in self._processed_events:
+            if notification in self._processed_notifications:
                 # nothing to do in the connection pool handling
-                # the event has already been handled or is expired
+                # the notification has already been handled or is expired
                 # just return
                 return
 
             with self.pool._lock:
                 if (
                     self.config.proactive_reconnect
-                    or self.config.is_relax_timeouts_enabled()
+                    or self.config.is_relaxed_timeouts_enabled()
                 ):
                     # Get the current connected address - if any
                     # This is the address that is being moved
@@ -614,21 +614,21 @@ def handle_node_moving_event(self, event: NodeMovingEvent):
                     # connection settings for matching connections
                     self.pool.update_connections_settings(
                         state=MaintenanceState.MOVING,
-                        maintenance_event_hash=hash(event),
-                        relax_timeout=self.config.relax_timeout,
-                        host_address=event.new_node_host,
+                        maintenance_notification_hash=hash(notification),
+                        relaxed_timeout=self.config.relaxed_timeout,
+                        host_address=notification.new_node_host,
                         matching_address=moving_address_src,
                         matching_pattern="connected_address",
-                        update_event_hash=True,
+                        update_notification_hash=True,
                         include_free_connections=True,
                     )
 
                     if self.config.proactive_reconnect:
-                        if event.new_node_host is not None:
+                        if notification.new_node_host is not None:
                             self.run_proactive_reconnect(moving_address_src)
                         else:
                             threading.Timer(
-                                event.ttl / 2,
+                                notification.ttl / 2,
                                 self.run_proactive_reconnect,
                                 args=(moving_address_src,),
                             ).start()
@@ -639,22 +639,22 @@ def handle_node_moving_event(self, event: NodeMovingEvent):
                     # if relax timeouts are enabled - update timeouts
                     kwargs: dict = {
                         "maintenance_state": MaintenanceState.MOVING,
-                        "maintenance_event_hash": hash(event),
+                        "maintenance_notification_hash": hash(notification),
                     }
-                    if event.new_node_host is not None:
+                    if notification.new_node_host is not None:
                         # the host is not updated if the new node host is None
                         # this happens when the MOVING push notification does not contain
                         # the new node host - in this case we only update the timeouts
                         kwargs.update(
                             {
-                                "host": event.new_node_host,
+                                "host": notification.new_node_host,
                             }
                         )
-                    if self.config.is_relax_timeouts_enabled():
+                    if self.config.is_relaxed_timeouts_enabled():
                         kwargs.update(
                             {
-                                "socket_timeout": self.config.relax_timeout,
-                                "socket_connect_timeout": self.config.relax_timeout,
+                                "socket_timeout": self.config.relaxed_timeout,
+                                "socket_connect_timeout": self.config.relaxed_timeout,
                             }
                         )
                     self.pool.update_connection_kwargs(**kwargs)
@@ -663,10 +663,12 @@ def handle_node_moving_event(self, event: NodeMovingEvent):
                         self.pool.set_in_maintenance(False)
 
             threading.Timer(
-                event.ttl, self.handle_node_moved_event, args=(event,)
+                notification.ttl,
+                self.handle_node_moved_notification,
+                args=(notification,),
             ).start()
 
-            self._processed_events.add(event)
+            self._processed_notifications.add(notification)
 
     def run_proactive_reconnect(self, moving_address_src: Optional[str] = None):
         """
@@ -687,17 +689,20 @@ def run_proactive_reconnect(self, moving_address_src: Optional[str] = None):
                     moving_address_src=moving_address_src,
                 )
 
-    def handle_node_moved_event(self, event: NodeMovingEvent):
+    def handle_node_moved_notification(self, notification: NodeMovingNotification):
         """
-        Handle the cleanup after a node moving event expires.
+        Handle the cleanup after a node moving notification expires.
         """
-        event_hash = hash(event)
+        notification_hash = hash(notification)
 
         with self._lock:
-            # if the current maintenance_event_hash in kwargs is not matching the event
-            # it means there has been a new moving event after this one
+            # if the current maintenance_notification_hash in kwargs is not matching the notification
+            # it means there has been a new moving notification after this one
             # and we don't need to revert the kwargs yet
-            if self.pool.connection_kwargs.get("maintenance_event_hash") == event_hash:
+            if (
+                self.pool.connection_kwargs.get("maintenance_notification_hash")
+                == notification_hash
+            ):
                 orig_host = self.pool.connection_kwargs.get("orig_host_address")
                 orig_socket_timeout = self.pool.connection_kwargs.get(
                     "orig_socket_timeout"
@@ -707,7 +712,7 @@ def handle_node_moved_event(self, event: NodeMovingEvent):
                 )
                 kwargs: dict = {
                     "maintenance_state": MaintenanceState.NONE,
-                    "maintenance_event_hash": None,
+                    "maintenance_notification_hash": None,
                     "host": orig_host,
                     "socket_timeout": orig_socket_timeout,
                     "socket_connect_timeout": orig_connect_timeout,
@@ -715,71 +720,75 @@ def handle_node_moved_event(self, event: NodeMovingEvent):
                 self.pool.update_connection_kwargs(**kwargs)
 
             with self.pool._lock:
-                reset_relax_timeout = self.config.is_relax_timeouts_enabled()
+                reset_relaxed_timeout = self.config.is_relaxed_timeouts_enabled()
                 reset_host_address = self.config.proactive_reconnect
 
                 self.pool.update_connections_settings(
-                    relax_timeout=-1,
+                    relaxed_timeout=-1,
                     state=MaintenanceState.NONE,
-                    maintenance_event_hash=None,
-                    matching_event_hash=event_hash,
-                    matching_pattern="event_hash",
-                    update_event_hash=True,
-                    reset_relax_timeout=reset_relax_timeout,
+                    maintenance_notification_hash=None,
+                    matching_notification_hash=notification_hash,
+                    matching_pattern="notification_hash",
+                    update_notification_hash=True,
+                    reset_relaxed_timeout=reset_relaxed_timeout,
                     reset_host_address=reset_host_address,
                     include_free_connections=True,
                 )
 
 
-class MaintenanceEventConnectionHandler:
-    # 1 = "starting maintenance" events, 0 = "completed maintenance" events
-    _EVENT_TYPES: dict[type["MaintenanceEvent"], int] = {
-        NodeMigratingEvent: 1,
-        NodeFailingOverEvent: 1,
-        NodeMigratedEvent: 0,
-        NodeFailedOverEvent: 0,
+class MaintNotificationsConnectionHandler:
+    # 1 = "starting maintenance" notifications, 0 = "completed maintenance" notifications
+    _NOTIFICATION_TYPES: dict[type["MaintenanceNotification"], int] = {
+        NodeMigratingNotification: 1,
+        NodeFailingOverNotification: 1,
+        NodeMigratedNotification: 0,
+        NodeFailedOverNotification: 0,
     }
 
     def __init__(
-        self, connection: "ConnectionInterface", config: MaintenanceEventsConfig
+        self, connection: "ConnectionInterface", config: MaintNotificationsConfig
     ) -> None:
         self.connection = connection
         self.config = config
 
-    def handle_event(self, event: MaintenanceEvent):
-        # get the event type by checking its class in the _EVENT_TYPES dict
-        event_type = self._EVENT_TYPES.get(event.__class__, None)
+    def handle_notification(self, notification: MaintenanceNotification):
+        # get the notification type by checking its class in the _NOTIFICATION_TYPES dict
+        notification_type = self._NOTIFICATION_TYPES.get(notification.__class__, None)
 
-        if event_type is None:
-            logging.error(f"Unhandled event type: {event}")
+        if notification_type is None:
+            logging.error(f"Unhandled notification type: {notification}")
             return
 
-        if event_type:
-            self.handle_maintenance_start_event(MaintenanceState.MAINTENANCE)
+        if notification_type:
+            self.handle_maintenance_start_notification(MaintenanceState.MAINTENANCE)
         else:
-            self.handle_maintenance_completed_event()
+            self.handle_maintenance_completed_notification()
 
-    def handle_maintenance_start_event(self, maintenance_state: MaintenanceState):
+    def handle_maintenance_start_notification(
+        self, maintenance_state: MaintenanceState
+    ):
         if (
             self.connection.maintenance_state == MaintenanceState.MOVING
-            or not self.config.is_relax_timeouts_enabled()
+            or not self.config.is_relaxed_timeouts_enabled()
         ):
             return
 
         self.connection.maintenance_state = maintenance_state
-        self.connection.set_tmp_settings(tmp_relax_timeout=self.config.relax_timeout)
+        self.connection.set_tmp_settings(
+            tmp_relaxed_timeout=self.config.relaxed_timeout
+        )
         # extend the timeout for all created connections
-        self.connection.update_current_socket_timeout(self.config.relax_timeout)
+        self.connection.update_current_socket_timeout(self.config.relaxed_timeout)
 
-    def handle_maintenance_completed_event(self):
-        # Only reset timeouts if state is not MOVING and relax timeouts are enabled
+    def handle_maintenance_completed_notification(self):
+        # Only reset timeouts if state is not MOVING and relaxed timeouts are enabled
         if (
             self.connection.maintenance_state == MaintenanceState.MOVING
-            or not self.config.is_relax_timeouts_enabled()
+            or not self.config.is_relaxed_timeouts_enabled()
         ):
             return
-        self.connection.reset_tmp_settings(reset_relax_timeout=True)
+        self.connection.reset_tmp_settings(reset_relaxed_timeout=True)
         # Maintenance completed - reset the connection
-        # timeouts by providing -1 as the relax timeout
+        # timeouts by providing -1 as the relaxed timeout
         self.connection.update_current_socket_timeout(-1)
         self.connection.maintenance_state = MaintenanceState.NONE
diff --git a/tests/test_maintenance_events.py b/tests/test_maintenance_events.py
index 69bdad2947..60a85c7bea 100644
--- a/tests/test_maintenance_events.py
+++ b/tests/test_maintenance_events.py
@@ -5,39 +5,39 @@
 from redis.connection import ConnectionInterface
 
 from redis.maintenance_events import (
-    MaintenanceEvent,
-    NodeMovingEvent,
-    NodeMigratingEvent,
-    NodeMigratedEvent,
-    NodeFailingOverEvent,
-    NodeFailedOverEvent,
-    MaintenanceEventsConfig,
-    MaintenanceEventPoolHandler,
-    MaintenanceEventConnectionHandler,
+    MaintenanceNotification,
+    NodeMovingNotification,
+    NodeMigratingNotification,
+    NodeMigratedNotification,
+    NodeFailingOverNotification,
+    NodeFailedOverNotification,
+    MaintNotificationsConfig,
+    MaintNotificationsPoolHandler,
+    MaintNotificationsConnectionHandler,
     MaintenanceState,
     EndpointType,
 )
 
 
-class TestMaintenanceEvent:
-    """Test the base MaintenanceEvent class functionality through concrete subclasses."""
+class TestMaintenanceNotification:
+    """Test the base MaintenanceNotification class functionality through concrete subclasses."""
 
     def test_abstract_class_cannot_be_instantiated(self):
-        """Test that MaintenanceEvent cannot be instantiated directly."""
+        """Test that MaintenanceNotification cannot be instantiated directly."""
         with patch("time.monotonic", return_value=1000):
             with pytest.raises(TypeError):
-                MaintenanceEvent(id=1, ttl=10)  # type: ignore
+                MaintenanceNotification(id=1, ttl=10)  # type: ignore
 
     def test_init_through_subclass(self):
-        """Test MaintenanceEvent initialization through concrete subclass."""
+        """Test MaintenanceNotification initialization through concrete subclass."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeMovingEvent(
+            notification = NodeMovingNotification(
                 id=1, new_node_host="localhost", new_node_port=6379, ttl=10
             )
-            assert event.id == 1
-            assert event.ttl == 10
-            assert event.creation_time == 1000
-            assert event.expire_at == 1010
+            assert notification.id == 1
+            assert notification.ttl == 10
+            assert notification.creation_time == 1000
+            assert notification.expire_at == 1010
 
     @pytest.mark.parametrize(
         ("current_time", "expected_expired_state"),
@@ -47,54 +47,54 @@ def test_init_through_subclass(self):
         ],
     )
     def test_is_expired(self, current_time, expected_expired_state):
-        """Test is_expired returns False for non-expired event."""
+        """Test is_expired returns False for non-expired notification."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeMovingEvent(
+            notification = NodeMovingNotification(
                 id=1, new_node_host="localhost", new_node_port=6379, ttl=10
             )
 
         with patch("time.monotonic", return_value=current_time):
-            assert event.is_expired() == expected_expired_state
+            assert notification.is_expired() == expected_expired_state
 
     def test_is_expired_exact_boundary(self):
         """Test is_expired at exact expiration boundary."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeMovingEvent(
+            notification = NodeMovingNotification(
                 id=1, new_node_host="localhost", new_node_port=6379, ttl=10
             )
 
         with patch("time.monotonic", return_value=1010):  # Exactly at expiration
-            assert not event.is_expired()
+            assert not notification.is_expired()
 
         with patch("time.monotonic", return_value=1011):  # 1 second past expiration
-            assert event.is_expired()
+            assert notification.is_expired()
 
 
-class TestNodeMovingEvent:
-    """Test the NodeMovingEvent class."""
+class TestNodeMovingNotification:
+    """Test the NodeMovingNotification class."""
 
     def test_init(self):
-        """Test NodeMovingEvent initialization."""
+        """Test NodeMovingNotification initialization."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeMovingEvent(
+            notification = NodeMovingNotification(
                 id=1, new_node_host="localhost", new_node_port=6379, ttl=10
             )
-            assert event.id == 1
-            assert event.new_node_host == "localhost"
-            assert event.new_node_port == 6379
-            assert event.ttl == 10
-            assert event.creation_time == 1000
+            assert notification.id == 1
+            assert notification.new_node_host == "localhost"
+            assert notification.new_node_port == 6379
+            assert notification.ttl == 10
+            assert notification.creation_time == 1000
 
     def test_repr(self):
-        """Test NodeMovingEvent string representation."""
+        """Test NodeMovingNotification string representation."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeMovingEvent(
+            notification = NodeMovingNotification(
                 id=1, new_node_host="localhost", new_node_port=6379, ttl=10
             )
 
         with patch("time.monotonic", return_value=1005):  # 5 seconds later
-            repr_str = repr(event)
-            assert "NodeMovingEvent" in repr_str
+            repr_str = repr(notification)
+            assert "NodeMovingNotification" in repr_str
             assert "id=1" in repr_str
             assert "new_node_host='localhost'" in repr_str
             assert "new_node_port=6379" in repr_str
@@ -103,334 +103,342 @@ def test_repr(self):
             assert "expired=False" in repr_str
 
     def test_equality_none_id_none_port(self):
-        """Test equality for events with same id and host and port - None."""
-        event1 = NodeMovingEvent(id=1, new_node_host=None, new_node_port=None, ttl=10)
-        event2 = NodeMovingEvent(
+        """Test equality for notifications with same id and host and port - None."""
+        notification1 = NodeMovingNotification(
+            id=1, new_node_host=None, new_node_port=None, ttl=10
+        )
+        notification2 = NodeMovingNotification(
             id=1, new_node_host=None, new_node_port=None, ttl=20
         )  # Different TTL
-        assert event1 == event2
+        assert notification1 == notification2
 
     def test_equality_same_id_host_port(self):
-        """Test equality for events with same id, host, and port."""
-        event1 = NodeMovingEvent(
+        """Test equality for notifications with same id, host, and port."""
+        notification1 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
-        event2 = NodeMovingEvent(
+        notification2 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=20
         )  # Different TTL
-        assert event1 == event2
+        assert notification1 == notification2
 
     def test_equality_same_id_different_host(self):
-        """Test inequality for events with same id but different host."""
-        event1 = NodeMovingEvent(
+        """Test inequality for notifications with same id but different host."""
+        notification1 = NodeMovingNotification(
             id=1, new_node_host="host1", new_node_port=6379, ttl=10
         )
-        event2 = NodeMovingEvent(
+        notification2 = NodeMovingNotification(
             id=1, new_node_host="host2", new_node_port=6379, ttl=10
         )
-        assert event1 != event2
+        assert notification1 != notification2
 
     def test_equality_same_id_different_port(self):
-        """Test inequality for events with same id but different port."""
-        event1 = NodeMovingEvent(
+        """Test inequality for notifications with same id but different port."""
+        notification1 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
-        event2 = NodeMovingEvent(
+        notification2 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6380, ttl=10
         )
-        assert event1 != event2
+        assert notification1 != notification2
 
     def test_equality_different_id(self):
-        """Test inequality for events with different id."""
-        event1 = NodeMovingEvent(
+        """Test inequality for notifications with different id."""
+        notification1 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
-        event2 = NodeMovingEvent(
+        notification2 = NodeMovingNotification(
             id=2, new_node_host="localhost", new_node_port=6379, ttl=10
         )
-        assert event1 != event2
+        assert notification1 != notification2
 
     def test_equality_different_type(self):
-        """Test inequality for events of different types."""
-        event1 = NodeMovingEvent(
+        """Test inequality for notifications of different types."""
+        notification1 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
-        event2 = NodeMigratingEvent(id=1, ttl=10)
-        assert event1 != event2
+        notification2 = NodeMigratingNotification(id=1, ttl=10)
+        assert notification1 != notification2
 
     def test_hash_same_id_host_port(self):
-        """Test hash consistency for events with same id, host, and port."""
-        event1 = NodeMovingEvent(
+        """Test hash consistency for notifications with same id, host, and port."""
+        notification1 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
-        event2 = NodeMovingEvent(
+        notification2 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=20
         )  # Different TTL
-        assert hash(event1) == hash(event2)
+        assert hash(notification1) == hash(notification2)
 
     def test_hash_different_host(self):
-        """Test hash difference for events with different host."""
-        event1 = NodeMovingEvent(
+        """Test hash difference for notifications with different host."""
+        notification1 = NodeMovingNotification(
             id=1, new_node_host="host1", new_node_port=6379, ttl=10
         )
-        event2 = NodeMovingEvent(
+        notification2 = NodeMovingNotification(
             id=1, new_node_host="host2", new_node_port=6379, ttl=10
         )
-        assert hash(event1) != hash(event2)
+        assert hash(notification1) != hash(notification2)
 
     def test_hash_different_port(self):
-        """Test hash difference for events with different port."""
-        event1 = NodeMovingEvent(
+        """Test hash difference for notifications with different port."""
+        notification1 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
-        event2 = NodeMovingEvent(
+        notification2 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6380, ttl=10
         )
-        assert hash(event1) != hash(event2)
+        assert hash(notification1) != hash(notification2)
 
     def test_hash_different_id(self):
-        """Test hash difference for events with different id."""
-        event1 = NodeMovingEvent(
+        """Test hash difference for notifications with different id."""
+        notification1 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
-        event2 = NodeMovingEvent(
+        notification2 = NodeMovingNotification(
             id=2, new_node_host="localhost", new_node_port=6379, ttl=10
         )
-        assert hash(event1) != hash(event2)
+        assert hash(notification1) != hash(notification2)
 
     def test_set_functionality(self):
-        """Test that events can be used in sets correctly."""
-        event1 = NodeMovingEvent(
+        """Test that notifications can be used in sets correctly."""
+        notification1 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
-        event2 = NodeMovingEvent(
+        notification2 = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=20
         )  # Same id, host, port - should be considered the same
-        event3 = NodeMovingEvent(
+        notification3 = NodeMovingNotification(
             id=1, new_node_host="host2", new_node_port=6380, ttl=10
         )  # Same id but different host/port - should be different
-        event4 = NodeMovingEvent(
+        notification4 = NodeMovingNotification(
             id=2, new_node_host="localhost", new_node_port=6379, ttl=10
         )  # Different id - should be different
 
-        event_set = {event1, event2, event3, event4}
-        assert len(event_set) == 3  # event1 and event2 should be considered the same
+        notification_set = {notification1, notification2, notification3, notification4}
+        assert (
+            len(notification_set) == 3
+        )  # notification1 and notification2 should be considered the same
 
 
-class TestNodeMigratingEvent:
-    """Test the NodeMigratingEvent class."""
+class TestNodeMigratingNotification:
+    """Test the NodeMigratingNotification class."""
 
     def test_init(self):
-        """Test NodeMigratingEvent initialization."""
+        """Test NodeMigratingNotification initialization."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeMigratingEvent(id=1, ttl=5)
-            assert event.id == 1
-            assert event.ttl == 5
-            assert event.creation_time == 1000
+            notification = NodeMigratingNotification(id=1, ttl=5)
+            assert notification.id == 1
+            assert notification.ttl == 5
+            assert notification.creation_time == 1000
 
     def test_repr(self):
-        """Test NodeMigratingEvent string representation."""
+        """Test NodeMigratingNotification string representation."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeMigratingEvent(id=1, ttl=5)
+            notification = NodeMigratingNotification(id=1, ttl=5)
 
         with patch("time.monotonic", return_value=1002):  # 2 seconds later
-            repr_str = repr(event)
-            assert "NodeMigratingEvent" in repr_str
+            repr_str = repr(notification)
+            assert "NodeMigratingNotification" in repr_str
             assert "id=1" in repr_str
             assert "ttl=5" in repr_str
             assert "remaining=3.0s" in repr_str
             assert "expired=False" in repr_str
 
     def test_equality_and_hash(self):
-        """Test equality and hash for NodeMigratingEvent."""
-        event1 = NodeMigratingEvent(id=1, ttl=5)
-        event2 = NodeMigratingEvent(id=1, ttl=10)  # Same id, different ttl
-        event3 = NodeMigratingEvent(id=2, ttl=5)  # Different id
+        """Test equality and hash for NodeMigratingNotification."""
+        notification1 = NodeMigratingNotification(id=1, ttl=5)
+        notification2 = NodeMigratingNotification(
+            id=1, ttl=10
+        )  # Same id, different ttl
+        notification3 = NodeMigratingNotification(id=2, ttl=5)  # Different id
 
-        assert event1 == event2
-        assert event1 != event3
-        assert hash(event1) == hash(event2)
-        assert hash(event1) != hash(event3)
+        assert notification1 == notification2
+        assert notification1 != notification3
+        assert hash(notification1) == hash(notification2)
+        assert hash(notification1) != hash(notification3)
 
 
-class TestNodeMigratedEvent:
-    """Test the NodeMigratedEvent class."""
+class TestNodeMigratedNotification:
+    """Test the NodeMigratedNotification class."""
 
     def test_init(self):
-        """Test NodeMigratedEvent initialization."""
+        """Test NodeMigratedNotification initialization."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeMigratedEvent(id=1)
-            assert event.id == 1
-            assert event.ttl == NodeMigratedEvent.DEFAULT_TTL
-            assert event.creation_time == 1000
+            notification = NodeMigratedNotification(id=1)
+            assert notification.id == 1
+            assert notification.ttl == NodeMigratedNotification.DEFAULT_TTL
+            assert notification.creation_time == 1000
 
     def test_default_ttl(self):
         """Test that DEFAULT_TTL is used correctly."""
-        assert NodeMigratedEvent.DEFAULT_TTL == 5
-        event = NodeMigratedEvent(id=1)
-        assert event.ttl == 5
+        assert NodeMigratedNotification.DEFAULT_TTL == 5
+        notification = NodeMigratedNotification(id=1)
+        assert notification.ttl == 5
 
     def test_repr(self):
-        """Test NodeMigratedEvent string representation."""
+        """Test NodeMigratedNotification string representation."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeMigratedEvent(id=1)
+            notification = NodeMigratedNotification(id=1)
 
         with patch("time.monotonic", return_value=1001):  # 1 second later
-            repr_str = repr(event)
-            assert "NodeMigratedEvent" in repr_str
+            repr_str = repr(notification)
+            assert "NodeMigratedNotification" in repr_str
             assert "id=1" in repr_str
             assert "ttl=5" in repr_str
             assert "remaining=4.0s" in repr_str
             assert "expired=False" in repr_str
 
     def test_equality_and_hash(self):
-        """Test equality and hash for NodeMigratedEvent."""
-        event1 = NodeMigratedEvent(id=1)
-        event2 = NodeMigratedEvent(id=1)  # Same id
-        event3 = NodeMigratedEvent(id=2)  # Different id
+        """Test equality and hash for NodeMigratedNotification."""
+        notification1 = NodeMigratedNotification(id=1)
+        notification2 = NodeMigratedNotification(id=1)  # Same id
+        notification3 = NodeMigratedNotification(id=2)  # Different id
 
-        assert event1 == event2
-        assert event1 != event3
-        assert hash(event1) == hash(event2)
-        assert hash(event1) != hash(event3)
+        assert notification1 == notification2
+        assert notification1 != notification3
+        assert hash(notification1) == hash(notification2)
+        assert hash(notification1) != hash(notification3)
 
 
-class TestNodeFailingOverEvent:
-    """Test the NodeFailingOverEvent class."""
+class TestNodeFailingOverNotification:
+    """Test the NodeFailingOverNotification class."""
 
     def test_init(self):
-        """Test NodeFailingOverEvent initialization."""
+        """Test NodeFailingOverNotification initialization."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeFailingOverEvent(id=1, ttl=5)
-            assert event.id == 1
-            assert event.ttl == 5
-            assert event.creation_time == 1000
+            notification = NodeFailingOverNotification(id=1, ttl=5)
+            assert notification.id == 1
+            assert notification.ttl == 5
+            assert notification.creation_time == 1000
 
     def test_repr(self):
-        """Test NodeFailingOverEvent string representation."""
+        """Test NodeFailingOverNotification string representation."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeFailingOverEvent(id=1, ttl=5)
+            notification = NodeFailingOverNotification(id=1, ttl=5)
 
         with patch("time.monotonic", return_value=1002):  # 2 seconds later
-            repr_str = repr(event)
-            assert "NodeFailingOverEvent" in repr_str
+            repr_str = repr(notification)
+            assert "NodeFailingOverNotification" in repr_str
             assert "id=1" in repr_str
             assert "ttl=5" in repr_str
             assert "remaining=3.0s" in repr_str
             assert "expired=False" in repr_str
 
     def test_equality_and_hash(self):
-        """Test equality and hash for NodeFailingOverEvent."""
-        event1 = NodeFailingOverEvent(id=1, ttl=5)
-        event2 = NodeFailingOverEvent(id=1, ttl=10)  # Same id, different ttl
-        event3 = NodeFailingOverEvent(id=2, ttl=5)  # Different id
+        """Test equality and hash for NodeFailingOverNotification."""
+        notification1 = NodeFailingOverNotification(id=1, ttl=5)
+        notification2 = NodeFailingOverNotification(
+            id=1, ttl=10
+        )  # Same id, different ttl
+        notification3 = NodeFailingOverNotification(id=2, ttl=5)  # Different id
 
-        assert event1 == event2
-        assert event1 != event3
-        assert hash(event1) == hash(event2)
-        assert hash(event1) != hash(event3)
+        assert notification1 == notification2
+        assert notification1 != notification3
+        assert hash(notification1) == hash(notification2)
+        assert hash(notification1) != hash(notification3)
 
 
-class TestNodeFailedOverEvent:
-    """Test the NodeFailedOverEvent class."""
+class TestNodeFailedOverNotification:
+    """Test the NodeFailedOverNotification class."""
 
     def test_init(self):
-        """Test NodeFailedOverEvent initialization."""
+        """Test NodeFailedOverNotification initialization."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeFailedOverEvent(id=1)
-            assert event.id == 1
-            assert event.ttl == NodeFailedOverEvent.DEFAULT_TTL
-            assert event.creation_time == 1000
+            notification = NodeFailedOverNotification(id=1)
+            assert notification.id == 1
+            assert notification.ttl == NodeFailedOverNotification.DEFAULT_TTL
+            assert notification.creation_time == 1000
 
     def test_default_ttl(self):
         """Test that DEFAULT_TTL is used correctly."""
-        assert NodeFailedOverEvent.DEFAULT_TTL == 5
-        event = NodeFailedOverEvent(id=1)
-        assert event.ttl == 5
+        assert NodeFailedOverNotification.DEFAULT_TTL == 5
+        notification = NodeFailedOverNotification(id=1)
+        assert notification.ttl == 5
 
     def test_repr(self):
-        """Test NodeFailedOverEvent string representation."""
+        """Test NodeFailedOverNotification string representation."""
         with patch("time.monotonic", return_value=1000):
-            event = NodeFailedOverEvent(id=1)
+            notification = NodeFailedOverNotification(id=1)
 
         with patch("time.monotonic", return_value=1001):  # 1 second later
-            repr_str = repr(event)
-            assert "NodeFailedOverEvent" in repr_str
+            repr_str = repr(notification)
+            assert "NodeFailedOverNotification" in repr_str
             assert "id=1" in repr_str
             assert "ttl=5" in repr_str
             assert "remaining=4.0s" in repr_str
             assert "expired=False" in repr_str
 
     def test_equality_and_hash(self):
-        """Test equality and hash for NodeFailedOverEvent."""
-        event1 = NodeFailedOverEvent(id=1)
-        event2 = NodeFailedOverEvent(id=1)  # Same id
-        event3 = NodeFailedOverEvent(id=2)  # Different id
+        """Test equality and hash for NodeFailedOverNotification."""
+        notification1 = NodeFailedOverNotification(id=1)
+        notification2 = NodeFailedOverNotification(id=1)  # Same id
+        notification3 = NodeFailedOverNotification(id=2)  # Different id
 
-        assert event1 == event2
-        assert event1 != event3
-        assert hash(event1) == hash(event2)
-        assert hash(event1) != hash(event3)
+        assert notification1 == notification2
+        assert notification1 != notification3
+        assert hash(notification1) == hash(notification2)
+        assert hash(notification1) != hash(notification3)
 
 
-class TestMaintenanceEventsConfig:
-    """Test the MaintenanceEventsConfig class."""
+class TestMaintNotificationsConfig:
+    """Test the MaintNotificationsConfig class."""
 
     def test_init_defaults(self):
-        """Test MaintenanceEventsConfig initialization with defaults."""
-        config = MaintenanceEventsConfig()
+        """Test MaintNotificationsConfig initialization with defaults."""
+        config = MaintNotificationsConfig()
         assert config.enabled is True
         assert config.proactive_reconnect is True
-        assert config.relax_timeout == 10
+        assert config.relaxed_timeout == 10
 
     def test_init_custom_values(self):
-        """Test MaintenanceEventsConfig initialization with custom values."""
-        config = MaintenanceEventsConfig(
-            enabled=True, proactive_reconnect=False, relax_timeout=30
+        """Test MaintNotificationsConfig initialization with custom values."""
+        config = MaintNotificationsConfig(
+            enabled=True, proactive_reconnect=False, relaxed_timeout=30
         )
         assert config.enabled is True
         assert config.proactive_reconnect is False
-        assert config.relax_timeout == 30
+        assert config.relaxed_timeout == 30
 
     def test_repr(self):
-        """Test MaintenanceEventsConfig string representation."""
-        config = MaintenanceEventsConfig(
-            enabled=True, proactive_reconnect=False, relax_timeout=30
+        """Test MaintNotificationsConfig string representation."""
+        config = MaintNotificationsConfig(
+            enabled=True, proactive_reconnect=False, relaxed_timeout=30
         )
         repr_str = repr(config)
-        assert "MaintenanceEventsConfig" in repr_str
+        assert "MaintNotificationsConfig" in repr_str
         assert "enabled=True" in repr_str
         assert "proactive_reconnect=False" in repr_str
-        assert "relax_timeout=30" in repr_str
+        assert "relaxed_timeout=30" in repr_str
 
-    def test_is_relax_timeouts_enabled_true(self):
-        """Test is_relax_timeouts_enabled returns True for positive timeout."""
-        config = MaintenanceEventsConfig(relax_timeout=20)
-        assert config.is_relax_timeouts_enabled() is True
+    def test_is_relaxed_timeouts_enabled_true(self):
+        """Test is_relaxed_timeouts_enabled returns True for positive timeout."""
+        config = MaintNotificationsConfig(relaxed_timeout=20)
+        assert config.is_relaxed_timeouts_enabled() is True
 
-    def test_is_relax_timeouts_enabled_false(self):
-        """Test is_relax_timeouts_enabled returns False for -1 timeout."""
-        config = MaintenanceEventsConfig(relax_timeout=-1)
-        assert config.is_relax_timeouts_enabled() is False
+    def test_is_relaxed_timeouts_enabled_false(self):
+        """Test is_relaxed_timeouts_enabled returns False for -1 timeout."""
+        config = MaintNotificationsConfig(relaxed_timeout=-1)
+        assert config.is_relaxed_timeouts_enabled() is False
 
-    def test_is_relax_timeouts_enabled_zero(self):
-        """Test is_relax_timeouts_enabled returns True for zero timeout."""
-        config = MaintenanceEventsConfig(relax_timeout=0)
-        assert config.is_relax_timeouts_enabled() is True
+    def test_is_relaxed_timeouts_enabled_zero(self):
+        """Test is_relaxed_timeouts_enabled returns True for zero timeout."""
+        config = MaintNotificationsConfig(relaxed_timeout=0)
+        assert config.is_relaxed_timeouts_enabled() is True
 
-    def test_is_relax_timeouts_enabled_none(self):
-        """Test is_relax_timeouts_enabled returns True for None timeout."""
-        config = MaintenanceEventsConfig(relax_timeout=None)
-        assert config.is_relax_timeouts_enabled() is True
+    def test_is_relaxed_timeouts_enabled_none(self):
+        """Test is_relaxed_timeouts_enabled returns True for None timeout."""
+        config = MaintNotificationsConfig(relaxed_timeout=None)
+        assert config.is_relaxed_timeouts_enabled() is True
 
-    def test_relax_timeout_none_is_saved_as_none(self):
-        """Test that None value for relax_timeout is saved as None."""
-        config = MaintenanceEventsConfig(relax_timeout=None)
-        assert config.relax_timeout is None
+    def test_relaxed_timeout_none_is_saved_as_none(self):
+        """Test that None value for relaxed_timeout is saved as None."""
+        config = MaintNotificationsConfig(relaxed_timeout=None)
+        assert config.relaxed_timeout is None
 
 
-class TestMaintenanceEventPoolHandler:
-    """Test the MaintenanceEventPoolHandler class."""
+class TestMaintNotificationsPoolHandler:
+    """Test the MaintNotificationsPoolHandler class."""
 
     def setup_method(self):
         """Set up test fixtures."""
@@ -438,84 +446,92 @@ def setup_method(self):
         self.mock_pool._lock = MagicMock()
         self.mock_pool._lock.__enter__.return_value = None
         self.mock_pool._lock.__exit__.return_value = None
-        self.config = MaintenanceEventsConfig(
-            enabled=True, proactive_reconnect=True, relax_timeout=20
+        self.config = MaintNotificationsConfig(
+            enabled=True, proactive_reconnect=True, relaxed_timeout=20
         )
-        self.handler = MaintenanceEventPoolHandler(self.mock_pool, self.config)
+        self.handler = MaintNotificationsPoolHandler(self.mock_pool, self.config)
 
     def test_init(self):
-        """Test MaintenanceEventPoolHandler initialization."""
+        """Test MaintNotificationsPoolHandler initialization."""
         assert self.handler.pool == self.mock_pool
         assert self.handler.config == self.config
-        assert isinstance(self.handler._processed_events, set)
+        assert isinstance(self.handler._processed_notifications, set)
         assert isinstance(self.handler._lock, type(threading.RLock()))
 
     def test_remove_expired_notifications(self):
         """Test removal of expired notifications."""
         with patch("time.monotonic", return_value=1000):
-            event1 = NodeMovingEvent(
+            notification1 = NodeMovingNotification(
                 id=1, new_node_host="host1", new_node_port=6379, ttl=10
             )
-            event2 = NodeMovingEvent(
+            notification2 = NodeMovingNotification(
                 id=2, new_node_host="host2", new_node_port=6380, ttl=5
             )
-            self.handler._processed_events.add(event1)
-            self.handler._processed_events.add(event2)
+            self.handler._processed_notifications.add(notification1)
+            self.handler._processed_notifications.add(notification2)
 
-        # Move time forward but not enough to expire event2 (expires at 1005)
+        # Move time forward but not enough to expire notification2 (expires at 1005)
         with patch("time.monotonic", return_value=1003):
             self.handler.remove_expired_notifications()
-            assert event1 in self.handler._processed_events
-            assert event2 in self.handler._processed_events  # Not expired yet
+            assert notification1 in self.handler._processed_notifications
+            assert (
+                notification2 in self.handler._processed_notifications
+            )  # Not expired yet
 
-        # Move time forward to expire event2 but not event1
+        # Move time forward to expire notification2 but not notification1
         with patch("time.monotonic", return_value=1006):
             self.handler.remove_expired_notifications()
-            assert event1 in self.handler._processed_events
-            assert event2 not in self.handler._processed_events  # Now expired
-
-    def test_handle_event_node_moving(self):
-        """Test handling of NodeMovingEvent."""
-        event = NodeMovingEvent(
+            assert notification1 in self.handler._processed_notifications
+            assert (
+                notification2 not in self.handler._processed_notifications
+            )  # Now expired
+
+    def test_handle_notification_node_moving(self):
+        """Test handling of NodeMovingNotification."""
+        notification = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
 
-        with patch.object(self.handler, "handle_node_moving_event") as mock_handle:
-            self.handler.handle_event(event)
-            mock_handle.assert_called_once_with(event)
+        with patch.object(
+            self.handler, "handle_node_moving_notification"
+        ) as mock_handle:
+            self.handler.handle_notification(notification)
+            mock_handle.assert_called_once_with(notification)
 
-    def test_handle_event_unknown_type(self):
-        """Test handling of unknown event type."""
-        event = NodeMigratingEvent(id=1, ttl=5)  # Not handled by pool handler
+    def test_handle_notification_unknown_type(self):
+        """Test handling of unknown notification type."""
+        notification = NodeMigratingNotification(
+            id=1, ttl=5
+        )  # Not handled by pool handler
 
-        result = self.handler.handle_event(event)
+        result = self.handler.handle_notification(notification)
         assert result is None
 
-    def test_handle_node_moving_event_disabled_config(self):
-        """Test node moving event handling when both features are disabled."""
-        config = MaintenanceEventsConfig(proactive_reconnect=False, relax_timeout=-1)
-        handler = MaintenanceEventPoolHandler(self.mock_pool, config)
-        event = NodeMovingEvent(
+    def test_handle_node_moving_notification_disabled_config(self):
+        """Test node moving notification handling when both features are disabled."""
+        config = MaintNotificationsConfig(proactive_reconnect=False, relaxed_timeout=-1)
+        handler = MaintNotificationsPoolHandler(self.mock_pool, config)
+        notification = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
 
-        result = handler.handle_node_moving_event(event)
+        result = handler.handle_node_moving_notification(notification)
         assert result is None
-        assert event not in handler._processed_events
+        assert notification not in handler._processed_notifications
 
-    def test_handle_node_moving_event_already_processed(self):
-        """Test node moving event handling when event already processed."""
-        event = NodeMovingEvent(
+    def test_handle_node_moving_notification_already_processed(self):
+        """Test node moving notification handling when notification already processed."""
+        notification = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
-        self.handler._processed_events.add(event)
+        self.handler._processed_notifications.add(notification)
 
-        result = self.handler.handle_node_moving_event(event)
+        result = self.handler.handle_node_moving_notification(notification)
         assert result is None
 
-    def test_handle_node_moving_event_success(self):
-        """Test successful node moving event handling."""
-        event = NodeMovingEvent(
+    def test_handle_node_moving_notification_success(self):
+        """Test successful node moving notification handling."""
+        notification = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
 
@@ -523,189 +539,197 @@ def test_handle_node_moving_event_success(self):
             patch("threading.Timer") as mock_timer,
             patch("time.monotonic", return_value=1000),
         ):
-            self.handler.handle_node_moving_event(event)
+            self.handler.handle_node_moving_notification(notification)
 
             # Verify timer was started
             mock_timer.assert_called_once_with(
-                event.ttl, self.handler.handle_node_moved_event, args=(event,)
+                notification.ttl,
+                self.handler.handle_node_moved_notification,
+                args=(notification,),
             )
             mock_timer.return_value.start.assert_called_once()
 
-            # Verify event was added to processed set
-            assert event in self.handler._processed_events
+            # Verify notification was added to processed set
+            assert notification in self.handler._processed_notifications
 
             # Verify pool methods were called
             self.mock_pool.update_connections_settings.assert_called_once()
 
-    def test_handle_node_moving_event_with_no_host_and_port(self):
-        """Test successful node moving event handling."""
-        event = NodeMovingEvent(id=1, new_node_host=None, new_node_port=None, ttl=2)
+    def test_handle_node_moving_notification_with_no_host_and_port(self):
+        """Test successful node moving notification handling."""
+        notification = NodeMovingNotification(
+            id=1, new_node_host=None, new_node_port=None, ttl=2
+        )
 
         with (
             patch("threading.Timer") as mock_timer,
             patch("time.monotonic", return_value=1000),
         ):
-            self.handler.handle_node_moving_event(event)
+            self.handler.handle_node_moving_notification(notification)
 
             # Verify timer was started
             mock_timer.assert_has_calls(
                 [
                     call(
-                        event.ttl / 2,
+                        notification.ttl / 2,
                         self.handler.run_proactive_reconnect,
                         args=(None,),
                     ),
                     call().start(),
                     call(
-                        event.ttl, self.handler.handle_node_moved_event, args=(event,)
+                        notification.ttl,
+                        self.handler.handle_node_moved_notification,
+                        args=(notification,),
                     ),
                     call().start(),
                 ]
             )
 
-            # Verify event was added to processed set
-            assert event in self.handler._processed_events
+            # Verify notification was added to processed set
+            assert notification in self.handler._processed_notifications
 
             # Verify pool methods were called
             self.mock_pool.update_connections_settings.assert_called_once()
 
-    def test_handle_node_moved_event(self):
-        """Test handling of node moved event (cleanup)."""
-        event = NodeMovingEvent(
+    def test_handle_node_moved_notification(self):
+        """Test handling of node moved notification (cleanup)."""
+        notification = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
         self.mock_pool.connection_kwargs = {"host": "localhost"}
-        self.handler.handle_node_moved_event(event)
+        self.handler.handle_node_moved_notification(notification)
 
         # Verify cleanup methods were called
         self.mock_pool.update_connections_settings.assert_called_once()
 
 
-class TestMaintenanceEventConnectionHandler:
-    """Test the MaintenanceEventConnectionHandler class."""
+class TestMaintNotificationsConnectionHandler:
+    """Test the MaintNotificationsConnectionHandler class."""
 
     def setup_method(self):
         """Set up test fixtures."""
         self.mock_connection = Mock()
-        self.config = MaintenanceEventsConfig(enabled=True, relax_timeout=20)
-        self.handler = MaintenanceEventConnectionHandler(
+        self.config = MaintNotificationsConfig(enabled=True, relaxed_timeout=20)
+        self.handler = MaintNotificationsConnectionHandler(
             self.mock_connection, self.config
         )
 
     def test_init(self):
-        """Test MaintenanceEventConnectionHandler initialization."""
+        """Test MaintNotificationsConnectionHandler initialization."""
         assert self.handler.connection == self.mock_connection
         assert self.handler.config == self.config
 
-    def test_handle_event_migrating(self):
-        """Test handling of NodeMigratingEvent."""
-        event = NodeMigratingEvent(id=1, ttl=5)
+    def test_handle_notification_migrating(self):
+        """Test handling of NodeMigratingNotification."""
+        notification = NodeMigratingNotification(id=1, ttl=5)
 
         with patch.object(
-            self.handler, "handle_maintenance_start_event"
+            self.handler, "handle_maintenance_start_notification"
         ) as mock_handle:
-            self.handler.handle_event(event)
+            self.handler.handle_notification(notification)
             mock_handle.assert_called_once_with(MaintenanceState.MAINTENANCE)
 
-    def test_handle_event_migrated(self):
-        """Test handling of NodeMigratedEvent."""
-        event = NodeMigratedEvent(id=1)
+    def test_handle_notification_migrated(self):
+        """Test handling of NodeMigratedNotification."""
+        notification = NodeMigratedNotification(id=1)
 
         with patch.object(
-            self.handler, "handle_maintenance_completed_event"
+            self.handler, "handle_maintenance_completed_notification"
         ) as mock_handle:
-            self.handler.handle_event(event)
+            self.handler.handle_notification(notification)
             mock_handle.assert_called_once_with()
 
-    def test_handle_event_failing_over(self):
-        """Test handling of NodeFailingOverEvent."""
-        event = NodeFailingOverEvent(id=1, ttl=5)
+    def test_handle_notification_failing_over(self):
+        """Test handling of NodeFailingOverNotification."""
+        notification = NodeFailingOverNotification(id=1, ttl=5)
 
         with patch.object(
-            self.handler, "handle_maintenance_start_event"
+            self.handler, "handle_maintenance_start_notification"
         ) as mock_handle:
-            self.handler.handle_event(event)
+            self.handler.handle_notification(notification)
             mock_handle.assert_called_once_with(MaintenanceState.MAINTENANCE)
 
-    def test_handle_event_failed_over(self):
-        """Test handling of NodeFailedOverEvent."""
-        event = NodeFailedOverEvent(id=1)
+    def test_handle_notification_failed_over(self):
+        """Test handling of NodeFailedOverNotification."""
+        notification = NodeFailedOverNotification(id=1)
 
         with patch.object(
-            self.handler, "handle_maintenance_completed_event"
+            self.handler, "handle_maintenance_completed_notification"
         ) as mock_handle:
-            self.handler.handle_event(event)
+            self.handler.handle_notification(notification)
             mock_handle.assert_called_once_with()
 
-    def test_handle_event_unknown_type(self):
-        """Test handling of unknown event type."""
-        event = NodeMovingEvent(
+    def test_handle_notification_unknown_type(self):
+        """Test handling of unknown notification type."""
+        notification = NodeMovingNotification(
             id=1, new_node_host="localhost", new_node_port=6379, ttl=10
         )
 
-        result = self.handler.handle_event(event)
+        result = self.handler.handle_notification(notification)
         assert result is None
 
-    def test_handle_maintenance_start_event_disabled(self):
-        """Test maintenance start event handling when relax timeouts are disabled."""
-        config = MaintenanceEventsConfig(relax_timeout=-1)
-        handler = MaintenanceEventConnectionHandler(self.mock_connection, config)
+    def test_handle_maintenance_start_notification_disabled(self):
+        """Test maintenance start notification handling when relaxed timeouts are disabled."""
+        config = MaintNotificationsConfig(relaxed_timeout=-1)
+        handler = MaintNotificationsConnectionHandler(self.mock_connection, config)
 
-        result = handler.handle_maintenance_start_event(MaintenanceState.MAINTENANCE)
+        result = handler.handle_maintenance_start_notification(
+            MaintenanceState.MAINTENANCE
+        )
 
         assert result is None
         self.mock_connection.update_current_socket_timeout.assert_not_called()
 
-    def test_handle_maintenance_start_event_moving_state(self):
-        """Test maintenance start event handling when connection is in MOVING state."""
+    def test_handle_maintenance_start_notification_moving_state(self):
+        """Test maintenance start notification handling when connection is in MOVING state."""
         self.mock_connection.maintenance_state = MaintenanceState.MOVING
 
-        result = self.handler.handle_maintenance_start_event(
+        result = self.handler.handle_maintenance_start_notification(
             MaintenanceState.MAINTENANCE
         )
         assert result is None
         self.mock_connection.update_current_socket_timeout.assert_not_called()
 
-    def test_handle_maintenance_start_event_success(self):
-        """Test successful maintenance start event handling for migrating."""
+    def test_handle_maintenance_start_notification_success(self):
+        """Test successful maintenance start notification handling for migrating."""
         self.mock_connection.maintenance_state = MaintenanceState.NONE
 
-        self.handler.handle_maintenance_start_event(MaintenanceState.MAINTENANCE)
+        self.handler.handle_maintenance_start_notification(MaintenanceState.MAINTENANCE)
 
         assert self.mock_connection.maintenance_state == MaintenanceState.MAINTENANCE
         self.mock_connection.update_current_socket_timeout.assert_called_once_with(20)
         self.mock_connection.set_tmp_settings.assert_called_once_with(
-            tmp_relax_timeout=20
+            tmp_relaxed_timeout=20
         )
 
-    def test_handle_maintenance_completed_event_disabled(self):
-        """Test maintenance completed event handling when relax timeouts are disabled."""
-        config = MaintenanceEventsConfig(relax_timeout=-1)
-        handler = MaintenanceEventConnectionHandler(self.mock_connection, config)
+    def test_handle_maintenance_completed_notification_disabled(self):
+        """Test maintenance completed notification handling when relaxed timeouts are disabled."""
+        config = MaintNotificationsConfig(relaxed_timeout=-1)
+        handler = MaintNotificationsConnectionHandler(self.mock_connection, config)
 
-        result = handler.handle_maintenance_completed_event()
+        result = handler.handle_maintenance_completed_notification()
         assert result is None
         self.mock_connection.update_current_socket_timeout.assert_not_called()
 
-    def test_handle_maintenance_completed_event_moving_state(self):
-        """Test maintenance completed event handling when connection is in MOVING state."""
+    def test_handle_maintenance_completed_notification_moving_state(self):
+        """Test maintenance completed notification handling when connection is in MOVING state."""
         self.mock_connection.maintenance_state = MaintenanceState.MOVING
 
-        result = self.handler.handle_maintenance_completed_event()
+        result = self.handler.handle_maintenance_completed_notification()
         assert result is None
         self.mock_connection.update_current_socket_timeout.assert_not_called()
 
-    def test_handle_maintenance_completed_event_success(self):
-        """Test successful maintenance completed event handling."""
+    def test_handle_maintenance_completed_notification_success(self):
+        """Test successful maintenance completed notification handling."""
         self.mock_connection.maintenance_state = MaintenanceState.MAINTENANCE
 
-        self.handler.handle_maintenance_completed_event()
+        self.handler.handle_maintenance_completed_notification()
 
         assert self.mock_connection.maintenance_state == MaintenanceState.NONE
 
         self.mock_connection.update_current_socket_timeout.assert_called_once_with(-1)
         self.mock_connection.reset_tmp_settings.assert_called_once_with(
-            reset_relax_timeout=True
+            reset_relaxed_timeout=True
         )
 
 
@@ -721,8 +745,8 @@ def test_endpoint_type_constants(self):
         assert EndpointType.NONE.value == "none"
 
 
-class TestMaintenanceEventsConfigEndpointType:
-    """Test MaintenanceEventsConfig endpoint type functionality."""
+class TestMaintNotificationsConfigEndpointType:
+    """Test MaintNotificationsConfig endpoint type functionality."""
 
     def setup_method(self):
         """Set up common mock classes for all tests."""
@@ -751,19 +775,19 @@ def get_resolved_ip(self):
         self.MockConnection = MockConnection
 
     def test_config_validation_valid_endpoint_types(self):
-        """Test that MaintenanceEventsConfig accepts valid endpoint types."""
+        """Test that MaintNotificationsConfig accepts valid endpoint types."""
         for endpoint_type in EndpointType:
-            config = MaintenanceEventsConfig(endpoint_type=endpoint_type)
+            config = MaintNotificationsConfig(endpoint_type=endpoint_type)
             assert config.endpoint_type == endpoint_type
 
     def test_config_validation_none_endpoint_type(self):
-        """Test that MaintenanceEventsConfig accepts None as endpoint type."""
-        config = MaintenanceEventsConfig(endpoint_type=None)
+        """Test that MaintNotificationsConfig accepts None as endpoint type."""
+        config = MaintNotificationsConfig(endpoint_type=None)
         assert config.endpoint_type is None
 
     def test_endpoint_type_detection_ip_addresses(self):
         """Test endpoint type detection for IP addresses."""
-        config = MaintenanceEventsConfig()
+        config = MaintNotificationsConfig()
 
         # Test private IPv4 addresses
         conn1 = self.MockConnection("192.168.1.1", resolved_ip="192.168.1.1")
@@ -788,7 +812,7 @@ def test_endpoint_type_detection_ip_addresses(self):
 
     def test_endpoint_type_detection_fqdn_with_resolved_ip(self):
         """Test endpoint type detection for FQDNs with resolved IP addresses."""
-        config = MaintenanceEventsConfig()
+        config = MaintNotificationsConfig()
 
         # Test FQDN resolving to private IP
         conn1 = self.MockConnection(
@@ -834,7 +858,7 @@ def test_endpoint_type_detection_fqdn_with_resolved_ip(self):
 
     def test_endpoint_type_detection_fqdn_heuristics(self):
         """Test endpoint type detection using FQDN heuristics when no resolved IP is available."""
-        config = MaintenanceEventsConfig()
+        config = MaintNotificationsConfig()
 
         # Test localhost (should be internal)
         conn1 = self.MockConnection("localhost")
@@ -859,11 +883,11 @@ def test_endpoint_type_override(self):
         """Test that configured endpoint_type overrides detection."""
 
         # Test with endpoint_type set to NONE
-        config = MaintenanceEventsConfig(endpoint_type=EndpointType.NONE)
+        config = MaintNotificationsConfig(endpoint_type=EndpointType.NONE)
         conn = self.MockConnection("localhost")
 
         assert config.get_endpoint_type("localhost", conn) == EndpointType.NONE
 
         # Test with endpoint_type set to EXTERNAL_IP
-        config = MaintenanceEventsConfig(endpoint_type=EndpointType.EXTERNAL_IP)
+        config = MaintNotificationsConfig(endpoint_type=EndpointType.EXTERNAL_IP)
         assert config.get_endpoint_type("localhost", conn) == EndpointType.EXTERNAL_IP
diff --git a/tests/test_maintenance_events_handling.py b/tests/test_maintenance_events_handling.py
index 06c607b552..c974eaaef7 100644
--- a/tests/test_maintenance_events_handling.py
+++ b/tests/test_maintenance_events_handling.py
@@ -14,13 +14,13 @@
     MaintenanceState,
 )
 from redis.maintenance_events import (
-    MaintenanceEventsConfig,
-    NodeMigratingEvent,
-    NodeMigratedEvent,
-    NodeFailingOverEvent,
-    NodeFailedOverEvent,
-    MaintenanceEventPoolHandler,
-    NodeMovingEvent,
+    MaintNotificationsConfig,
+    NodeMigratingNotification,
+    NodeMigratedNotification,
+    NodeFailingOverNotification,
+    NodeFailedOverNotification,
+    MaintNotificationsPoolHandler,
+    NodeMovingNotification,
 )
 
 
@@ -28,14 +28,14 @@
 DEFAULT_ADDRESS = "12.45.34.56:6379"
 MOVING_TIMEOUT = 1
 
-MOVING_EVENT = NodeMovingEvent(
+MOVING_NOTIFICATION = NodeMovingNotification(
     id=1,
     new_node_host=AFTER_MOVING_ADDRESS.split(":")[0],
     new_node_port=int(AFTER_MOVING_ADDRESS.split(":")[1]),
     ttl=MOVING_TIMEOUT,
 )
 
-MOVING_NONE_EVENT = NodeMovingEvent(
+MOVING_NONE_NOTIFICATION = NodeMovingNotification(
     id=1,
     new_node_host=None,
     new_node_port=None,
@@ -44,7 +44,7 @@
 
 
 class Helpers:
-    """Helper class containing static methods for validation in maintenance events tests."""
+    """Helper class containing static methods for validation in maintenance notifications tests."""
 
     @staticmethod
     def validate_in_use_connections_state(
@@ -122,7 +122,7 @@ def validate_free_connections_state(
             )
             assert connection.maintenance_state == expected_state
             if expected_state == MaintenanceState.NONE:
-                assert connection.maintenance_event_hash is None
+                assert connection.maintenance_notification_hash is None
 
             if connection._sock is not None:
                 assert connection._sock.connected is True
@@ -135,7 +135,7 @@ def validate_free_connections_state(
     def validate_conn_kwargs(
         pool,
         expected_maintenance_state,
-        expected_maintenance_event_hash,
+        expected_maintenance_notification_hash,
         expected_host_address,
         expected_port,
         expected_socket_timeout,
@@ -147,8 +147,8 @@ def validate_conn_kwargs(
         """Helper method to validate connection kwargs."""
         assert pool.connection_kwargs["maintenance_state"] == expected_maintenance_state
         assert (
-            pool.connection_kwargs["maintenance_event_hash"]
-            == expected_maintenance_event_hash
+            pool.connection_kwargs["maintenance_notification_hash"]
+            == expected_maintenance_notification_hash
         )
         assert pool.connection_kwargs["host"] == expected_host_address
         assert pool.connection_kwargs["port"] == expected_port
@@ -181,7 +181,7 @@ def __init__(self):
         self.closed = False
         self.command_count = 0
         self.pending_responses = []
-        # Track socket timeout changes for maintenance events validation
+        # Track socket timeout changes for maintenance notifications validation
         self.timeout = None
         self.thread_timeouts = {}  # Track last applied timeout per thread
         self.moving_sent = False
@@ -337,8 +337,8 @@ def shutdown(self, how):
         pass
 
 
-class TestMaintenanceEventsHandlingSingleProxy:
-    """Integration tests for maintenance events handling with real connection pool."""
+class TestMaintenanceNotificationsHandlingSingleProxy:
+    """Integration tests for maintenance notifications handling with real connection pool."""
 
     def setup_method(self):
         """Set up test fixtures with mocked sockets."""
@@ -370,9 +370,9 @@ def mock_select(rlist, wlist, xlist, timeout=0):
         self.select_patcher = patch("select.select", side_effect=mock_select)
         self.select_patcher.start()
 
-        # Create maintenance events config
-        self.config = MaintenanceEventsConfig(
-            enabled=True, proactive_reconnect=True, relax_timeout=30
+        # Create maintenance notifications config
+        self.config = MaintNotificationsConfig(
+            enabled=True, proactive_reconnect=True, relaxed_timeout=30
         )
 
     def teardown_method(self):
@@ -384,24 +384,24 @@ def _get_client(
         self,
         pool_class,
         max_connections=10,
-        maintenance_events_config=None,
+        maint_notifications_config=None,
         setup_pool_handler=False,
     ):
-        """Helper method to create a pool and Redis client with maintenance events configuration.
+        """Helper method to create a pool and Redis client with maintenance notifications configuration.
 
         Args:
             pool_class: The connection pool class (ConnectionPool or BlockingConnectionPool)
             max_connections: Maximum number of connections in the pool (default: 10)
-            maintenance_events_config: Optional MaintenanceEventsConfig to use. If not provided,
+            maint_notifications_config: Optional MaintNotificationsConfig to use. If not provided,
                                      uses self.config from setup_method (default: None)
-            setup_pool_handler: Whether to set up pool handler for moving events (default: False)
+            setup_pool_handler: Whether to set up pool handler for moving notifications (default: False)
 
         Returns:
             tuple: (test_pool, test_redis_client)
         """
         config = (
-            maintenance_events_config
-            if maintenance_events_config is not None
+            maint_notifications_config
+            if maint_notifications_config is not None
             else self.config
         )
 
@@ -409,17 +409,17 @@ def _get_client(
             host=DEFAULT_ADDRESS.split(":")[0],
             port=int(DEFAULT_ADDRESS.split(":")[1]),
             max_connections=max_connections,
-            protocol=3,  # Required for maintenance events
-            maintenance_events_config=config,
+            protocol=3,  # Required for maintenance notifications
+            maint_notifications_config=config,
         )
         test_redis_client = Redis(connection_pool=test_pool)
 
-        # Set up pool handler for moving events if requested
+        # Set up pool handler for moving notifications if requested
         if setup_pool_handler:
-            pool_handler = MaintenanceEventPoolHandler(
+            pool_handler = MaintNotificationsPoolHandler(
                 test_redis_client.connection_pool, config
             )
-            test_redis_client.connection_pool.set_maintenance_events_pool_handler(
+            test_redis_client.connection_pool.set_maint_notifications_pool_handler(
                 pool_handler
             )
 
@@ -433,7 +433,7 @@ def _validate_connection_handlers(self, conn, pool_handler, config):
         assert hasattr(parser_handler, "__self__")
         assert hasattr(parser_handler, "__func__")
         assert parser_handler.__self__ is pool_handler
-        assert parser_handler.__func__ is pool_handler.handle_event.__func__
+        assert parser_handler.__func__ is pool_handler.handle_notification.__func__
 
         # Test that the maintenance handler function is correctly set
         maintenance_handler = conn._parser.maintenance_push_handler_func
@@ -441,17 +441,17 @@ def _validate_connection_handlers(self, conn, pool_handler, config):
         assert hasattr(maintenance_handler, "__self__")
         assert hasattr(maintenance_handler, "__func__")
         # The maintenance handler should be bound to the connection's
-        # maintenance event connection handler
+        # maintenance notification connection handler
         assert (
-            maintenance_handler.__self__ is conn._maintenance_event_connection_handler
+            maintenance_handler.__self__ is conn._maint_notifications_connection_handler
         )
         assert (
             maintenance_handler.__func__
-            is conn._maintenance_event_connection_handler.handle_event.__func__
+            is conn._maint_notifications_connection_handler.handle_notification.__func__
         )
 
         # Validate that the connection's maintenance handler has the same config object
-        assert conn._maintenance_event_connection_handler.config is config
+        assert conn._maint_notifications_connection_handler.config is config
 
     def _validate_current_timeout(self, expected_timeout, error_msg=None):
         """Helper method to validate the current timeout for the calling thread."""
@@ -487,16 +487,16 @@ def _validate_connected(self, expected_count):
         assert connected_sockets_count == expected_count
 
     def test_client_initialization(self):
-        """Test that Redis client is created with maintenance events configuration."""
-        # Create a pool and Redis client with maintenance events
+        """Test that Redis client is created with maintenance notifications configuration."""
+        # Create a pool and Redis client with maintenance notifications
 
         test_redis_client = Redis(
-            protocol=3,  # Required for maintenance events
-            maintenance_events_config=self.config,
+            protocol=3,  # Required for maintenance notifications
+            maint_notifications_config=self.config,
         )
 
         pool_handler = test_redis_client.connection_pool.connection_kwargs.get(
-            "maintenance_events_pool_handler"
+            "maint_notifications_pool_handler"
         )
         assert pool_handler is not None
         assert pool_handler.config == self.config
@@ -513,7 +513,7 @@ def test_client_initialization(self):
         assert hasattr(parser_handler, "__self__")
         assert hasattr(parser_handler, "__func__")
         assert parser_handler.__self__ is pool_handler
-        assert parser_handler.__func__ is pool_handler.handle_event.__func__
+        assert parser_handler.__func__ is pool_handler.handle_notification.__func__
 
         # Test that the maintenance handler function is correctly set
         maintenance_handler = conn._parser.maintenance_push_handler_func
@@ -521,49 +521,49 @@ def test_client_initialization(self):
         assert hasattr(maintenance_handler, "__self__")
         assert hasattr(maintenance_handler, "__func__")
         # The maintenance handler should be bound to the connection's
-        # maintenance event connection handler
+        # maintenance notification connection handler
         assert (
-            maintenance_handler.__self__ is conn._maintenance_event_connection_handler
+            maintenance_handler.__self__ is conn._maint_notifications_connection_handler
         )
         assert (
             maintenance_handler.__func__
-            is conn._maintenance_event_connection_handler.handle_event.__func__
+            is conn._maint_notifications_connection_handler.handle_notification.__func__
         )
 
         # Validate that the connection's maintenance handler has the same config object
-        assert conn._maintenance_event_connection_handler.config is self.config
+        assert conn._maint_notifications_connection_handler.config is self.config
 
     def test_maint_handler_init_for_existing_connections(self):
-        """Test that maintenance event handlers are properly set on existing and new connections
+        """Test that maintenance notification handlers are properly set on existing and new connections
         when configuration is enabled after client creation."""
 
-        # Create a Redis client with disabled maintenance events configuration
-        disabled_config = MaintenanceEventsConfig(enabled=False)
+        # Create a Redis client with disabled maintenance notifications configuration
+        disabled_config = MaintNotificationsConfig(enabled=False)
         test_redis_client = Redis(
-            protocol=3,  # Required for maintenance events
-            maintenance_events_config=disabled_config,
+            protocol=3,  # Required for maintenance notifications
+            maint_notifications_config=disabled_config,
         )
 
-        # Extract an existing connection before enabling maintenance events
+        # Extract an existing connection before enabling maintenance notifications
         existing_conn = test_redis_client.connection_pool.get_connection()
 
-        # Verify that maintenance events are initially disabled
+        # Verify that maintenance notifications are initially disabled
         assert existing_conn._parser.node_moving_push_handler_func is None
-        assert existing_conn._maintenance_event_connection_handler is None
+        assert existing_conn._maint_notifications_connection_handler is None
         assert existing_conn._parser.maintenance_push_handler_func is None
 
         # Create a new enabled configuration and set up pool handler
-        enabled_config = MaintenanceEventsConfig(
-            enabled=True, proactive_reconnect=True, relax_timeout=30
+        enabled_config = MaintNotificationsConfig(
+            enabled=True, proactive_reconnect=True, relaxed_timeout=30
         )
-        pool_handler = MaintenanceEventPoolHandler(
+        pool_handler = MaintNotificationsPoolHandler(
             test_redis_client.connection_pool, enabled_config
         )
-        test_redis_client.connection_pool.set_maintenance_events_pool_handler(
+        test_redis_client.connection_pool.set_maint_notifications_pool_handler(
             pool_handler
         )
 
-        # Validate the existing connection after enabling maintenance events
+        # Validate the existing connection after enabling maintenance notifications
         # Both existing and new connections should now have full handler setup
         self._validate_connection_handlers(existing_conn, pool_handler, enabled_config)
 
@@ -576,9 +576,9 @@ def test_maint_handler_init_for_existing_connections(self):
         test_redis_client.connection_pool.release(new_conn)
 
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
-    def test_connection_pool_creation_with_maintenance_events(self, pool_class):
-        """Test that connection pools are created with maintenance events configuration."""
-        # Create a pool and Redis client with maintenance events
+    def test_connection_pool_creation_with_maintenance_notifications(self, pool_class):
+        """Test that connection pools are created with maintenance notifications configuration."""
+        # Create a pool and Redis client with maintenance notifications
         max_connections = 3 if pool_class == BlockingConnectionPool else 10
         test_redis_client = self._get_client(
             pool_class, max_connections=max_connections
@@ -587,23 +587,23 @@ def test_connection_pool_creation_with_maintenance_events(self, pool_class):
 
         try:
             assert (
-                test_pool.connection_kwargs.get("maintenance_events_config")
+                test_pool.connection_kwargs.get("maint_notifications_config")
                 == self.config
             )
-            # Pool should have maintenance events enabled
-            assert test_pool.maintenance_events_pool_handler_enabled() is True
+            # Pool should have maintenance notifications enabled
+            assert test_pool.maint_notifications_pool_handler_enabled() is True
 
             # Create and set a pool handler
-            pool_handler = MaintenanceEventPoolHandler(test_pool, self.config)
-            test_pool.set_maintenance_events_pool_handler(pool_handler)
+            pool_handler = MaintNotificationsPoolHandler(test_pool, self.config)
+            test_pool.set_maint_notifications_pool_handler(pool_handler)
 
             # Validate that the handler is properly set on the pool
             assert (
-                test_pool.connection_kwargs.get("maintenance_events_pool_handler")
+                test_pool.connection_kwargs.get("maint_notifications_pool_handler")
                 == pool_handler
             )
             assert (
-                test_pool.connection_kwargs.get("maintenance_events_config")
+                test_pool.connection_kwargs.get("maint_notifications_config")
                 == pool_handler.config
             )
 
@@ -621,7 +621,7 @@ def test_redis_operations_with_mock_sockets(self, pool_class):
         Test basic Redis operations work with mocked sockets and proper response parsing.
         Basically with test - the mocked socket is validated.
         """
-        # Create a pool and Redis client with maintenance events
+        # Create a pool and Redis client with maintenance notifications
         test_redis_client = self._get_client(pool_class, max_connections=5)
 
         try:
@@ -638,27 +638,27 @@ def test_redis_operations_with_mock_sockets(self, pool_class):
             assert self.mock_sockets[0].connected
             assert len(self.mock_sockets[0].sent_data) >= 2  # HELLO, SET, GET commands
 
-            # Verify that the connection has maintenance event handler
+            # Verify that the connection has maintenance notification handler
             connection = test_redis_client.connection_pool.get_connection()
-            assert hasattr(connection, "_maintenance_event_connection_handler")
+            assert hasattr(connection, "_maint_notifications_connection_handler")
             test_redis_client.connection_pool.release(connection)
 
         finally:
             if hasattr(test_redis_client.connection_pool, "disconnect"):
                 test_redis_client.connection_pool.disconnect()
 
-    def test_pool_handler_with_migrating_event(self):
-        """Test that pool handler correctly handles migrating events."""
-        # Create a pool and Redis client with maintenance events
+    def test_pool_handler_with_migrating_notification(self):
+        """Test that pool handler correctly handles migrating notifications."""
+        # Create a pool and Redis client with maintenance notifications
         test_redis_client = self._get_client(ConnectionPool)
         test_pool = test_redis_client.connection_pool
 
         try:
             # Create and set a pool handler
-            pool_handler = MaintenanceEventPoolHandler(test_pool, self.config)
+            pool_handler = MaintNotificationsPoolHandler(test_pool, self.config)
 
-            # Create a migrating event (not handled by pool handler)
-            migrating_event = NodeMigratingEvent(id=1, ttl=5)
+            # Create a migrating notification (not handled by pool handler)
+            migrating_notification = NodeMigratingNotification(id=1, ttl=5)
 
             # Mock the required functions
             with (
@@ -666,17 +666,17 @@ def test_pool_handler_with_migrating_event(self):
                     pool_handler, "remove_expired_notifications"
                 ) as mock_remove_expired,
                 patch.object(
-                    pool_handler, "handle_node_moving_event"
+                    pool_handler, "handle_node_moving_notification"
                 ) as mock_handle_moving,
                 patch("redis.maintenance_events.logging.error") as mock_logging_error,
             ):
-                # Pool handler should return None for migrating events (not its responsibility)
-                pool_handler.handle_event(migrating_event)
+                # Pool handler should return None for migrating notifications (not its responsibility)
+                pool_handler.handle_notification(migrating_notification)
 
                 # Validate that remove_expired_notifications has been called once
                 mock_remove_expired.assert_called_once()
 
-                # Validate that handle_node_moving_event hasn't been called
+                # Validate that handle_node_moving_notification hasn't been called
                 mock_handle_moving.assert_not_called()
 
                 # Validate that logging.error has been called once
@@ -687,9 +687,9 @@ def test_pool_handler_with_migrating_event(self):
                 test_pool.disconnect()
 
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
-    def test_migration_related_events_handling_integration(self, pool_class):
+    def test_migration_related_notifications_handling_integration(self, pool_class):
         """
-        Test full integration of migration-related events (MIGRATING/MIGRATED) handling.
+        Test full integration of migration-related notifications (MIGRATING/MIGRATED) handling.
 
         This test validates the complete migration lifecycle:
         1. Executes 5 Redis commands sequentially
@@ -701,7 +701,7 @@ def test_migration_related_events_handling_integration(self, pool_class):
         7. Tests both ConnectionPool and BlockingConnectionPool implementations
         8. Uses proper RESP3 push message format for realistic protocol simulation
         """
-        # Create a pool and Redis client with maintenance events
+        # Create a pool and Redis client with maintenance notifications
         test_redis_client = self._get_client(pool_class, max_connections=10)
 
         try:
@@ -760,7 +760,7 @@ def test_migration_related_events_handling_integration(self, pool_class):
             # Step 8: Validate socket timeout is reversed back to original after MIGRATED
             self._validate_current_timeout(None)
 
-            # Verify maintenance events were processed correctly
+            # Verify maintenance notifications were processed correctly
             # The key is that we have at least 1 socket and all operations succeeded
             assert len(self.mock_sockets) >= 1, (
                 f"Expected at least 1 socket for operations, got {len(self.mock_sockets)}"
@@ -771,26 +771,26 @@ def test_migration_related_events_handling_integration(self, pool_class):
                 test_redis_client.connection_pool.disconnect()
 
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
-    def test_migrating_event_with_disabled_relax_timeout(self, pool_class):
+    def test_migrating_notification_with_disabled_relaxed_timeout(self, pool_class):
         """
-        Test maintenance events handling when relax timeout is disabled.
+        Test maintenance notifications handling when relaxed timeout is disabled.
 
-        This test validates that when relax_timeout is disabled (-1):
-        1. MIGRATING, MIGRATED, FAILING_OVER, and FAILED_OVER events are received and processed
+        This test validates that when relaxed_timeout is disabled (-1):
+        1. MIGRATING, MIGRATED, FAILING_OVER, and FAILED_OVER notifications are received and processed
         2. No timeout updates are applied to connections
-        3. Socket timeouts remain unchanged during all maintenance events
+        3. Socket timeouts remain unchanged during all maintenance notifications
         4. Tests both ConnectionPool and BlockingConnectionPool implementations
         5. Tests the complete lifecycle: MIGRATING -> MIGRATED -> FAILING_OVER -> FAILED_OVER
         """
-        # Create config with disabled relax timeout
-        disabled_config = MaintenanceEventsConfig(
+        # Create config with disabled relaxed timeout
+        disabled_config = MaintNotificationsConfig(
             enabled=True,
-            relax_timeout=-1,  # This means the relax timeout is Disabled
+            relaxed_timeout=-1,  # This means the relaxed timeout is Disabled
         )
 
-        # Create a pool and Redis client with disabled relax timeout config
+        # Create a pool and Redis client with disabled relaxed timeout config
         test_redis_client = self._get_client(
-            pool_class, max_connections=5, maintenance_events_config=disabled_config
+            pool_class, max_connections=5, maint_notifications_config=disabled_config
         )
 
         try:
@@ -810,7 +810,7 @@ def test_migrating_event_with_disabled_relax_timeout(self, pool_class):
             # Validate Command 2 result
             assert result2 is True, "Command 2 (SET key_receive_migrating) failed"
 
-            # Validate timeout was NOT updated (relax is disabled)
+            # Validate timeout was NOT updated (relaxed is disabled)
             # Should remain at default timeout (None), not relaxed to 30s
             self._validate_current_timeout(None)
 
@@ -831,7 +831,7 @@ def test_migrating_event_with_disabled_relax_timeout(self, pool_class):
             # Validate Command 4 result
             assert result4 is True, "Command 4 (SET key_receive_migrated) failed"
 
-            # Validate timeout is still NOT updated after MIGRATED (relax is disabled)
+            # Validate timeout is still NOT updated after MIGRATED (relaxed is disabled)
             self._validate_current_timeout(None)
 
             # Command 5: This SET command will receive FAILING_OVER push message before response
@@ -842,7 +842,7 @@ def test_migrating_event_with_disabled_relax_timeout(self, pool_class):
             # Validate Command 5 result
             assert result5 is True, "Command 5 (SET key_receive_failing_over) failed"
 
-            # Validate timeout is still NOT updated after FAILING_OVER (relax is disabled)
+            # Validate timeout is still NOT updated after FAILING_OVER (relaxed is disabled)
             self._validate_current_timeout(None)
 
             # Command 6: Another command to verify timeout remains unchanged during failover
@@ -862,10 +862,10 @@ def test_migrating_event_with_disabled_relax_timeout(self, pool_class):
             # Validate Command 7 result
             assert result7 is True, "Command 7 (SET key_receive_failed_over) failed"
 
-            # Validate timeout is still NOT updated after FAILED_OVER (relax is disabled)
+            # Validate timeout is still NOT updated after FAILED_OVER (relaxed is disabled)
             self._validate_current_timeout(None)
 
-            # Command 8: Final command to verify timeout remains unchanged after all events
+            # Command 8: Final command to verify timeout remains unchanged after all notifications
             result8 = test_redis_client.get(key_failed_over)
 
             # Validate Command 8 result
@@ -874,7 +874,7 @@ def test_migrating_event_with_disabled_relax_timeout(self, pool_class):
                 f"Command 8 (GET key_receive_failed_over) failed. Expected: {expected_value8}, Got: {result8}"
             )
 
-            # Verify maintenance events were processed correctly
+            # Verify maintenance notifications were processed correctly
             # The key is that we have at least 1 socket and all operations succeeded
             assert len(self.mock_sockets) >= 1, (
                 f"Expected at least 1 socket for operations, got {len(self.mock_sockets)}"
@@ -885,9 +885,9 @@ def test_migrating_event_with_disabled_relax_timeout(self, pool_class):
                 test_redis_client.connection_pool.disconnect()
 
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
-    def test_failing_over_related_events_handling_integration(self, pool_class):
+    def test_failing_over_related_notifications_handling_integration(self, pool_class):
         """
-        Test full integration of failing-over-related events (FAILING_OVER/FAILED_OVER) handling.
+        Test full integration of failing-over-related notifications (FAILING_OVER/FAILED_OVER) handling.
 
         This test validates the complete FAILING_OVER -> FAILED_OVER lifecycle:
         1. Executes 5 Redis commands sequentially
@@ -899,7 +899,7 @@ def test_failing_over_related_events_handling_integration(self, pool_class):
         7. Tests both ConnectionPool and BlockingConnectionPool implementations
         8. Uses proper RESP3 push message format for realistic protocol simulation
         """
-        # Create a pool and Redis client with maintenance events
+        # Create a pool and Redis client with maintenance notifications
         test_redis_client = self._get_client(pool_class, max_connections=10)
 
         try:
@@ -958,7 +958,7 @@ def test_failing_over_related_events_handling_integration(self, pool_class):
             # Step 8: Validate socket timeout is reversed back to original after FAILED_OVER
             self._validate_current_timeout(None)
 
-            # Verify maintenance events were processed correctly
+            # Verify maintenance notifications were processed correctly
             # The key is that we have at least 1 socket and all operations succeeded
             assert len(self.mock_sockets) >= 1, (
                 f"Expected at least 1 socket for operations, got {len(self.mock_sockets)}"
@@ -969,11 +969,11 @@ def test_failing_over_related_events_handling_integration(self, pool_class):
                 test_redis_client.connection_pool.disconnect()
 
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
-    def test_moving_related_events_handling_integration(self, pool_class):
+    def test_moving_related_notifications_handling_integration(self, pool_class):
         """
-        Test full integration of moving-related events (MOVING) handling with Redis commands.
+        Test full integration of moving-related notifications (MOVING) handling with Redis commands.
 
-        This test validates the complete MOVING event lifecycle:
+        This test validates the complete MOVING notification lifecycle:
         1. Creates multiple connections in the pool
         2. Executes a Redis command that triggers a MOVING push message
         3. Validates that pool configuration is updated with temporary
@@ -981,7 +981,7 @@ def test_moving_related_events_handling_integration(self, pool_class):
         4. Validates that existing connections are marked for disconnection
         5. Tests both ConnectionPool and BlockingConnectionPool implementations
         """
-        # Create a pool and Redis client with maintenance events and pool handler
+        # Create a pool and Redis client with maintenance notifications and pool handler
         test_redis_client = self._get_client(
             pool_class, max_connections=10, setup_pool_handler=True
         )
@@ -1002,10 +1002,10 @@ def test_moving_related_events_handling_integration(self, pool_class):
                 connection = test_redis_client.connection_pool.get_connection()
                 in_use_connections.append(connection)
 
-            # Validate all connections are connected prior MOVING event
+            # Validate all connections are connected prior MOVING notification
             self._validate_disconnected(0)
 
-            # Run command that will receive and handle MOVING event
+            # Run command that will receive and handle MOVING notification
             key_moving = "key_receive_moving_0"
             value_moving = "value3_0"
             # the connection used for the command is expected to be reconnected to the new address
@@ -1015,17 +1015,17 @@ def test_moving_related_events_handling_integration(self, pool_class):
             # Validate Command 2 result
             assert result2 is True, "Command 2 (SET key_receive_moving) failed"
 
-            # Validate pool and connections settings were updated according to MOVING event
-            expected_event_hash = hash(MOVING_EVENT)
+            # Validate pool and connections settings were updated according to MOVING notification
+            expected_notification_hash = hash(MOVING_NOTIFICATION)
 
             Helpers.validate_conn_kwargs(
                 pool=test_redis_client.connection_pool,
                 expected_maintenance_state=MaintenanceState.MOVING,
-                expected_maintenance_event_hash=expected_event_hash,
+                expected_maintenance_notification_hash=expected_notification_hash,
                 expected_host_address=AFTER_MOVING_ADDRESS.split(":")[0],
                 expected_port=int(DEFAULT_ADDRESS.split(":")[1]),
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
@@ -1036,12 +1036,12 @@ def test_moving_related_events_handling_integration(self, pool_class):
                 in_use_connections,
                 expected_state=MaintenanceState.MOVING,
                 expected_host_address=AFTER_MOVING_ADDRESS.split(":")[0],
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
-                expected_current_socket_timeout=self.config.relax_timeout,
+                expected_current_socket_timeout=self.config.relaxed_timeout,
                 expected_current_peername=DEFAULT_ADDRESS.split(":")[
                     0
                 ],  # the in use connections reconnect when they complete their current task
@@ -1050,8 +1050,8 @@ def test_moving_related_events_handling_integration(self, pool_class):
                 pool=test_redis_client.connection_pool,
                 expected_state=MaintenanceState.MOVING,
                 expected_host_address=AFTER_MOVING_ADDRESS.split(":")[0],
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
@@ -1076,7 +1076,7 @@ def test_moving_related_events_handling_integration(self, pool_class):
             Helpers.validate_conn_kwargs(
                 pool=test_redis_client.connection_pool,
                 expected_maintenance_state=MaintenanceState.NONE,
-                expected_maintenance_event_hash=None,
+                expected_maintenance_notification_hash=None,
                 expected_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_port=int(DEFAULT_ADDRESS.split(":")[1]),
                 expected_socket_timeout=None,
@@ -1102,11 +1102,11 @@ def test_moving_related_events_handling_integration(self, pool_class):
                 test_redis_client.connection_pool.disconnect()
 
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
-    def test_moving_none_events_handling_integration(self, pool_class):
+    def test_moving_none_notifications_handling_integration(self, pool_class):
         """
-        Test full integration of moving-related events (MOVING) handling with Redis commands.
+        Test full integration of moving-related notifications (MOVING) handling with Redis commands.
 
-        This test validates the complete MOVING event lifecycle,
+        This test validates the complete MOVING notification lifecycle,
         when the push notification doesn't contain host and port:
         1. Creates multiple connections in the pool
         2. Executes a Redis command that triggers a MOVING with "null" push message
@@ -1115,7 +1115,7 @@ def test_moving_none_events_handling_integration(self, pool_class):
         4. Validates that existing connections are marked for disconnection after ttl/2 seconds
         5. Tests both ConnectionPool and BlockingConnectionPool implementations
         """
-        # Create a pool and Redis client with maintenance events and pool handler
+        # Create a pool and Redis client with maintenance notifications and pool handler
         test_redis_client = self._get_client(
             pool_class, max_connections=10, setup_pool_handler=True
         )
@@ -1136,10 +1136,10 @@ def test_moving_none_events_handling_integration(self, pool_class):
                 connection = test_redis_client.connection_pool.get_connection()
                 in_use_connections.append(connection)
 
-            # Validate all connections are connected prior MOVING event
+            # Validate all connections are connected prior MOVING notification
             self._validate_disconnected(0)
 
-            # Run command that will receive and handle MOVING event
+            # Run command that will receive and handle MOVING notification
             key_moving = "key_receive_moving_none_0"
             value_moving = "value3_0"
 
@@ -1150,15 +1150,15 @@ def test_moving_none_events_handling_integration(self, pool_class):
             # Validate Command 2 result
             assert result2 is True, "Command 2 (SET key_receive_moving) failed"
 
-            # Validate pool and connections settings were updated according to MOVING event
+            # Validate pool and connections settings were updated according to MOVING notification
             Helpers.validate_conn_kwargs(
                 pool=test_redis_client.connection_pool,
                 expected_maintenance_state=MaintenanceState.MOVING,
-                expected_maintenance_event_hash=hash(MOVING_NONE_EVENT),
+                expected_maintenance_notification_hash=hash(MOVING_NONE_NOTIFICATION),
                 expected_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_port=int(DEFAULT_ADDRESS.split(":")[1]),
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
@@ -1170,12 +1170,12 @@ def test_moving_none_events_handling_integration(self, pool_class):
                 expected_should_reconnect=False,
                 expected_state=MaintenanceState.MOVING,
                 expected_host_address=DEFAULT_ADDRESS.split(":")[0],
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
-                expected_current_socket_timeout=self.config.relax_timeout,
+                expected_current_socket_timeout=self.config.relaxed_timeout,
                 expected_current_peername=DEFAULT_ADDRESS.split(":")[
                     0
                 ],  # the in use connections reconnect when they complete their current task
@@ -1184,8 +1184,8 @@ def test_moving_none_events_handling_integration(self, pool_class):
                 pool=test_redis_client.connection_pool,
                 expected_state=MaintenanceState.MOVING,
                 expected_host_address=DEFAULT_ADDRESS.split(":")[0],
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
@@ -1199,12 +1199,12 @@ def test_moving_none_events_handling_integration(self, pool_class):
                 expected_should_reconnect=True,
                 expected_state=MaintenanceState.MOVING,
                 expected_host_address=DEFAULT_ADDRESS.split(":")[0],
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
-                expected_current_socket_timeout=self.config.relax_timeout,
+                expected_current_socket_timeout=self.config.relaxed_timeout,
                 expected_current_peername=DEFAULT_ADDRESS.split(":")[
                     0
                 ],  # the in use connections reconnect when they complete their current task
@@ -1229,7 +1229,7 @@ def test_moving_none_events_handling_integration(self, pool_class):
             Helpers.validate_conn_kwargs(
                 pool=test_redis_client.connection_pool,
                 expected_maintenance_state=MaintenanceState.NONE,
-                expected_maintenance_event_hash=None,
+                expected_maintenance_notification_hash=None,
                 expected_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_port=int(DEFAULT_ADDRESS.split(":")[1]),
                 expected_socket_timeout=None,
@@ -1257,14 +1257,14 @@ def test_moving_none_events_handling_integration(self, pool_class):
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
     def test_create_new_conn_while_moving_not_expired(self, pool_class):
         """
-        Test creating new connections while MOVING event is active (not expired).
+        Test creating new connections while MOVING notification is active (not expired).
 
         This test validates that:
-        1. After MOVING event is processed, new connections are created with temporary address
+        1. After MOVING notification is processed, new connections are created with temporary address
         2. New connections inherit the relaxed timeout settings
         3. Pool configuration is properly applied to newly created connections
         """
-        # Create a pool and Redis client with maintenance events and pool handler
+        # Create a pool and Redis client with maintenance notifications and pool handler
         test_redis_client = self._get_client(
             pool_class, max_connections=10, setup_pool_handler=True
         )
@@ -1285,10 +1285,10 @@ def test_create_new_conn_while_moving_not_expired(self, pool_class):
                 connection = test_redis_client.connection_pool.get_connection()
                 in_use_connections.append(connection)
 
-            # Validate all connections are connected prior MOVING event
+            # Validate all connections are connected prior MOVING notification
             self._validate_disconnected(0)
 
-            # Run command that will receive and handle MOVING event
+            # Run command that will receive and handle MOVING notification
             key_moving = "key_receive_moving_0"
             value_moving = "value3_0"
             result = test_redis_client.set(key_moving, value_moving)
@@ -1296,18 +1296,18 @@ def test_create_new_conn_while_moving_not_expired(self, pool_class):
             # Validate command result
             assert result is True, "SET key_receive_moving command failed"
 
-            # Validate pool and connections settings were updated according to MOVING event
+            # Validate pool and connections settings were updated according to MOVING notification
             Helpers.validate_conn_kwargs(
                 pool=test_redis_client.connection_pool,
                 expected_maintenance_state=MaintenanceState.MOVING,
-                expected_maintenance_event_hash=hash(MOVING_EVENT),
+                expected_maintenance_notification_hash=hash(MOVING_NOTIFICATION),
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_port=int(DEFAULT_ADDRESS.split(":")[1]),
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
                 expected_host_address=AFTER_MOVING_ADDRESS.split(":")[0],
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
             )
 
             # Now get several more connections to force creation of new ones
@@ -1319,11 +1319,11 @@ def test_create_new_conn_while_moving_not_expired(self, pool_class):
 
             new_connection = test_redis_client.connection_pool.get_connection()
 
-            # Validate that new connections are created with temporary address and relax timeout
+            # Validate that new connections are created with temporary address and relaxed timeout
             # and when connecting those configs are used
             # get_connection() returns a connection that is already connected
             assert new_connection.host == AFTER_MOVING_ADDRESS.split(":")[0]
-            assert new_connection.socket_timeout is self.config.relax_timeout
+            assert new_connection.socket_timeout is self.config.relaxed_timeout
             # New connections should be connected to the temporary address
             assert new_connection._sock is not None
             assert new_connection._sock.connected is True
@@ -1331,7 +1331,7 @@ def test_create_new_conn_while_moving_not_expired(self, pool_class):
                 new_connection._sock.getpeername()[0]
                 == AFTER_MOVING_ADDRESS.split(":")[0]
             )
-            assert new_connection._sock.gettimeout() == self.config.relax_timeout
+            assert new_connection._sock.gettimeout() == self.config.relaxed_timeout
 
         finally:
             if hasattr(test_redis_client.connection_pool, "disconnect"):
@@ -1340,14 +1340,14 @@ def test_create_new_conn_while_moving_not_expired(self, pool_class):
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
     def test_create_new_conn_after_moving_expires(self, pool_class):
         """
-        Test creating new connections after MOVING event expires.
+        Test creating new connections after MOVING notification expires.
 
         This test validates that:
         1. After MOVING timeout expires, new connections use original address
         2. Pool configuration is reset to original values
         3. New connections don't inherit temporary settings
         """
-        # Create a pool and Redis client with maintenance events and pool handler
+        # Create a pool and Redis client with maintenance notifications and pool handler
         test_redis_client = self._get_client(
             pool_class, max_connections=10, setup_pool_handler=True
         )
@@ -1368,7 +1368,7 @@ def test_create_new_conn_after_moving_expires(self, pool_class):
                 connection = test_redis_client.connection_pool.get_connection()
                 in_use_connections.append(connection)
 
-            # Run command that will receive and handle MOVING event
+            # Run command that will receive and handle MOVING notification
             key_moving = "key_receive_moving_0"
             value_moving = "value3_0"
             result = test_redis_client.set(key_moving, value_moving)
@@ -1403,18 +1403,18 @@ def test_create_new_conn_after_moving_expires(self, pool_class):
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
     def test_receive_migrated_after_moving(self, pool_class):
         """
-        Test receiving MIGRATED event after MOVING event.
+        Test receiving MIGRATED notification after MOVING notification.
 
         This test validates the complete MOVING -> MIGRATED lifecycle:
-        1. MOVING event is processed and temporary settings are applied
-        2. MIGRATED event is received during command execution
+        1. MOVING notification is processed and temporary settings are applied
+        2. MIGRATED notification is received during command execution
         3. Temporary settings are cleared after MIGRATED
         4. Pool configuration is restored to original values
 
         Note: When MIGRATED comes after MOVING and MOVING hasn't yet expired,
         it should not decrease timeouts (future refactoring consideration).
         """
-        # Create a pool and Redis client with maintenance events and pool handler
+        # Create a pool and Redis client with maintenance notifications and pool handler
         test_redis_client = self._get_client(
             pool_class, max_connections=10, setup_pool_handler=True
         )
@@ -1435,10 +1435,10 @@ def test_receive_migrated_after_moving(self, pool_class):
                 connection = test_redis_client.connection_pool.get_connection()
                 in_use_connections.append(connection)
 
-            # Validate all connections are connected prior MOVING event
+            # Validate all connections are connected prior MOVING notification
             self._validate_disconnected(0)
 
-            # Step 1: Run command that will receive and handle MOVING event
+            # Step 1: Run command that will receive and handle MOVING notification
             key_moving = "key_receive_moving_0"
             value_moving = "value3_0"
             result_moving = test_redis_client.set(key_moving, value_moving)
@@ -1446,23 +1446,23 @@ def test_receive_migrated_after_moving(self, pool_class):
             # Validate MOVING command result
             assert result_moving is True, "SET key_receive_moving command failed"
 
-            # Validate pool and connections settings were updated according to MOVING event
+            # Validate pool and connections settings were updated according to MOVING notification
             Helpers.validate_conn_kwargs(
                 pool=test_redis_client.connection_pool,
                 expected_maintenance_state=MaintenanceState.MOVING,
-                expected_maintenance_event_hash=hash(MOVING_EVENT),
+                expected_maintenance_notification_hash=hash(MOVING_NOTIFICATION),
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_port=int(DEFAULT_ADDRESS.split(":")[1]),
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
                 expected_host_address=AFTER_MOVING_ADDRESS.split(":")[0],
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
             )
 
             # TODO validate current socket timeout
 
-            # Step 2: Run command that will receive and handle MIGRATED event
+            # Step 2: Run command that will receive and handle MIGRATED notification
             # This should clear the temporary settings
             key_migrated = "key_receive_migrated_0"
             value_migrated = "migrated_value"
@@ -1471,21 +1471,21 @@ def test_receive_migrated_after_moving(self, pool_class):
             # Validate MIGRATED command result
             assert result_migrated is True, "SET key_receive_migrated command failed"
 
-            # Step 3: Validate that MIGRATED event was processed but MOVING settings remain
-            # (MIGRATED doesn't automatically clear MOVING settings - they are separate events)
+            # Step 3: Validate that MIGRATED notification was processed but MOVING settings remain
+            # (MIGRATED doesn't automatically clear MOVING settings - they are separate notifications)
             # MOVING settings should still be active
             # MOVING timeout should still be active
             Helpers.validate_conn_kwargs(
                 pool=test_redis_client.connection_pool,
                 expected_maintenance_state=MaintenanceState.MOVING,
-                expected_maintenance_event_hash=hash(MOVING_EVENT),
+                expected_maintenance_notification_hash=hash(MOVING_NOTIFICATION),
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_port=int(DEFAULT_ADDRESS.split(":")[1]),
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
                 expected_host_address=AFTER_MOVING_ADDRESS.split(":")[0],
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
             )
 
             # Step 4: Create new connections after MIGRATED to verify they still use MOVING settings
@@ -1498,7 +1498,7 @@ def test_receive_migrated_after_moving(self, pool_class):
             # Validate that new connections are created with MOVING settings (still active)
             for connection in new_connections:
                 assert connection.host == AFTER_MOVING_ADDRESS.split(":")[0]
-                # Note: New connections may not inherit the exact relax timeout value
+                # Note: New connections may not inherit the exact relaxed timeout value
                 # but they should have the temporary host address
                 # New connections should be connected
                 if connection._sock is not None:
@@ -1517,10 +1517,10 @@ def test_receive_migrated_after_moving(self, pool_class):
                 test_redis_client.connection_pool.disconnect()
 
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
-    def test_overlapping_moving_events(self, pool_class):
+    def test_overlapping_moving_notifications(self, pool_class):
         """
-        Test handling of overlapping/duplicate MOVING events (e.g., two MOVING events before the first expires).
-        Ensures that the second MOVING event updates the pool and connections as expected, and that expiry/cleanup works.
+        Test handling of overlapping/duplicate MOVING notifications (e.g., two MOVING notifications before the first expires).
+        Ensures that the second MOVING notification updates the pool and connections as expected, and that expiry/cleanup works.
         """
         global AFTER_MOVING_ADDRESS
         test_redis_client = self._get_client(
@@ -1543,7 +1543,7 @@ def test_overlapping_moving_events(self, pool_class):
                 conn = test_redis_client.connection_pool.get_connection()
                 in_use_connections.append(conn)
 
-            # Trigger first MOVING event
+            # Trigger first MOVING notification
             key_moving1 = "key_receive_moving_0"
             value_moving1 = "value3_0"
             result1 = test_redis_client.set(key_moving1, value_moving1)
@@ -1551,26 +1551,26 @@ def test_overlapping_moving_events(self, pool_class):
             Helpers.validate_conn_kwargs(
                 pool=test_redis_client.connection_pool,
                 expected_maintenance_state=MaintenanceState.MOVING,
-                expected_maintenance_event_hash=hash(MOVING_EVENT),
+                expected_maintenance_notification_hash=hash(MOVING_NOTIFICATION),
                 expected_host_address=AFTER_MOVING_ADDRESS.split(":")[0],
                 expected_port=int(DEFAULT_ADDRESS.split(":")[1]),
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
             )
-            # Validate all connections reflect the first MOVING event
+            # Validate all connections reflect the first MOVING notification
             Helpers.validate_in_use_connections_state(
                 in_use_connections,
                 expected_state=MaintenanceState.MOVING,
                 expected_host_address=AFTER_MOVING_ADDRESS.split(":")[0],
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
-                expected_current_socket_timeout=self.config.relax_timeout,
+                expected_current_socket_timeout=self.config.relaxed_timeout,
                 expected_current_peername=DEFAULT_ADDRESS.split(":")[0],
             )
             Helpers.validate_free_connections_state(
@@ -1579,8 +1579,8 @@ def test_overlapping_moving_events(self, pool_class):
                 connected_to_tmp_address=True,
                 expected_state=MaintenanceState.MOVING,
                 expected_host_address=AFTER_MOVING_ADDRESS.split(":")[0],
-                expected_socket_timeout=self.config.relax_timeout,
-                expected_socket_connect_timeout=self.config.relax_timeout,
+                expected_socket_timeout=self.config.relaxed_timeout,
+                expected_socket_connect_timeout=self.config.relaxed_timeout,
                 expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_orig_socket_timeout=None,
                 expected_orig_socket_connect_timeout=None,
@@ -1590,13 +1590,13 @@ def test_overlapping_moving_events(self, pool_class):
                 conn.disconnect()
                 conn.connect()
 
-            # Before the first MOVING expires, trigger a second MOVING event (simulate new address)
+            # Before the first MOVING expires, trigger a second MOVING notification (simulate new address)
             # Validate the orig properties are not changed!
             second_moving_address = "5.6.7.8:6380"
             orig_after_moving = AFTER_MOVING_ADDRESS
             # Temporarily modify the global constant for this test
             AFTER_MOVING_ADDRESS = second_moving_address
-            second_moving_event = NodeMovingEvent(
+            second_moving_notification = NodeMovingNotification(
                 id=1,
                 new_node_host=second_moving_address.split(":")[0],
                 new_node_port=int(second_moving_address.split(":")[1]),
@@ -1610,26 +1610,28 @@ def test_overlapping_moving_events(self, pool_class):
                 Helpers.validate_conn_kwargs(
                     pool=test_redis_client.connection_pool,
                     expected_maintenance_state=MaintenanceState.MOVING,
-                    expected_maintenance_event_hash=hash(second_moving_event),
+                    expected_maintenance_notification_hash=hash(
+                        second_moving_notification
+                    ),
                     expected_host_address=second_moving_address.split(":")[0],
                     expected_port=int(DEFAULT_ADDRESS.split(":")[1]),
-                    expected_socket_timeout=self.config.relax_timeout,
-                    expected_socket_connect_timeout=self.config.relax_timeout,
+                    expected_socket_timeout=self.config.relaxed_timeout,
+                    expected_socket_connect_timeout=self.config.relaxed_timeout,
                     expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                     expected_orig_socket_timeout=None,
                     expected_orig_socket_connect_timeout=None,
                 )
-                # Validate all connections reflect the second MOVING event
+                # Validate all connections reflect the second MOVING notification
                 Helpers.validate_in_use_connections_state(
                     in_use_connections,
                     expected_state=MaintenanceState.MOVING,
                     expected_host_address=second_moving_address.split(":")[0],
-                    expected_socket_timeout=self.config.relax_timeout,
-                    expected_socket_connect_timeout=self.config.relax_timeout,
+                    expected_socket_timeout=self.config.relaxed_timeout,
+                    expected_socket_connect_timeout=self.config.relaxed_timeout,
                     expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                     expected_orig_socket_timeout=None,
                     expected_orig_socket_connect_timeout=None,
-                    expected_current_socket_timeout=self.config.relax_timeout,
+                    expected_current_socket_timeout=self.config.relaxed_timeout,
                     expected_current_peername=orig_after_moving.split(":")[0],
                 )
                 # print(test_redis_client.connection_pool._available_connections)
@@ -1640,8 +1642,8 @@ def test_overlapping_moving_events(self, pool_class):
                     tmp_address=second_moving_address.split(":")[0],
                     expected_state=MaintenanceState.MOVING,
                     expected_host_address=second_moving_address.split(":")[0],
-                    expected_socket_timeout=self.config.relax_timeout,
-                    expected_socket_connect_timeout=self.config.relax_timeout,
+                    expected_socket_timeout=self.config.relaxed_timeout,
+                    expected_socket_connect_timeout=self.config.relaxed_timeout,
                     expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
                     expected_orig_socket_timeout=None,
                     expected_orig_socket_connect_timeout=None,
@@ -1654,7 +1656,7 @@ def test_overlapping_moving_events(self, pool_class):
             Helpers.validate_conn_kwargs(
                 pool=test_redis_client.connection_pool,
                 expected_maintenance_state=MaintenanceState.NONE,
-                expected_maintenance_event_hash=None,
+                expected_maintenance_notification_hash=None,
                 expected_host_address=DEFAULT_ADDRESS.split(":")[0],
                 expected_port=int(DEFAULT_ADDRESS.split(":")[1]),
                 expected_socket_timeout=None,
@@ -1668,10 +1670,10 @@ def test_overlapping_moving_events(self, pool_class):
                 test_redis_client.connection_pool.disconnect()
 
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
-    def test_thread_safety_concurrent_event_handling(self, pool_class):
+    def test_thread_safety_concurrent_notification_handling(self, pool_class):
         """
-        Test thread-safety under concurrent maintenance event handling.
-        Simulates multiple threads triggering MOVING events and performing operations concurrently.
+        Test thread-safety under concurrent maintenance notification handling.
+        Simulates multiple threads triggering MOVING notifications and performing operations concurrently.
         """
         import threading
 
@@ -1697,15 +1699,15 @@ def worker(idx):
             t.join()
         assert all(results), f"Not all threads succeeded: {results}"
         assert not errors, f"Errors occurred in threads: {errors}"
-        # After all threads, MOVING event should have been handled safely
+        # After all threads, MOVING notification should have been handled safely
         Helpers.validate_conn_kwargs(
             pool=test_redis_client.connection_pool,
             expected_maintenance_state=MaintenanceState.MOVING,
-            expected_maintenance_event_hash=hash(MOVING_EVENT),
+            expected_maintenance_notification_hash=hash(MOVING_NOTIFICATION),
             expected_host_address=AFTER_MOVING_ADDRESS.split(":")[0],
             expected_port=int(DEFAULT_ADDRESS.split(":")[1]),
-            expected_socket_timeout=self.config.relax_timeout,
-            expected_socket_connect_timeout=self.config.relax_timeout,
+            expected_socket_timeout=self.config.relaxed_timeout,
+            expected_socket_connect_timeout=self.config.relaxed_timeout,
             expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
             expected_orig_socket_timeout=None,
             expected_orig_socket_connect_timeout=None,
@@ -1717,17 +1719,17 @@ def worker(idx):
     @pytest.mark.parametrize("pool_class", [ConnectionPool, BlockingConnectionPool])
     def test_moving_migrating_migrated_moved_state_transitions(self, pool_class):
         """
-        Test moving configs are not lost if the per connection events get picked up after moving is handled.
-        Sequence of events: MOVING, MIGRATING, MIGRATED, FAILING_OVER, FAILED_OVER, MOVED.
-        Note: FAILING_OVER and FAILED_OVER events do not change the connection state when already in MOVING state.
-        Checks the state after each event for all connections and for new connections created during each state.
+        Test moving configs are not lost if the per connection notifications get picked up after moving is handled.
+        Sequence of notifications: MOVING, MIGRATING, MIGRATED, FAILING_OVER, FAILED_OVER, MOVED.
+        Note: FAILING_OVER and FAILED_OVER notifications do not change the connection state when already in MOVING state.
+        Checks the state after each notification for all connections and for new connections created during each state.
         """
         # Setup
         test_redis_client = self._get_client(
             pool_class, max_connections=5, setup_pool_handler=True
         )
         pool = test_redis_client.connection_pool
-        pool_handler = pool.connection_kwargs["maintenance_events_pool_handler"]
+        pool_handler = pool.connection_kwargs["maint_notifications_pool_handler"]
 
         # Create and release some connections
         in_use_connections = []
@@ -1745,23 +1747,23 @@ def test_moving_migrating_migrated_moved_state_transitions(self, pool_class):
             conn = pool.get_connection()
             in_use_connections.append(conn)
 
-        # 1. MOVING event
+        # 1. MOVING notification
         tmp_address = "22.23.24.25"
-        moving_event = NodeMovingEvent(
+        moving_notification = NodeMovingNotification(
             id=1, new_node_host=tmp_address, new_node_port=6379, ttl=1
         )
-        pool_handler.handle_event(moving_event)
+        pool_handler.handle_notification(moving_notification)
 
         Helpers.validate_in_use_connections_state(
             in_use_connections,
             expected_state=MaintenanceState.MOVING,
             expected_host_address=tmp_address,
-            expected_socket_timeout=self.config.relax_timeout,
-            expected_socket_connect_timeout=self.config.relax_timeout,
+            expected_socket_timeout=self.config.relaxed_timeout,
+            expected_socket_connect_timeout=self.config.relaxed_timeout,
             expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
             expected_orig_socket_timeout=None,
             expected_orig_socket_connect_timeout=None,
-            expected_current_socket_timeout=self.config.relax_timeout,
+            expected_current_socket_timeout=self.config.relaxed_timeout,
             expected_current_peername=DEFAULT_ADDRESS.split(":")[0],
         )
         Helpers.validate_free_connections_state(
@@ -1770,90 +1772,90 @@ def test_moving_migrating_migrated_moved_state_transitions(self, pool_class):
             connected_to_tmp_address=False,
             expected_state=MaintenanceState.MOVING,
             expected_host_address=tmp_address,
-            expected_socket_timeout=self.config.relax_timeout,
-            expected_socket_connect_timeout=self.config.relax_timeout,
+            expected_socket_timeout=self.config.relaxed_timeout,
+            expected_socket_connect_timeout=self.config.relaxed_timeout,
             expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
             expected_orig_socket_timeout=None,
             expected_orig_socket_connect_timeout=None,
         )
 
-        # 2. MIGRATING event (simulate direct connection handler call)
+        # 2. MIGRATING notification (simulate direct connection handler call)
         for conn in in_use_connections:
-            conn._maintenance_event_connection_handler.handle_event(
-                NodeMigratingEvent(id=2, ttl=1)
+            conn._maint_notifications_connection_handler.handle_notification(
+                NodeMigratingNotification(id=2, ttl=1)
             )
         Helpers.validate_in_use_connections_state(
             in_use_connections,
             expected_state=MaintenanceState.MOVING,
             expected_host_address=tmp_address,
-            expected_socket_timeout=self.config.relax_timeout,
-            expected_socket_connect_timeout=self.config.relax_timeout,
+            expected_socket_timeout=self.config.relaxed_timeout,
+            expected_socket_connect_timeout=self.config.relaxed_timeout,
             expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
             expected_orig_socket_timeout=None,
             expected_orig_socket_connect_timeout=None,
-            expected_current_socket_timeout=self.config.relax_timeout,
+            expected_current_socket_timeout=self.config.relaxed_timeout,
             expected_current_peername=DEFAULT_ADDRESS.split(":")[0],
         )
 
-        # 3. MIGRATED event (simulate direct connection handler call)
+        # 3. MIGRATED notification (simulate direct connection handler call)
         for conn in in_use_connections:
-            conn._maintenance_event_connection_handler.handle_event(
-                NodeMigratedEvent(id=2)
+            conn._maint_notifications_connection_handler.handle_notification(
+                NodeMigratedNotification(id=2)
             )
         # State should not change for connections that are in MOVING state
         Helpers.validate_in_use_connections_state(
             in_use_connections,
             expected_state=MaintenanceState.MOVING,
             expected_host_address=tmp_address,
-            expected_socket_timeout=self.config.relax_timeout,
-            expected_socket_connect_timeout=self.config.relax_timeout,
+            expected_socket_timeout=self.config.relaxed_timeout,
+            expected_socket_connect_timeout=self.config.relaxed_timeout,
             expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
             expected_orig_socket_timeout=None,
             expected_orig_socket_connect_timeout=None,
-            expected_current_socket_timeout=self.config.relax_timeout,
+            expected_current_socket_timeout=self.config.relaxed_timeout,
             expected_current_peername=DEFAULT_ADDRESS.split(":")[0],
         )
 
-        # 4. FAILING_OVER event (simulate direct connection handler call)
+        # 4. FAILING_OVER notification (simulate direct connection handler call)
         for conn in in_use_connections:
-            conn._maintenance_event_connection_handler.handle_event(
-                NodeFailingOverEvent(id=3, ttl=1)
+            conn._maint_notifications_connection_handler.handle_notification(
+                NodeFailingOverNotification(id=3, ttl=1)
             )
         # State should not change for connections that are in MOVING state
         Helpers.validate_in_use_connections_state(
             in_use_connections,
             expected_state=MaintenanceState.MOVING,
             expected_host_address=tmp_address,
-            expected_socket_timeout=self.config.relax_timeout,
-            expected_socket_connect_timeout=self.config.relax_timeout,
+            expected_socket_timeout=self.config.relaxed_timeout,
+            expected_socket_connect_timeout=self.config.relaxed_timeout,
             expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
             expected_orig_socket_timeout=None,
             expected_orig_socket_connect_timeout=None,
-            expected_current_socket_timeout=self.config.relax_timeout,
+            expected_current_socket_timeout=self.config.relaxed_timeout,
             expected_current_peername=DEFAULT_ADDRESS.split(":")[0],
         )
 
-        # 5. FAILED_OVER event (simulate direct connection handler call)
+        # 5. FAILED_OVER notification (simulate direct connection handler call)
         for conn in in_use_connections:
-            conn._maintenance_event_connection_handler.handle_event(
-                NodeFailedOverEvent(id=3)
+            conn._maint_notifications_connection_handler.handle_notification(
+                NodeFailedOverNotification(id=3)
             )
         # State should not change for connections that are in MOVING state
         Helpers.validate_in_use_connections_state(
             in_use_connections,
             expected_state=MaintenanceState.MOVING,
             expected_host_address=tmp_address,
-            expected_socket_timeout=self.config.relax_timeout,
-            expected_socket_connect_timeout=self.config.relax_timeout,
+            expected_socket_timeout=self.config.relaxed_timeout,
+            expected_socket_connect_timeout=self.config.relaxed_timeout,
             expected_orig_host_address=DEFAULT_ADDRESS.split(":")[0],
             expected_orig_socket_timeout=None,
             expected_orig_socket_connect_timeout=None,
-            expected_current_socket_timeout=self.config.relax_timeout,
+            expected_current_socket_timeout=self.config.relaxed_timeout,
             expected_current_peername=DEFAULT_ADDRESS.split(":")[0],
         )
 
-        # 6. MOVED event (simulate timer expiry)
-        pool_handler.handle_node_moved_event(moving_event)
+        # 6. MOVED notification (simulate timer expiry)
+        pool_handler.handle_node_moved_notification(moving_notification)
         Helpers.validate_in_use_connections_state(
             in_use_connections,
             expected_state=MaintenanceState.NONE,
@@ -1889,8 +1891,8 @@ def test_moving_migrating_migrated_moved_state_transitions(self, pool_class):
             pool.disconnect()
 
 
-class TestMaintenanceEventsHandlingMultipleProxies:
-    """Integration tests for maintenance events handling with real connection pool."""
+class TestMaintenanceNotificationsHandlingMultipleProxies:
+    """Integration tests for maintenance notifications handling with real connection pool."""
 
     def setup_method(self):
         """Set up test fixtures with mocked sockets."""
@@ -1950,9 +1952,9 @@ def mock_socket_getaddrinfo(host, port, family=0, type=0, proto=0, flags=0):
         )
         self.getaddrinfo_patcher.start()
 
-        # Create maintenance events config
-        self.config = MaintenanceEventsConfig(
-            enabled=True, proactive_reconnect=True, relax_timeout=30
+        # Create maintenance notifications config
+        self.config = MaintNotificationsConfig(
+            enabled=True, proactive_reconnect=True, relaxed_timeout=30
         )
 
     def teardown_method(self):
@@ -1970,13 +1972,13 @@ def test_migrating_after_moving_multiple_proxies(self, pool_class):
             host=self.orig_host,
             port=12345,
             max_connections=10,
-            protocol=3,  # Required for maintenance events
-            maintenance_events_config=self.config,
+            protocol=3,  # Required for maintenance notifications
+            maint_notifications_config=self.config,
         )
-        pool.set_maintenance_events_pool_handler(
-            MaintenanceEventPoolHandler(pool, self.config)
+        pool.set_maint_notifications_pool_handler(
+            MaintNotificationsPoolHandler(pool, self.config)
         )
-        pool_handler = pool.connection_kwargs["maintenance_events_pool_handler"]
+        pool_handler = pool.connection_kwargs["maint_notifications_pool_handler"]
 
         # Create and release some connections
         key1 = "1.2.3.4"
@@ -1992,12 +1994,14 @@ def test_migrating_after_moving_multiple_proxies(self, pool_class):
             while len(conns) > 1:
                 pool.release(conns.pop())
 
-        # Send MOVING event to con with ip = key1
+        # Send MOVING notification to con with ip = key1
         conn = in_use_connections[key1][0]
         pool_handler.set_connection(conn)
         new_ip = "13.14.15.16"
-        pool_handler.handle_event(
-            NodeMovingEvent(id=1, new_node_host=new_ip, new_node_port=6379, ttl=1)
+        pool_handler.handle_notification(
+            NodeMovingNotification(
+                id=1, new_node_host=new_ip, new_node_port=6379, ttl=1
+            )
         )
 
         # validate in use connection and ip1
@@ -2005,12 +2009,12 @@ def test_migrating_after_moving_multiple_proxies(self, pool_class):
             in_use_connections[key1],
             expected_state=MaintenanceState.MOVING,
             expected_host_address=new_ip,
-            expected_socket_timeout=self.config.relax_timeout,
-            expected_socket_connect_timeout=self.config.relax_timeout,
+            expected_socket_timeout=self.config.relaxed_timeout,
+            expected_socket_connect_timeout=self.config.relaxed_timeout,
             expected_orig_host_address=self.orig_host,
             expected_orig_socket_timeout=None,
             expected_orig_socket_connect_timeout=None,
-            expected_current_socket_timeout=self.config.relax_timeout,
+            expected_current_socket_timeout=self.config.relaxed_timeout,
             expected_current_peername=key1,
         )
         # validate free connections for ip1
@@ -2024,8 +2028,8 @@ def test_migrating_after_moving_multiple_proxies(self, pool_class):
                 changed_free_connections += 1
                 assert conn.maintenance_state == MaintenanceState.MOVING
                 assert conn.host == new_ip
-                assert conn.socket_timeout == self.config.relax_timeout
-                assert conn.socket_connect_timeout == self.config.relax_timeout
+                assert conn.socket_timeout == self.config.relaxed_timeout
+                assert conn.socket_connect_timeout == self.config.relaxed_timeout
                 assert conn.orig_host_address == self.orig_host
                 assert conn.orig_socket_timeout is None
                 assert conn.orig_socket_connect_timeout is None
@@ -2040,12 +2044,14 @@ def test_migrating_after_moving_multiple_proxies(self, pool_class):
         assert changed_free_connections == 2
         assert len(free_connections) == 4
 
-        # Send second MOVING event to con with ip = key2
+        # Send second MOVING notification to con with ip = key2
         conn = in_use_connections[key2][0]
         pool_handler.set_connection(conn)
         new_ip_2 = "17.18.19.20"
-        pool_handler.handle_event(
-            NodeMovingEvent(id=2, new_node_host=new_ip_2, new_node_port=6379, ttl=2)
+        pool_handler.handle_notification(
+            NodeMovingNotification(
+                id=2, new_node_host=new_ip_2, new_node_port=6379, ttl=2
+            )
         )
 
         # validate in use connection and ip2
@@ -2053,12 +2059,12 @@ def test_migrating_after_moving_multiple_proxies(self, pool_class):
             in_use_connections[key2],
             expected_state=MaintenanceState.MOVING,
             expected_host_address=new_ip_2,
-            expected_socket_timeout=self.config.relax_timeout,
-            expected_socket_connect_timeout=self.config.relax_timeout,
+            expected_socket_timeout=self.config.relaxed_timeout,
+            expected_socket_connect_timeout=self.config.relaxed_timeout,
             expected_orig_host_address=self.orig_host,
             expected_orig_socket_timeout=None,
             expected_orig_socket_connect_timeout=None,
-            expected_current_socket_timeout=self.config.relax_timeout,
+            expected_current_socket_timeout=self.config.relaxed_timeout,
             expected_current_peername=key2,
         )
         # validate free connections for ip2
@@ -2072,46 +2078,50 @@ def test_migrating_after_moving_multiple_proxies(self, pool_class):
                 changed_free_connections += 1
                 assert conn.maintenance_state == MaintenanceState.MOVING
                 assert conn.host == new_ip_2
-                assert conn.socket_timeout == self.config.relax_timeout
-                assert conn.socket_connect_timeout == self.config.relax_timeout
+                assert conn.socket_timeout == self.config.relaxed_timeout
+                assert conn.socket_connect_timeout == self.config.relaxed_timeout
                 assert conn.orig_host_address == self.orig_host
                 assert conn.orig_socket_timeout is None
                 assert conn.orig_socket_connect_timeout is None
             # here I can't validate the other connections since some of
-            # them are in MOVING state from the first event
+            # them are in MOVING state from the first notification
             # and some are in NONE state
         assert changed_free_connections == 1
 
-        # MIGRATING event on connection that has already been marked as MOVING
+        # MIGRATING notification on connection that has already been marked as MOVING
         conn = in_use_connections[key2][0]
-        conn_event_handler = conn._maintenance_event_connection_handler
-        conn_event_handler.handle_event(NodeMigratingEvent(id=3, ttl=1))
+        conn_notification_handler = conn._maint_notifications_connection_handler
+        conn_notification_handler.handle_notification(
+            NodeMigratingNotification(id=3, ttl=1)
+        )
         # validate connection does not lose its MOVING state
         assert conn.maintenance_state == MaintenanceState.MOVING
-        # MIGRATED event
-        conn_event_handler.handle_event(NodeMigratedEvent(id=3))
-        # validate connection does not lose its MOVING state and relax timeout
+        # MIGRATED notification
+        conn_notification_handler.handle_notification(NodeMigratedNotification(id=3))
+        # validate connection does not lose its MOVING state and relaxed timeout
         assert conn.maintenance_state == MaintenanceState.MOVING
-        assert conn.socket_timeout == self.config.relax_timeout
+        assert conn.socket_timeout == self.config.relaxed_timeout
 
-        # Send Migrating event to con with ip = key3
+        # Send Migrating notification to con with ip = key3
         conn = in_use_connections[key3][0]
-        conn_event_handler = conn._maintenance_event_connection_handler
-        conn_event_handler.handle_event(NodeMigratingEvent(id=3, ttl=1))
+        conn_notification_handler = conn._maint_notifications_connection_handler
+        conn_notification_handler.handle_notification(
+            NodeMigratingNotification(id=3, ttl=1)
+        )
         # validate connection is in MIGRATING state
         assert conn.maintenance_state == MaintenanceState.MAINTENANCE
 
-        assert conn.socket_timeout == self.config.relax_timeout
+        assert conn.socket_timeout == self.config.relaxed_timeout
 
-        # Send MIGRATED event to con with ip = key3
-        conn_event_handler.handle_event(NodeMigratedEvent(id=3))
+        # Send MIGRATED notification to con with ip = key3
+        conn_notification_handler.handle_notification(NodeMigratedNotification(id=3))
         # validate connection is in MOVING state
         assert conn.maintenance_state == MaintenanceState.NONE
         assert conn.socket_timeout is None
 
-        # sleep to expire only the first MOVING events
+        # sleep to expire only the first MOVING notifications
         sleep(1.3)
-        # validate only the connections affected by the first MOVING event
+        # validate only the connections affected by the first MOVING notification
         # have lost their MOVING state
         Helpers.validate_in_use_connections_state(
             in_use_connections[key1],
@@ -2129,12 +2139,12 @@ def test_migrating_after_moving_multiple_proxies(self, pool_class):
             in_use_connections[key2],
             expected_state=MaintenanceState.MOVING,
             expected_host_address=new_ip_2,
-            expected_socket_timeout=self.config.relax_timeout,
-            expected_socket_connect_timeout=self.config.relax_timeout,
+            expected_socket_timeout=self.config.relaxed_timeout,
+            expected_socket_connect_timeout=self.config.relaxed_timeout,
             expected_orig_host_address=self.orig_host,
             expected_orig_socket_timeout=None,
             expected_orig_socket_connect_timeout=None,
-            expected_current_socket_timeout=self.config.relax_timeout,
+            expected_current_socket_timeout=self.config.relaxed_timeout,
             expected_current_peername=key2,
         )
         Helpers.validate_in_use_connections_state(
@@ -2152,7 +2162,7 @@ def test_migrating_after_moving_multiple_proxies(self, pool_class):
         )
         # TODO validate free connections
 
-        # sleep to expire the second MOVING events
+        # sleep to expire the second MOVING notifications
         sleep(1)
         # validate all connections have lost their MOVING state
         Helpers.validate_in_use_connections_state(
diff --git a/tests/test_scenario/conftest.py b/tests/test_scenario/conftest.py
index 805941bbaf..afc4f5df1c 100644
--- a/tests/test_scenario/conftest.py
+++ b/tests/test_scenario/conftest.py
@@ -7,11 +7,11 @@
 
 from redis.backoff import ExponentialWithJitterBackoff, NoBackoff
 from redis.client import Redis
-from redis.maintenance_events import EndpointType, MaintenanceEventsConfig
+from redis.maintenance_events import EndpointType, MaintNotificationsConfig
 from redis.retry import Retry
 from tests.test_scenario.fault_injector_client import FaultInjectorClient
 
-RELAX_TIMEOUT = 30
+RELAXED_TIMEOUT = 30
 CLIENT_TIMEOUT = 5
 
 DEFAULT_ENDPOINT_NAME = "m-standard"
@@ -49,22 +49,22 @@ def fault_injector_client():
 
 
 @pytest.fixture()
-def client_maint_events(endpoints_config):
-    return _get_client_maint_events(endpoints_config)
+def client_maint_notifications(endpoints_config):
+    return _get_client_maint_notifications(endpoints_config)
 
 
-def _get_client_maint_events(
+def _get_client_maint_notifications(
     endpoints_config,
     protocol: int = 3,
-    enable_maintenance_events: bool = True,
+    enable_maintenance_notifications: bool = True,
     endpoint_type: Optional[EndpointType] = None,
-    enable_relax_timeout: bool = True,
+    enable_relaxed_timeout: bool = True,
     enable_proactive_reconnect: bool = True,
     disable_retries: bool = False,
     socket_timeout: Optional[float] = None,
     host_config: Optional[str] = None,
 ):
-    """Create Redis client with maintenance events enabled."""
+    """Create Redis client with maintenance notifications enabled."""
 
     # Get credentials from the configuration
     username = endpoints_config.get("username")
@@ -84,16 +84,16 @@ def _get_client_maint_events(
 
     logging.info(f"Connecting to Redis Enterprise: {host}:{port} with user: {username}")
 
-    # Configure maintenance events
-    maintenance_config = MaintenanceEventsConfig(
-        enabled=enable_maintenance_events,
+    # Configure maintenance notifications
+    maintenance_config = MaintNotificationsConfig(
+        enabled=enable_maintenance_notifications,
         proactive_reconnect=enable_proactive_reconnect,
-        relax_timeout=RELAX_TIMEOUT if enable_relax_timeout else -1,
+        relaxed_timeout=RELAXED_TIMEOUT if enable_relaxed_timeout else -1,
         endpoint_type=endpoint_type,
     )
 
-    # Create Redis client with maintenance events config
-    # This will automatically create the MaintenanceEventPoolHandler
+    # Create Redis client with maintenance notifications config
+    # This will automatically create the MaintNotificationsPoolHandler
     if disable_retries:
         retry = Retry(NoBackoff(), 0)
     else:
@@ -112,12 +112,14 @@ def _get_client_maint_events(
         ssl_cert_reqs="none",
         ssl_check_hostname=False,
         protocol=protocol,  # RESP3 required for push notifications
-        maintenance_events_config=maintenance_config,
+        maint_notifications_config=maintenance_config,
         retry=retry,
     )
-    logging.info("Redis client created with maintenance events enabled")
+    logging.info("Redis client created with maintenance notifications enabled")
     logging.info(f"Client uses Protocol: {client.connection_pool.get_protocol()}")
-    maintenance_handler_exists = client.maintenance_events_pool_handler is not None
-    logging.info(f"Maintenance events pool handler: {maintenance_handler_exists}")
+    maintenance_handler_exists = client.maint_notifications_pool_handler is not None
+    logging.info(
+        f"Maintenance notifications pool handler: {maintenance_handler_exists}"
+    )
 
     return client
diff --git a/tests/test_scenario/test_hitless_upgrade.py b/tests/test_scenario/test_hitless_upgrade.py
index f23be4d4b2..601b4b5a18 100644
--- a/tests/test_scenario/test_hitless_upgrade.py
+++ b/tests/test_scenario/test_hitless_upgrade.py
@@ -14,13 +14,13 @@
 from redis.connection import ConnectionInterface
 from redis.maintenance_events import (
     EndpointType,
-    MaintenanceEventsConfig,
+    MaintNotificationsConfig,
     MaintenanceState,
 )
 from tests.test_scenario.conftest import (
     CLIENT_TIMEOUT,
-    RELAX_TIMEOUT,
-    _get_client_maint_events,
+    RELAXED_TIMEOUT,
+    _get_client_maint_notifications,
 )
 from tests.test_scenario.fault_injector_client import (
     FaultInjectorClient,
@@ -51,7 +51,7 @@ class TestPushNotifications:
     @pytest.fixture(autouse=True)
     def setup_and_cleanup(
         self,
-        client_maint_events: Redis,
+        client_maint_notifications: Redis,
         fault_injector_client: FaultInjectorClient,
         endpoints_config: Dict[str, Any],
         endpoint_name: str,
@@ -96,7 +96,7 @@ def setup_and_cleanup(
         # Cleanup code - this will run even if the test fails
         logging.info("Starting cleanup...")
         try:
-            client_maint_events.close()
+            client_maint_notifications.close()
         except Exception as e:
             logging.error(f"Failed to close client: {e}")
 
@@ -227,7 +227,7 @@ def _validate_maintenance_state(
         for conn in connections:
             if (
                 conn._sock is not None
-                and conn._sock.gettimeout() == RELAX_TIMEOUT
+                and conn._sock.gettimeout() == RELAXED_TIMEOUT
                 and conn.maintenance_state == MaintenanceState.MAINTENANCE
             ):
                 matching_conns_count += 1
@@ -255,13 +255,13 @@ def _validate_moving_state(
                     and conn.host != conn.orig_host_address
                     and (
                         configured_endpoint_type
-                        == MaintenanceEventsConfig().get_endpoint_type(conn.host, conn)
+                        == MaintNotificationsConfig().get_endpoint_type(conn.host, conn)
                     )
                 )
             )
             if (
                 conn._sock is not None
-                and conn._sock.gettimeout() == RELAX_TIMEOUT
+                and conn._sock.gettimeout() == RELAXED_TIMEOUT
                 and conn.maintenance_state == MaintenanceState.MOVING
                 and endpoint_configured_correctly
             ):
@@ -269,7 +269,7 @@ def _validate_moving_state(
             elif (
                 conn._sock is None
                 and conn.maintenance_state == MaintenanceState.MOVING
-                and conn.socket_timeout == RELAX_TIMEOUT
+                and conn.socket_timeout == RELAXED_TIMEOUT
                 and endpoint_configured_correctly
             ):
                 matching_disconnected_conns_count += 1
@@ -330,7 +330,7 @@ def _validate_default_notif_disabled_state(
     @pytest.mark.timeout(300)  # 5 minutes timeout for this test
     def test_receive_failing_over_and_failed_over_push_notification(
         self,
-        client_maint_events: Redis,
+        client_maint_notifications: Redis,
         fault_injector_client: FaultInjectorClient,
         endpoints_config: Dict[str, Any],
     ):
@@ -339,7 +339,7 @@ def test_receive_failing_over_and_failed_over_push_notification(
 
         """
         logging.info("Creating one connection in the pool.")
-        conn = client_maint_events.connection_pool.get_connection()
+        conn = client_maint_notifications.connection_pool.get_connection()
 
         logging.info("Executing failover command...")
         failover_thread = Thread(
@@ -351,16 +351,16 @@ def test_receive_failing_over_and_failed_over_push_notification(
 
         logging.info("Waiting for FAILING_OVER push notifications...")
         ClientValidations.wait_push_notification(
-            client_maint_events, timeout=FAILOVER_TIMEOUT, connection=conn
+            client_maint_notifications, timeout=FAILOVER_TIMEOUT, connection=conn
         )
 
         logging.info("Validating connection maintenance state...")
         assert conn.maintenance_state == MaintenanceState.MAINTENANCE
-        assert conn._sock.gettimeout() == RELAX_TIMEOUT
+        assert conn._sock.gettimeout() == RELAXED_TIMEOUT
 
         logging.info("Waiting for FAILED_OVER push notifications...")
         ClientValidations.wait_push_notification(
-            client_maint_events, timeout=FAILOVER_TIMEOUT, connection=conn
+            client_maint_notifications, timeout=FAILOVER_TIMEOUT, connection=conn
         )
 
         logging.info("Validating connection default states is restored...")
@@ -368,14 +368,14 @@ def test_receive_failing_over_and_failed_over_push_notification(
         assert conn._sock.gettimeout() == CLIENT_TIMEOUT
 
         logging.info("Releasing connection back to the pool...")
-        client_maint_events.connection_pool.release(conn)
+        client_maint_notifications.connection_pool.release(conn)
 
         failover_thread.join()
 
     @pytest.mark.timeout(300)  # 5 minutes timeout for this test
     def test_receive_migrating_and_moving_push_notification(
         self,
-        client_maint_events: Redis,
+        client_maint_notifications: Redis,
         fault_injector_client: FaultInjectorClient,
         endpoints_config: Dict[str, Any],
     ):
@@ -399,25 +399,25 @@ def test_receive_migrating_and_moving_push_notification(
 
         logging.info("Waiting for MIGRATING push notifications...")
         ClientValidations.wait_push_notification(
-            client_maint_events, timeout=MIGRATE_TIMEOUT
+            client_maint_notifications, timeout=MIGRATE_TIMEOUT
         )
 
         logging.info("Validating connection migrating state...")
-        conn = client_maint_events.connection_pool.get_connection()
+        conn = client_maint_notifications.connection_pool.get_connection()
         assert conn.maintenance_state == MaintenanceState.MAINTENANCE
-        assert conn._sock.gettimeout() == RELAX_TIMEOUT
-        client_maint_events.connection_pool.release(conn)
+        assert conn._sock.gettimeout() == RELAXED_TIMEOUT
+        client_maint_notifications.connection_pool.release(conn)
 
         logging.info("Waiting for MIGRATED push notifications...")
         ClientValidations.wait_push_notification(
-            client_maint_events, timeout=MIGRATE_TIMEOUT
+            client_maint_notifications, timeout=MIGRATE_TIMEOUT
         )
 
         logging.info("Validating connection states...")
-        conn = client_maint_events.connection_pool.get_connection()
+        conn = client_maint_notifications.connection_pool.get_connection()
         assert conn.maintenance_state == MaintenanceState.NONE
         assert conn._sock.gettimeout() == CLIENT_TIMEOUT
-        client_maint_events.connection_pool.release(conn)
+        client_maint_notifications.connection_pool.release(conn)
 
         migrate_thread.join()
 
@@ -432,13 +432,13 @@ def test_receive_migrating_and_moving_push_notification(
 
         logging.info("Waiting for MOVING push notifications...")
         ClientValidations.wait_push_notification(
-            client_maint_events, timeout=BIND_TIMEOUT
+            client_maint_notifications, timeout=BIND_TIMEOUT
         )
 
         logging.info("Validating connection states...")
-        conn = client_maint_events.connection_pool.get_connection()
+        conn = client_maint_notifications.connection_pool.get_connection()
         assert conn.maintenance_state == MaintenanceState.MOVING
-        assert conn._sock.gettimeout() == RELAX_TIMEOUT
+        assert conn._sock.gettimeout() == RELAXED_TIMEOUT
 
         logging.info("Waiting for moving ttl to expire")
         time.sleep(BIND_TIMEOUT)
@@ -447,7 +447,7 @@ def test_receive_migrating_and_moving_push_notification(
         assert conn.maintenance_state == MaintenanceState.NONE
         assert conn.socket_timeout == CLIENT_TIMEOUT
         assert conn._sock.gettimeout() == CLIENT_TIMEOUT
-        client_maint_events.connection_pool.release(conn)
+        client_maint_notifications.connection_pool.release(conn)
         bind_thread.join()
 
     @pytest.mark.timeout(300)  # 5 minutes timeout
@@ -470,7 +470,7 @@ def test_timeout_handling_during_migrating_and_moving(
 
         """
         logging.info(f"Testing timeout handling for endpoint type: {endpoint_type}")
-        client = _get_client_maint_events(
+        client = _get_client_maint_notifications(
             endpoints_config=endpoints_config, endpoint_type=endpoint_type
         )
 
@@ -542,7 +542,7 @@ def test_timeout_handling_during_migrating_and_moving(
             expected_matching_disconnected_conns_count=3,
         )
         # during get_connection() the connection will be reconnected
-        # either to the address provided in the moving event or to the original address
+        # either to the address provided in the moving notification or to the original address
         # depending on the configured endpoint type
         # with this call we test if we are able to connect to the new address
         conn = client.connection_pool.get_connection()
@@ -577,7 +577,7 @@ def test_connection_handling_during_moving(
         endpoints_config: Dict[str, Any],
     ):
         logging.info(f"Testing timeout handling for endpoint type: {endpoint_type}")
-        client = _get_client_maint_events(
+        client = _get_client_maint_notifications(
             endpoints_config=endpoints_config, endpoint_type=endpoint_type
         )
 
@@ -637,7 +637,7 @@ def test_connection_handling_during_moving(
             )
             time.sleep(8)
 
-        # validate that new connections will also receive the moving event
+        # validate that new connections will also receive the moving notification
         connections = []
         for _ in range(3):
             connections.append(client.connection_pool.get_connection())
@@ -646,7 +646,7 @@ def test_connection_handling_during_moving(
 
         logging.info("Validating connections states during MOVING ...")
         # during get_connection() the existing connection will be reconnected
-        # either to the address provided in the moving event or to the original address
+        # either to the address provided in the moving notification or to the original address
         # depending on the configured endpoint type
         # with this call we test if we are able to connect to the new address
         # new connection should also be marked as moving
@@ -675,7 +675,7 @@ def test_old_connection_shutdown_during_moving(
         # and connected to the new address
         endpoint_type = EndpointType.EXTERNAL_IP
         logging.info("Testing old connection shutdown during MOVING")
-        client = _get_client_maint_events(
+        client = _get_client_maint_notifications(
             endpoints_config=endpoints_config, endpoint_type=endpoint_type
         )
 
@@ -753,12 +753,12 @@ def execute_commands(moving_event: threading.Event, errors: Queue):
             if conn._sock is not None:
                 assert conn.get_resolved_ip() == conn.host
                 assert conn.maintenance_state == MaintenanceState.MOVING
-                assert conn._sock.gettimeout() == RELAX_TIMEOUT
+                assert conn._sock.gettimeout() == RELAXED_TIMEOUT
                 assert conn.host != conn.orig_host_address
                 assert not conn.should_reconnect()
             else:
                 assert conn.maintenance_state == MaintenanceState.MOVING
-                assert conn.socket_timeout == RELAX_TIMEOUT
+                assert conn.socket_timeout == RELAXED_TIMEOUT
                 assert conn.host != conn.orig_host_address
                 assert not conn.should_reconnect()
 
@@ -772,12 +772,12 @@ def execute_commands(moving_event: threading.Event, errors: Queue):
     @pytest.mark.timeout(300)  # 5 minutes timeout
     def test_new_connections_receive_moving(
         self,
-        client_maint_events: Redis,
+        client_maint_notifications: Redis,
         fault_injector_client: FaultInjectorClient,
         endpoints_config: Dict[str, Any],
     ):
         logging.info("Creating one connection in the pool.")
-        first_conn = client_maint_events.connection_pool.get_connection()
+        first_conn = client_maint_notifications.connection_pool.get_connection()
 
         logging.info("Executing rladmin migrate command...")
         migrate_thread = Thread(
@@ -795,16 +795,16 @@ def test_new_connections_receive_moving(
         logging.info("Waiting for MIGRATING push notifications...")
         # this will consume the notification in the provided connection
         ClientValidations.wait_push_notification(
-            client_maint_events, timeout=MIGRATE_TIMEOUT, connection=first_conn
+            client_maint_notifications, timeout=MIGRATE_TIMEOUT, connection=first_conn
         )
 
         self._validate_maintenance_state(
-            client_maint_events, expected_matching_conns_count=1
+            client_maint_notifications, expected_matching_conns_count=1
         )
 
         logging.info("Waiting for MIGRATED push notifications on both connections ...")
         ClientValidations.wait_push_notification(
-            client_maint_events, timeout=MIGRATE_TIMEOUT, connection=first_conn
+            client_maint_notifications, timeout=MIGRATE_TIMEOUT, connection=first_conn
         )
 
         migrate_thread.join()
@@ -820,18 +820,18 @@ def test_new_connections_receive_moving(
 
         logging.info("Waiting for MOVING push notifications on random connection ...")
         ClientValidations.wait_push_notification(
-            client_maint_events, timeout=BIND_TIMEOUT, connection=first_conn
+            client_maint_notifications, timeout=BIND_TIMEOUT, connection=first_conn
         )
 
         old_address = first_conn._sock.getpeername()[0]
         logging.info(f"The node address before bind: {old_address}")
         logging.info(
-            "Creating new client to connect to the same node - new connections to this node should receive the moving event..."
+            "Creating new client to connect to the same node - new connections to this node should receive the moving notification..."
         )
 
         endpoint_type = EndpointType.EXTERNAL_IP
-        # create new client with new pool that should also receive the moving event
-        new_client = _get_client_maint_events(
+        # create new client with new pool that should also receive the moving notification
+        new_client = _get_client_maint_notifications(
             endpoints_config=endpoints_config,
             endpoint_type=endpoint_type,
             host_config=old_address,
@@ -841,7 +841,7 @@ def test_new_connections_receive_moving(
         # part of the client connection setup, so we don't need
         # to wait for it explicitly with wait_push_notification
         logging.info(
-            "Creating one connection in the new pool that should receive the moving event."
+            "Creating one connection in the new pool that should receive the moving notification."
         )
         new_client_conn = new_client.connection_pool.get_connection()
 
@@ -859,17 +859,17 @@ def test_new_connections_receive_moving(
         new_client.connection_pool.release(new_client_conn)
         new_client.close()
 
-        client_maint_events.connection_pool.release(first_conn)
+        client_maint_notifications.connection_pool.release(first_conn)
 
     @pytest.mark.timeout(300)  # 5 minutes timeout
     def test_new_connections_receive_migrating(
         self,
-        client_maint_events: Redis,
+        client_maint_notifications: Redis,
         fault_injector_client: FaultInjectorClient,
         endpoints_config: Dict[str, Any],
     ):
         logging.info("Creating one connection in the pool.")
-        first_conn = client_maint_events.connection_pool.get_connection()
+        first_conn = client_maint_notifications.connection_pool.get_connection()
 
         logging.info("Executing rladmin migrate command...")
         migrate_thread = Thread(
@@ -887,35 +887,37 @@ def test_new_connections_receive_migrating(
         logging.info("Waiting for MIGRATING push notifications...")
         # this will consume the notification in the provided connection
         ClientValidations.wait_push_notification(
-            client_maint_events, timeout=MIGRATE_TIMEOUT, connection=first_conn
+            client_maint_notifications, timeout=MIGRATE_TIMEOUT, connection=first_conn
         )
 
         self._validate_maintenance_state(
-            client_maint_events, expected_matching_conns_count=1
+            client_maint_notifications, expected_matching_conns_count=1
         )
 
-        # validate that new connections will also receive the migrating event
+        # validate that new connections will also receive the migrating notification
         # it should be received as part of the client connection setup flow
         logging.info(
-            "Creating second connection that should receive the migrating event as well."
+            "Creating second connection that should receive the migrating notification as well."
         )
-        second_connection = client_maint_events.connection_pool.get_connection()
+        second_connection = client_maint_notifications.connection_pool.get_connection()
         self._validate_maintenance_state(
-            client_maint_events, expected_matching_conns_count=2
+            client_maint_notifications, expected_matching_conns_count=2
         )
 
         logging.info("Waiting for MIGRATED push notifications on both connections ...")
         ClientValidations.wait_push_notification(
-            client_maint_events, timeout=MIGRATE_TIMEOUT, connection=first_conn
+            client_maint_notifications, timeout=MIGRATE_TIMEOUT, connection=first_conn
         )
         ClientValidations.wait_push_notification(
-            client_maint_events, timeout=MIGRATE_TIMEOUT, connection=second_connection
+            client_maint_notifications,
+            timeout=MIGRATE_TIMEOUT,
+            connection=second_connection,
         )
 
         migrate_thread.join()
 
-        client_maint_events.connection_pool.release(first_conn)
-        client_maint_events.connection_pool.release(second_connection)
+        client_maint_notifications.connection_pool.release(first_conn)
+        client_maint_notifications.connection_pool.release(second_connection)
 
     @pytest.mark.timeout(300)
     def test_disabled_handling_during_migrating_and_moving(
@@ -924,9 +926,9 @@ def test_disabled_handling_during_migrating_and_moving(
         endpoints_config: Dict[str, Any],
     ):
         logging.info("Creating client with disabled notifications.")
-        client = _get_client_maint_events(
+        client = _get_client_maint_notifications(
             endpoints_config=endpoints_config,
-            enable_maintenance_events=False,
+            enable_maintenance_notifications=False,
         )
 
         logging.info("Creating one connection in the pool.")
@@ -955,7 +957,7 @@ def test_disabled_handling_during_migrating_and_moving(
             client, expected_matching_conns_count=1
         )
 
-        # validate that new connections will not receive the migrating event
+        # validate that new connections will also receive the moving notification
         logging.info(
             "Creating second connection in the pool"
             " and expect it not to receive the migrating as well."
@@ -1007,7 +1009,7 @@ def test_disabled_handling_during_migrating_and_moving(
             fail_on_timeout=False,
         )
 
-        # validate that new connections will also receive the moving event
+        # validate that new connections will also receive the moving notification
         connections = []
         for _ in range(3):
             connections.append(client.connection_pool.get_connection())
@@ -1044,23 +1046,23 @@ def test_command_execution_during_migrating_and_moving(
         endpoint_type: EndpointType,
     ):
         """
-        Test command execution during migrating and moving events.
+        Test command execution during migrating and moving notifications.
 
         This test validates that:
-        1. Commands can be executed during MIGRATING and MOVING events
-        2. Commands are not blocked by the events
+        1. Commands can be executed during MIGRATING and MOVING notifications
+        2. Commands are not blocked by the notifications
         3. Commands are executed successfully
         """
         errors = Queue()
         execution_duration = 180
         socket_timeout = 0.5
 
-        client = _get_client_maint_events(
+        client = _get_client_maint_notifications(
             endpoints_config=endpoints_config,
             endpoint_type=endpoint_type,
             disable_retries=True,
             socket_timeout=socket_timeout,
-            enable_maintenance_events=True,
+            enable_maintenance_notifications=True,
         )
 
         migrate_and_bind_thread = Thread(