diff --git a/packages/client/lib/client/commands-queue.ts b/packages/client/lib/client/commands-queue.ts
index 52a07a7e3b..6893a04f14 100644
--- a/packages/client/lib/client/commands-queue.ts
+++ b/packages/client/lib/client/commands-queue.ts
@@ -1,10 +1,11 @@
-import { SinglyLinkedList, DoublyLinkedNode, DoublyLinkedList } from './linked-list';
+import { DoublyLinkedNode, DoublyLinkedList, EmptyAwareSinglyLinkedList } from './linked-list';
 import encodeCommand from '../RESP/encoder';
 import { Decoder, PUSH_TYPE_MAPPING, RESP_TYPES } from '../RESP/decoder';
 import { TypeMapping, ReplyUnion, RespVersions, RedisArgument } from '../RESP/types';
 import { ChannelListeners, PubSub, PubSubCommand, PubSubListener, PubSubType, PubSubTypeListeners } from './pub-sub';
-import { AbortError, ErrorReply, TimeoutError } from '../errors';
+import { AbortError, ErrorReply, CommandTimeoutDuringMaintananceError, TimeoutError } from '../errors';
 import { MonitorCallback } from '.';
+import { dbgMaintenance } from './enterprise-maintenance-manager';
 
 export interface CommandOptions<T = TypeMapping> {
   chainId?: symbol;
@@ -30,6 +31,7 @@ export interface CommandToWrite extends CommandWaitingForReply {
   timeout: {
     signal: AbortSignal;
     listener: () => unknown;
+    originalTimeout: number | undefined;
   } | undefined;
 }
 
@@ -50,22 +52,74 @@ const RESP2_PUSH_TYPE_MAPPING = {
   [RESP_TYPES.SIMPLE_STRING]: Buffer
 };
 
+// Try to handle a push notification. Return whether you
+// successfully consumed the notification or not. This is
+// important in order for the queue to be able to pass the
+// notification to another handler if the current one did not
+// succeed.
+type PushHandler = (pushItems: Array<any>) => boolean;
+
 export default class RedisCommandsQueue {
   readonly #respVersion;
   readonly #maxLength;
   readonly #toWrite = new DoublyLinkedList<CommandToWrite>();
-  readonly #waitingForReply = new SinglyLinkedList<CommandWaitingForReply>();
+  readonly #waitingForReply = new EmptyAwareSinglyLinkedList<CommandWaitingForReply>();
   readonly #onShardedChannelMoved;
   #chainInExecution: symbol | undefined;
   readonly decoder;
   readonly #pubSub = new PubSub();
 
+  #pushHandlers: PushHandler[] = [this.#onPush.bind(this)];
+
+  #maintenanceCommandTimeout: number | undefined
+
+  setMaintenanceCommandTimeout(ms: number | undefined) {
+    // Prevent possible api misuse
+    if (this.#maintenanceCommandTimeout === ms) {
+      dbgMaintenance(`Queue already set maintenanceCommandTimeout to ${ms}, skipping`);
+      return;
+    };
+
+    dbgMaintenance(`Setting maintenance command timeout to ${ms}`);
+    this.#maintenanceCommandTimeout = ms;
+
+    if(this.#maintenanceCommandTimeout === undefined) {
+      dbgMaintenance(`Queue will keep maintenanceCommandTimeout for exisitng commands, just to be on the safe side. New commands will receive normal timeouts`);
+      return;
+    }
+
+    let counter = 0;
+    const total = this.#toWrite.length;
+
+    // Overwrite timeouts of all eligible toWrite commands
+    for(const node of this.#toWrite.nodes()) {
+      const command = node.value;
+
+      // Remove timeout listener if it exists
+      RedisCommandsQueue.#removeTimeoutListener(command)
+
+      counter++;
+      const newTimeout = this.#maintenanceCommandTimeout;
+
+      // Overwrite the command's timeout
+      const signal = AbortSignal.timeout(newTimeout);
+      command.timeout = {
+        signal,
+        listener: () => {
+          this.#toWrite.remove(node);
+          command.reject(new CommandTimeoutDuringMaintananceError(newTimeout));
+        },
+        originalTimeout: command.timeout?.originalTimeout
+      };
+      signal.addEventListener('abort', command.timeout.listener, { once: true });
+    };
+    dbgMaintenance(`Total of ${counter} of ${total} timeouts reset to ${ms}`);
+  }
+
   get isPubSubActive() {
     return this.#pubSub.isActive;
   }
 
-  #invalidateCallback?: (key: RedisArgument | null) => unknown;
-
   constructor(
     respVersion: RespVersions,
     maxLength: number | null | undefined,
@@ -107,6 +161,7 @@ export default class RedisCommandsQueue {
       }
       return true;
     }
+    return false
   }
 
   #getTypeMapping() {
@@ -119,30 +174,27 @@ export default class RedisCommandsQueue {
       onErrorReply: err => this.#onErrorReply(err),
       //TODO: we can shave off a few cycles by not adding onPush handler at all if CSC is not used
       onPush: push => {
-        if (!this.#onPush(push)) {
-          // currently only supporting "invalidate" over RESP3 push messages
-          switch (push[0].toString()) {
-            case "invalidate": {
-              if (this.#invalidateCallback) {
-                if (push[1] !== null) {
-                  for (const key of push[1]) {
-                    this.#invalidateCallback(key);
-                  }
-                } else {
-                  this.#invalidateCallback(null);
-                }
-              }
-              break;
-            }
-          }
+        for(const pushHandler of this.#pushHandlers) {
+          if(pushHandler(push)) return
         }
       },
       getTypeMapping: () => this.#getTypeMapping()
     });
   }
 
-  setInvalidateCallback(callback?: (key: RedisArgument | null) => unknown) {
-    this.#invalidateCallback = callback;
+  addPushHandler(handler: PushHandler): void {
+    this.#pushHandlers.push(handler);
+  }
+
+  async waitForInflightCommandsToComplete(): Promise<void> {
+    // In-flight commands already completed
+    if(this.#waitingForReply.length === 0) {
+      return
+    };
+    // Otherwise wait for in-flight commands to fire `empty` event
+    return new Promise(resolve => {
+      this.#waitingForReply.events.on('empty', resolve)
+    });
   }
 
   addCommand<T>(
@@ -168,15 +220,20 @@ export default class RedisCommandsQueue {
         typeMapping: options?.typeMapping
       };
 
-      const timeout = options?.timeout;
+      // If #maintenanceCommandTimeout was explicitly set, we should
+      // use it instead of the timeout provided by the command
+      const timeout = this.#maintenanceCommandTimeout ?? options?.timeout;
+      const wasInMaintenance = this.#maintenanceCommandTimeout !== undefined;
       if (timeout) {
+
         const signal = AbortSignal.timeout(timeout);
         value.timeout = {
           signal,
           listener: () => {
             this.#toWrite.remove(node);
-            value.reject(new TimeoutError());
-          }
+            value.reject(wasInMaintenance ? new CommandTimeoutDuringMaintananceError(timeout) : new TimeoutError());
+          },
+          originalTimeout: options?.timeout
         };
         signal.addEventListener('abort', value.timeout.listener, { once: true });
       }
@@ -432,7 +489,7 @@ export default class RedisCommandsQueue {
   }
 
   static #removeTimeoutListener(command: CommandToWrite) {
-    command.timeout!.signal.removeEventListener('abort', command.timeout!.listener);
+    command.timeout?.signal.removeEventListener('abort', command.timeout!.listener);
   }
 
   static #flushToWrite(toBeSent: CommandToWrite, err: Error) {
diff --git a/packages/client/lib/client/enterprise-maintenance-manager.ts b/packages/client/lib/client/enterprise-maintenance-manager.ts
new file mode 100644
index 0000000000..98a95ccb1c
--- /dev/null
+++ b/packages/client/lib/client/enterprise-maintenance-manager.ts
@@ -0,0 +1,350 @@
+import { RedisClientOptions } from ".";
+import RedisCommandsQueue from "./commands-queue";
+import { RedisArgument } from "../..";
+import { isIP } from "net";
+import { lookup } from "dns/promises";
+import assert from "node:assert";
+import { setTimeout } from "node:timers/promises";
+import RedisSocket from "./socket";
+import diagnostics_channel from "node:diagnostics_channel";
+
+export const MAINTENANCE_EVENTS = {
+  PAUSE_WRITING: "pause-writing",
+  RESUME_WRITING: "resume-writing",
+  TIMEOUTS_UPDATE: "timeouts-update",
+} as const;
+
+const PN = {
+  MOVING: "MOVING",
+  MIGRATING: "MIGRATING",
+  MIGRATED: "MIGRATED",
+  FAILING_OVER: "FAILING_OVER",
+  FAILED_OVER: "FAILED_OVER",
+};
+
+export type DiagnosticsEvent = {
+  type: string;
+  timestamp: number;
+  data?: Object;
+};
+
+export const dbgMaintenance = (...args: any[]) => {
+  if (!process.env.DEBUG_MAINTENANCE) return;
+  return console.log("[MNT]", ...args);
+};
+
+export const emitDiagnostics = (event: DiagnosticsEvent) => {
+  if (!process.env.EMIT_DIAGNOSTICS) return;
+
+  const channel = diagnostics_channel.channel("redis.maintenance");
+  channel.publish(event);
+};
+
+export interface MaintenanceUpdate {
+  relaxedCommandTimeout?: number;
+  relaxedSocketTimeout?: number;
+}
+
+interface Client {
+  _ejectSocket: () => RedisSocket;
+  _insertSocket: (socket: RedisSocket) => void;
+  _pause: () => void;
+  _unpause: () => void;
+  _maintenanceUpdate: (update: MaintenanceUpdate) => void;
+  duplicate: (options: RedisClientOptions) => Client;
+  connect: () => Promise<Client>;
+  destroy: () => void;
+}
+
+export default class EnterpriseMaintenanceManager {
+  #commandsQueue: RedisCommandsQueue;
+  #options: RedisClientOptions;
+  #isMaintenance = 0;
+  #client: Client;
+
+  static setupDefaultMaintOptions(options: RedisClientOptions) {
+    if (options.maintPushNotifications === undefined) {
+      options.maintPushNotifications =
+        options?.RESP === 3 ? "auto" : "disabled";
+    }
+    if (options.maintMovingEndpointType === undefined) {
+      options.maintMovingEndpointType = "auto";
+    }
+    if (options.maintRelaxedSocketTimeout === undefined) {
+      options.maintRelaxedSocketTimeout = 10000;
+    }
+    if (options.maintRelaxedCommandTimeout === undefined) {
+      options.maintRelaxedCommandTimeout = 10000;
+    }
+  }
+
+  static async getHandshakeCommand(
+    tls: boolean,
+    host: string,
+    options: RedisClientOptions,
+  ): Promise<
+    | { cmd: Array<RedisArgument>; errorHandler: (error: Error) => void }
+    | undefined
+  > {
+    if (options.maintPushNotifications === "disabled") return;
+
+    const movingEndpointType = await determineEndpoint(tls, host, options);
+    return {
+      cmd: [
+        "CLIENT",
+        "MAINT_NOTIFICATIONS",
+        "ON",
+        "moving-endpoint-type",
+        movingEndpointType,
+      ],
+      errorHandler: (error: Error) => {
+        dbgMaintenance("handshake failed:", error);
+        if (options.maintPushNotifications === "enabled") {
+          throw error;
+        }
+      },
+    };
+  }
+
+  constructor(
+    commandsQueue: RedisCommandsQueue,
+    client: Client,
+    options: RedisClientOptions,
+  ) {
+    this.#commandsQueue = commandsQueue;
+    this.#options = options;
+    this.#client = client;
+
+    this.#commandsQueue.addPushHandler(this.#onPush);
+  }
+
+  #onPush = (push: Array<any>): boolean => {
+    dbgMaintenance("ONPUSH:", push.map(String));
+    
+    if (!Array.isArray(push) || !["MOVING", "MIGRATING", "MIGRATED", "FAILING_OVER", "FAILED_OVER"].includes(String(push[0]))) {
+      return false;
+    }
+
+    const type = String(push[0]);
+
+    emitDiagnostics({
+          type,
+          timestamp: Date.now(),
+          data: {
+            push: push.map(String),
+          },
+        });
+    switch (type) {
+      case PN.MOVING: {
+        // [ 'MOVING', '17', '15', '54.78.247.156:12075' ]
+        //             ^seq   ^after    ^new ip
+        const afterSeconds = push[2];
+        const url: string | null = push[3] ? String(push[3]) : null;
+        dbgMaintenance("Received MOVING:", afterSeconds, url);
+        this.#onMoving(afterSeconds, url);
+        return true;
+      }
+      case PN.MIGRATING:
+      case PN.FAILING_OVER: {
+        dbgMaintenance("Received MIGRATING|FAILING_OVER");
+        this.#onMigrating();
+        return true;
+      }
+      case PN.MIGRATED:
+      case PN.FAILED_OVER: {
+        dbgMaintenance("Received MIGRATED|FAILED_OVER");
+        this.#onMigrated();
+        return true;
+      }
+    }
+    return false;
+  };
+
+  //  Queue:
+  //     toWrite [ C D E ]
+  //     waitingForReply [ A B ]   - aka In-flight commands
+  //
+  //  time: ---1-2---3-4-5-6---------------------------
+  //
+  //  1. [EVENT] MOVING PN received
+  //  2. [ACTION] Pause writing ( we need to wait for new socket to connect and for all in-flight commands to complete )
+  //  3. [EVENT] New socket connected
+  //  4. [EVENT] In-flight commands completed
+  //  5. [ACTION] Destroy old socket
+  //  6. [ACTION] Resume writing -> we are going to write to the new socket from now on
+  #onMoving = async (
+    afterSeconds: number,
+    url: string | null,
+  ): Promise<void> => {
+    // 1 [EVENT] MOVING PN received
+    this.#onMigrating();
+
+    let host: string;
+    let port: number;
+
+    // The special value `none` indicates that the `MOVING` message doesn’t need
+    // to contain an endpoint. Instead it contains the value `null` then. In
+    // such a corner case, the client is expected to schedule a graceful
+    // reconnect to its currently configured endpoint after half of the grace
+    // period that was communicated by the server is over.
+    if (url === null) {
+      assert(this.#options.maintMovingEndpointType === "none");
+      assert(this.#options.socket !== undefined);
+      assert("host" in this.#options.socket);
+      assert(typeof this.#options.socket.host === "string");
+      host = this.#options.socket.host;
+      assert(typeof this.#options.socket.port === "number");
+      port = this.#options.socket.port;
+      const waitTime = (afterSeconds * 1000) / 2;
+      dbgMaintenance(`Wait for ${waitTime}ms`);
+      await setTimeout(waitTime);
+    } else {
+      const split = url.split(":");
+      host = split[0];
+      port = Number(split[1]);
+    }
+
+    // 2 [ACTION] Pause writing
+    dbgMaintenance("Pausing writing of new commands to old socket");
+    this.#client._pause();
+
+    dbgMaintenance("Creating new tmp client");
+    let start = performance.now();
+
+    const tmpOptions = this.#options;
+    // If the URL is provided, it takes precedense
+    if(tmpOptions.url) {
+      const u = new URL(tmpOptions.url);
+      u.hostname = host;
+      u.port = String(port);
+      tmpOptions.url = u.toString();
+    } else {
+      tmpOptions.socket = {
+        ...tmpOptions.socket,
+        host, port
+      }
+    }
+    const tmpClient = this.#client.duplicate(tmpOptions);
+    dbgMaintenance(`Tmp client created in ${( performance.now() - start ).toFixed(2)}ms`);
+    dbgMaintenance(`Connecting tmp client: ${host}:${port}`);
+    start = performance.now();
+    tmpClient._maintenanceUpdate({
+      relaxedCommandTimeout: this.#options.maintRelaxedCommandTimeout,
+      relaxedSocketTimeout: this.#options.maintRelaxedSocketTimeout,
+    });
+    await tmpClient.connect();
+    dbgMaintenance(`Connected to tmp client in ${(performance.now() - start).toFixed(2)}ms`);
+    // 3 [EVENT] New socket connected
+
+    //TODO
+    // dbgMaintenance(
+    //   `Set timeout for new socket to ${this.#options.maintRelaxedSocketTimeout}`,
+    // );
+    // newSocket.setMaintenanceTimeout(this.#options.maintRelaxedSocketTimeout);
+
+    dbgMaintenance(`Wait for all in-flight commands to complete`);
+    await this.#commandsQueue.waitForInflightCommandsToComplete();
+    dbgMaintenance(`In-flight commands completed`);
+    // 4 [EVENT] In-flight commands completed
+
+    dbgMaintenance("Swap client sockets...");
+    const oldSocket = this.#client._ejectSocket();
+    const newSocket = tmpClient._ejectSocket();
+    this.#client._insertSocket(newSocket);
+    tmpClient._insertSocket(oldSocket);
+    tmpClient.destroy();
+    dbgMaintenance("Swap client sockets done.");
+    // 5 + 6
+    dbgMaintenance("Resume writing");
+    this.#client._unpause();
+    this.#onMigrated();
+  };
+
+  #onMigrating = async () => {
+    this.#isMaintenance++;
+    if (this.#isMaintenance > 1) {
+      dbgMaintenance(`Timeout relaxation already done`);
+      return;
+    }
+
+    const update: MaintenanceUpdate = {
+      relaxedCommandTimeout: this.#options.maintRelaxedCommandTimeout,
+      relaxedSocketTimeout: this.#options.maintRelaxedSocketTimeout,
+    };
+
+    this.#client._maintenanceUpdate(update);
+  };
+
+  #onMigrated = async () => {
+    this.#isMaintenance--;
+    assert(this.#isMaintenance >= 0);
+    if (this.#isMaintenance > 0) {
+      dbgMaintenance(`Not ready to unrelax timeouts yet`);
+      return;
+    }
+
+    const update: MaintenanceUpdate = {
+      relaxedCommandTimeout: undefined,
+      relaxedSocketTimeout: undefined
+    };
+
+    this.#client._maintenanceUpdate(update);
+  };
+}
+
+export type MovingEndpointType =
+  | "auto"
+  | "internal-ip"
+  | "internal-fqdn"
+  | "external-ip"
+  | "external-fqdn"
+  | "none";
+
+function isPrivateIP(ip: string): boolean {
+  const version = isIP(ip);
+  if (version === 4) {
+    const octets = ip.split(".").map(Number);
+    return (
+      octets[0] === 10 ||
+      (octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31) ||
+      (octets[0] === 192 && octets[1] === 168)
+    );
+  }
+  if (version === 6) {
+    return (
+      ip.startsWith("fc") || // Unique local
+      ip.startsWith("fd") || // Unique local
+      ip === "::1" || // Loopback
+      ip.startsWith("fe80") // Link-local unicast
+    );
+  }
+  return false;
+}
+
+async function determineEndpoint(
+  tlsEnabled: boolean,
+  host: string,
+  options: RedisClientOptions,
+): Promise<MovingEndpointType> {
+  assert(options.maintMovingEndpointType !== undefined);
+  if (options.maintMovingEndpointType !== "auto") {
+    dbgMaintenance(
+      `Determine endpoint type: ${options.maintMovingEndpointType}`,
+    );
+    return options.maintMovingEndpointType;
+  }
+
+  const ip = isIP(host) ? host : (await lookup(host, { family: 0 })).address;
+
+  const isPrivate = isPrivateIP(ip);
+
+  let result: MovingEndpointType;
+  if (tlsEnabled) {
+    result = isPrivate ? "internal-fqdn" : "external-fqdn";
+  } else {
+    result = isPrivate ? "internal-ip" : "external-ip";
+  }
+
+  dbgMaintenance(`Determine endpoint type: ${result}`);
+  return result;
+}
diff --git a/packages/client/lib/client/index.ts b/packages/client/lib/client/index.ts
index 1a27ea8898..a09326e062 100644
--- a/packages/client/lib/client/index.ts
+++ b/packages/client/lib/client/index.ts
@@ -1,5 +1,5 @@
 import COMMANDS from '../commands';
-import RedisSocket, { RedisSocketOptions } from './socket';
+import RedisSocket, { RedisSocketOptions, RedisTcpSocketOptions } from './socket';
 import { BasicAuth, CredentialsError, CredentialsProvider, StreamingCredentialsProvider, UnableToObtainNewCredentialsError, Disposable } from '../authx';
 import RedisCommandsQueue, { CommandOptions } from './commands-queue';
 import { EventEmitter } from 'node:events';
@@ -20,6 +20,7 @@ import { BasicClientSideCache, ClientSideCacheConfig, ClientSideCacheProvider }
 import { BasicCommandParser, CommandParser } from './parser';
 import SingleEntryCache from '../single-entry-cache';
 import { version } from '../../package.json'
+import EnterpriseMaintenanceManager, { MaintenanceUpdate, MovingEndpointType } from './enterprise-maintenance-manager';
 
 export interface RedisClientOptions<
   M extends RedisModules = RedisModules,
@@ -144,7 +145,46 @@ export interface RedisClientOptions<
    * Tag to append to library name that is sent to the Redis server
    */
   clientInfoTag?: string;
-}
+  /**
+   * Controls how the client handles Redis Enterprise maintenance push notifications.
+   *
+   * - `disabled`: The feature is not used by the client.
+   * - `enabled`: The client attempts to enable the feature on the server. If the server responds with an error, the connection is interrupted.
+   * - `auto`: The client attempts to enable the feature on the server. If the server returns an error, the client disables the feature and continues.
+   *
+   * The default is `auto`.
+   */
+  maintPushNotifications?: 'disabled' | 'enabled' | 'auto';
+  /**
+   * Controls how the client requests the endpoint to reconnect to during a MOVING notification in Redis Enterprise maintenance.
+   *
+   * - `auto`: If the connection is opened to a name or IP address that is from/resolves to a reserved private IP range, request an internal endpoint (e.g., internal-ip), otherwise an external one. If TLS is enabled, then request a FQDN.
+   * - `internal-ip`: Enforce requesting the internal IP.
+   * - `internal-fqdn`: Enforce requesting the internal FQDN.
+   * - `external-ip`: Enforce requesting the external IP address.
+   * - `external-fqdn`: Enforce requesting the external FQDN.
+   * - `none`: Used to request a null endpoint, which tells the client to reconnect based on its current config
+
+   * The default is `auto`.
+   */
+  maintMovingEndpointType?: MovingEndpointType;
+  /**
+   * Specifies a more relaxed timeout (in milliseconds) for commands during a maintenance window.
+   * This helps minimize command timeouts during maintenance. If not provided, the `commandOptions.timeout`
+   * will be used instead. Timeouts during maintenance period result in a `CommandTimeoutDuringMaintanance` error.
+   *
+   * The default is 10000
+   */
+  maintRelaxedCommandTimeout?: number;
+  /**
+   * Specifies a more relaxed timeout (in milliseconds) for the socket during a maintenance window.
+   * This helps minimize socket timeouts during maintenance. If not provided, the `socket.timeout`
+   * will be used instead. Timeouts during maintenance period result in a `SocketTimeoutDuringMaintanance` error.
+   *
+   * The default is 10000
+   */
+  maintRelaxedSocketTimeout?: number;
+};
 
 type WithCommands<
   RESP extends RespVersions,
@@ -390,7 +430,7 @@ export default class RedisClient<
   }
 
   readonly #options?: RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>;
-  readonly #socket: RedisSocket;
+  #socket: RedisSocket;
   readonly #queue: RedisCommandsQueue;
   #selectedDB = 0;
   #monitorCallback?: MonitorCallback<TYPE_MAPPING>;
@@ -403,11 +443,16 @@ export default class RedisClient<
   #watchEpoch?: number;
   #clientSideCache?: ClientSideCacheProvider;
   #credentialsSubscription: Disposable | null = null;
+  // Flag used to pause writing to the socket during maintenance windows.
+  // When true, prevents new commands from being written while waiting for:
+  // 1. New socket to be ready after maintenance redirect
+  // 2. In-flight commands on the old socket to complete
+  #paused = false;
+
   get clientSideCache() {
     return this._self.#clientSideCache;
   }
 
-
   get options(): RedisClientOptions<M, F, S, RESP> | undefined {
     return this._self.#options;
   }
@@ -457,6 +502,11 @@ export default class RedisClient<
     this.#queue = this.#initiateQueue();
     this.#socket = this.#initiateSocket();
 
+
+    if(options?.maintPushNotifications !== 'disabled') {
+      new EnterpriseMaintenanceManager(this.#queue, this, this.#options!);
+    };
+
     if (options?.clientSideCache) {
       if (options.clientSideCache instanceof ClientSideCacheProvider) {
         this.#clientSideCache = options.clientSideCache;
@@ -464,7 +514,19 @@ export default class RedisClient<
         const cscConfig = options.clientSideCache;
         this.#clientSideCache = new BasicClientSideCache(cscConfig);
       }
-      this.#queue.setInvalidateCallback(this.#clientSideCache.invalidate.bind(this.#clientSideCache));
+      this.#queue.addPushHandler((push: Array<any>): boolean => {
+        if (push[0].toString() !== 'invalidate') return false;
+
+        if (push[1] !== null) {
+          for (const key of push[1]) {
+            this.#clientSideCache?.invalidate(key)
+          }
+        } else {
+          this.#clientSideCache?.invalidate(null)
+        }
+
+        return true
+      });
     }
   }
 
@@ -473,7 +535,12 @@ export default class RedisClient<
       throw new Error('Client Side Caching is only supported with RESP3');
     }
 
+    if (options?.maintPushNotifications && options?.maintPushNotifications !== 'disabled' && options?.RESP !== 3) {
+      throw new Error('Graceful Maintenance is only supported with RESP3');
+    }
+
   }
+
   #initiateOptions(options?: RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>): RedisClientOptions<M, F, S, RESP, TYPE_MAPPING> | undefined {
 
     // Convert username/password to credentialsProvider if no credentialsProvider is already in place
@@ -496,13 +563,15 @@ export default class RedisClient<
       this._commandOptions = options.commandOptions;
     }
 
+    if(options?.maintPushNotifications !== 'disabled') {
+      EnterpriseMaintenanceManager.setupDefaultMaintOptions(options!);
+    }
+
     if (options?.url) {
       const parsedOptions = RedisClient.parseOptions(options);
-    
       if (parsedOptions?.database) {
         this._self.#selectedDB = parsedOptions.database;
       }
-
       return parsedOptions;
     }
 
@@ -679,9 +748,44 @@ export default class RedisClient<
       commands.push({cmd: this.#clientSideCache.trackingOn()});
     }
 
+    const { tls, host } = this.#options!.socket as RedisTcpSocketOptions;
+    const maintenanceHandshakeCmd = await EnterpriseMaintenanceManager.getHandshakeCommand(!!tls, host!, this.#options!);
+    if(maintenanceHandshakeCmd) {
+      commands.push(maintenanceHandshakeCmd);
+    };
+
     return commands;
   }
 
+  #attachListeners(socket: RedisSocket) {
+    socket.on('data', chunk => {
+      try {
+        this.#queue.decoder.write(chunk);
+      } catch (err) {
+        this.#queue.resetDecoder();
+        this.emit('error', err);
+      }
+    })
+    .on('error', err => {
+      this.emit('error', err);
+      this.#clientSideCache?.onError();
+      if (this.#socket.isOpen && !this.#options?.disableOfflineQueue) {
+        this.#queue.flushWaitingForReply(err);
+      } else {
+        this.#queue.flushAll(err);
+      }
+    })
+    .on('connect', () => this.emit('connect'))
+    .on('ready', () => {
+      this.emit('ready');
+      this.#setPingTimer();
+      this.#maybeScheduleWrite();
+    })
+    .on('reconnecting', () => this.emit('reconnecting'))
+    .on('drain', () => this.#maybeScheduleWrite())
+    .on('end', () => this.emit('end'));
+  }
+
   #initiateSocket(): RedisSocket {
     const socketInitiator = async () => {
       const promises = [],
@@ -713,33 +817,9 @@ export default class RedisClient<
       }
     };
 
-    return new RedisSocket(socketInitiator, this.#options?.socket)
-      .on('data', chunk => {
-        try {
-          this.#queue.decoder.write(chunk);
-        } catch (err) {
-          this.#queue.resetDecoder();
-          this.emit('error', err);
-        }
-      })
-      .on('error', err => {
-        this.emit('error', err);
-        this.#clientSideCache?.onError();
-        if (this.#socket.isOpen && !this.#options?.disableOfflineQueue) {
-          this.#queue.flushWaitingForReply(err);
-        } else {
-          this.#queue.flushAll(err);
-        }
-      })
-      .on('connect', () => this.emit('connect'))
-      .on('ready', () => {
-        this.emit('ready');
-        this.#setPingTimer();
-        this.#maybeScheduleWrite();
-      })
-      .on('reconnecting', () => this.emit('reconnecting'))
-      .on('drain', () => this.#maybeScheduleWrite())
-      .on('end', () => this.emit('end'));
+    const socket = new RedisSocket(socketInitiator, this.#options?.socket);
+    this.#attachListeners(socket);
+    return socket;
   }
 
   #pingTimer?: NodeJS.Timeout;
@@ -851,6 +931,51 @@ export default class RedisClient<
     return this as unknown as RedisClientType<M, F, S, RESP, TYPE_MAPPING>;
   }
 
+  /**
+   * @internal
+   */
+   _ejectSocket(): RedisSocket {
+     const socket = this._self.#socket;
+     // @ts-ignore
+     this._self.#socket = null;
+     socket.removeAllListeners();
+     return socket;
+   }
+
+   /**
+    * @intenal
+    */
+   _insertSocket(socket: RedisSocket) {
+     if(this._self.#socket) {
+      this._self._ejectSocket().destroy();
+     }
+     this._self.#socket = socket;
+     this._self.#attachListeners(this._self.#socket);
+   }
+
+   /**
+    * @internal
+    */
+   _maintenanceUpdate(update: MaintenanceUpdate) {
+     this._self.#socket.setMaintenanceTimeout(update.relaxedSocketTimeout);
+     this._self.#queue.setMaintenanceCommandTimeout(update.relaxedCommandTimeout);
+   }
+
+   /**
+    * @internal
+    */
+   _pause() {
+     this._self.#paused = true;
+   }
+
+   /**
+    * @internal
+    */
+   _unpause() {
+     this._self.#paused = false;
+     this._self.#maybeScheduleWrite();
+   }
+
   /**
    * @internal
    */
@@ -1080,6 +1205,9 @@ export default class RedisClient<
   }
 
   #write() {
+    if(this.#paused) {
+      return
+    }
     this.#socket.write(this.#queue.commandsToWrite());
   }
 
diff --git a/packages/client/lib/client/linked-list.spec.ts b/packages/client/lib/client/linked-list.spec.ts
index 9547fb81c7..c791d21900 100644
--- a/packages/client/lib/client/linked-list.spec.ts
+++ b/packages/client/lib/client/linked-list.spec.ts
@@ -1,138 +1,197 @@
-import { SinglyLinkedList, DoublyLinkedList } from './linked-list';
-import { equal, deepEqual } from 'assert/strict';
-
-describe('DoublyLinkedList', () => {
+import {
+  SinglyLinkedList,
+  DoublyLinkedList,
+  EmptyAwareSinglyLinkedList,
+} from "./linked-list";
+import { equal, deepEqual } from "assert/strict";
+
+describe("DoublyLinkedList", () => {
   const list = new DoublyLinkedList();
 
-  it('should start empty', () => {
+  it("should start empty", () => {
     equal(list.length, 0);
     equal(list.head, undefined);
     equal(list.tail, undefined);
     deepEqual(Array.from(list), []);
   });
 
-  it('shift empty', () => {
+  it("shift empty", () => {
     equal(list.shift(), undefined);
     equal(list.length, 0);
     deepEqual(Array.from(list), []);
   });
 
-  it('push 1', () => {
+  it("push 1", () => {
     list.push(1);
     equal(list.length, 1);
     deepEqual(Array.from(list), [1]);
   });
 
-  it('push 2', () => {
+  it("push 2", () => {
     list.push(2);
     equal(list.length, 2);
     deepEqual(Array.from(list), [1, 2]);
   });
 
-  it('unshift 0', () => {
+  it("unshift 0", () => {
     list.unshift(0);
     equal(list.length, 3);
     deepEqual(Array.from(list), [0, 1, 2]);
   });
 
-  it('remove middle node', () => {
+  it("remove middle node", () => {
     list.remove(list.head!.next!);
     equal(list.length, 2);
     deepEqual(Array.from(list), [0, 2]);
   });
 
-  it('remove head', () => {
+  it("remove head", () => {
     list.remove(list.head!);
     equal(list.length, 1);
     deepEqual(Array.from(list), [2]);
   });
 
-  it('remove tail', () => {
+  it("remove tail", () => {
     list.remove(list.tail!);
     equal(list.length, 0);
     deepEqual(Array.from(list), []);
   });
 
-  it('unshift empty queue', () => {
+  it("unshift empty queue", () => {
     list.unshift(0);
     equal(list.length, 1);
     deepEqual(Array.from(list), [0]);
   });
 
-  it('push 1', () => {
+  it("push 1", () => {
     list.push(1);
     equal(list.length, 2);
     deepEqual(Array.from(list), [0, 1]);
   });
 
-  it('shift', () => {
+  it("shift", () => {
     equal(list.shift(), 0);
     equal(list.length, 1);
     deepEqual(Array.from(list), [1]);
   });
 
-  it('shift last element', () => {
+  it("shift last element", () => {
     equal(list.shift(), 1);
     equal(list.length, 0);
     deepEqual(Array.from(list), []);
   });
+
+  it("provide forEach for nodes", () => {
+    list.reset();
+    list.push(1);
+    list.push(2);
+    list.push(3);
+    let count = 0;
+    for(const _ of list.nodes()) {
+      count++;
+    }
+    equal(count, 3);
+    for(const _ of list.nodes()) {
+      count++;
+    }
+    equal(count, 6);
+  });
 });
 
-describe('SinglyLinkedList', () => {
+describe("SinglyLinkedList", () => {
   const list = new SinglyLinkedList();
 
-  it('should start empty', () => {
+  it("should start empty", () => {
     equal(list.length, 0);
     equal(list.head, undefined);
     equal(list.tail, undefined);
     deepEqual(Array.from(list), []);
   });
 
-  it('shift empty', () => {
+  it("shift empty", () => {
     equal(list.shift(), undefined);
     equal(list.length, 0);
     deepEqual(Array.from(list), []);
   });
 
-  it('push 1', () => {
+  it("push 1", () => {
     list.push(1);
     equal(list.length, 1);
     deepEqual(Array.from(list), [1]);
   });
 
-  it('push 2', () => {
+  it("push 2", () => {
     list.push(2);
     equal(list.length, 2);
     deepEqual(Array.from(list), [1, 2]);
   });
 
-  it('push 3', () => {
+  it("push 3", () => {
     list.push(3);
     equal(list.length, 3);
     deepEqual(Array.from(list), [1, 2, 3]);
   });
 
-  it('shift 1', () => {
+  it("shift 1", () => {
     equal(list.shift(), 1);
     equal(list.length, 2);
     deepEqual(Array.from(list), [2, 3]);
   });
 
-  it('shift 2', () => {
+  it("shift 2", () => {
     equal(list.shift(), 2);
     equal(list.length, 1);
     deepEqual(Array.from(list), [3]);
   });
 
-  it('shift 3', () => {
+  it("shift 3", () => {
     equal(list.shift(), 3);
     equal(list.length, 0);
     deepEqual(Array.from(list), []);
   });
 
-  it('should be empty', () => {
+  it("should be empty", () => {
     equal(list.length, 0);
     equal(list.head, undefined);
     equal(list.tail, undefined);
   });
 });
+
+describe("EmptyAwareSinglyLinkedList", () => {
+  it("should emit 'empty' event when reset", () => {
+    const list = new EmptyAwareSinglyLinkedList<number>();
+    let count = 0;
+    list.events.on("empty", () => count++);
+    list.push(1);
+    list.reset();
+    equal(count, 1);
+    list.reset();
+    equal(count, 1);
+  });
+
+  it("should emit 'empty' event when shift makes the list empty", () => {
+    const list = new EmptyAwareSinglyLinkedList<number>();
+    let count = 0;
+    list.events.on("empty", () => count++);
+    list.push(1);
+    list.push(2);
+    list.shift();
+    equal(count, 0);
+    list.shift();
+    equal(count, 1);
+    list.shift();
+    equal(count, 1);
+  });
+
+  it("should emit 'empty' event when remove makes the list empty", () => {
+    const list = new EmptyAwareSinglyLinkedList<number>();
+    let count = 0;
+    list.events.on("empty", () => count++);
+    const node1 = list.push(1);
+    const node2 = list.push(2);
+    list.remove(node1, undefined);
+    equal(count, 0);
+    list.remove(node2, undefined);
+    equal(count, 1);
+  });
+});
diff --git a/packages/client/lib/client/linked-list.ts b/packages/client/lib/client/linked-list.ts
index 29678f027b..461f1d4082 100644
--- a/packages/client/lib/client/linked-list.ts
+++ b/packages/client/lib/client/linked-list.ts
@@ -1,3 +1,5 @@
+import EventEmitter from "events";
+
 export interface DoublyLinkedNode<T> {
   value: T;
   previous: DoublyLinkedNode<T> | undefined;
@@ -32,7 +34,7 @@ export class DoublyLinkedList<T> {
         next: undefined,
         value
       };
-    } 
+    }
 
     return this.#tail = this.#tail.next = {
       previous: this.#tail,
@@ -93,7 +95,7 @@ export class DoublyLinkedList<T> {
       node.previous!.next = node.next;
       node.previous = undefined;
     }
-    
+
     node.next = undefined;
   }
 
@@ -109,6 +111,14 @@ export class DoublyLinkedList<T> {
       node = node.next;
     }
   }
+
+  *nodes() {
+    let node = this.#head;
+    while(node) {
+      yield node;
+      node = node.next;
+    }
+  }
 }
 
 export interface SinglyLinkedNode<T> {
@@ -201,3 +211,30 @@ export class SinglyLinkedList<T> {
     }
   }
 }
+
+export class EmptyAwareSinglyLinkedList<T> extends SinglyLinkedList<T> {
+  readonly events = new EventEmitter();
+  reset() {
+    const old = this.length;
+    super.reset();
+    if(old !== this.length && this.length === 0) {
+      this.events.emit('empty');
+    }
+  }
+  shift(): T | undefined {
+    const old = this.length;
+    const ret = super.shift();
+    if(old !== this.length && this.length === 0) {
+      this.events.emit('empty');
+    }
+    return ret;
+  }
+  remove(node: SinglyLinkedNode<T>, parent: SinglyLinkedNode<T> | undefined) {
+    const old = this.length;
+    super.remove(node, parent);
+    if(old !== this.length && this.length === 0) {
+      this.events.emit('empty');
+    }
+  }
+
+}
diff --git a/packages/client/lib/client/socket.ts b/packages/client/lib/client/socket.ts
index 5f0bcc4492..9d8ebdae07 100644
--- a/packages/client/lib/client/socket.ts
+++ b/packages/client/lib/client/socket.ts
@@ -1,9 +1,10 @@
 import { EventEmitter, once } from 'node:events';
 import net from 'node:net';
 import tls from 'node:tls';
-import { ConnectionTimeoutError, ClientClosedError, SocketClosedUnexpectedlyError, ReconnectStrategyError, SocketTimeoutError } from '../errors';
+import { ConnectionTimeoutError, ClientClosedError, SocketClosedUnexpectedlyError, ReconnectStrategyError, SocketTimeoutError, SocketTimeoutDuringMaintananceError } from '../errors';
 import { setTimeout } from 'node:timers/promises';
 import { RedisArgument } from '../RESP/types';
+import { dbgMaintenance } from './enterprise-maintenance-manager';
 
 type NetOptions = {
   tls?: false;
@@ -60,6 +61,8 @@ export default class RedisSocket extends EventEmitter {
   readonly #socketFactory;
   readonly #socketTimeout;
 
+  #maintenanceTimeout: number | undefined;
+
   #socket?: net.Socket | tls.TLSSocket;
 
   #isOpen = false;
@@ -238,6 +241,22 @@ export default class RedisSocket extends EventEmitter {
     } while (this.#isOpen && !this.#isReady);
   }
 
+  setMaintenanceTimeout(ms?: number) {
+    dbgMaintenance(`Set socket timeout to ${ms}`);
+    if (this.#maintenanceTimeout === ms) {
+      dbgMaintenance(`Socket already set maintenanceCommandTimeout to ${ms}, skipping`);
+      return;
+    };
+
+    this.#maintenanceTimeout = ms;
+
+    if(ms !== undefined) {
+      this.#socket?.setTimeout(ms);
+    } else {
+      this.#socket?.setTimeout(this.#socketTimeout ?? 0);
+    }
+  }
+
   async #createSocket(): Promise<net.Socket | tls.TLSSocket> {
     const socket = this.#socketFactory.create();
 
@@ -260,7 +279,10 @@ export default class RedisSocket extends EventEmitter {
 
     if (this.#socketTimeout) {
       socket.once('timeout', () => {
-        socket.destroy(new SocketTimeoutError(this.#socketTimeout!));
+        const error = this.#maintenanceTimeout
+          ? new SocketTimeoutDuringMaintananceError(this.#maintenanceTimeout)
+          : new SocketTimeoutError(this.#socketTimeout!)
+        socket.destroy(error);
       });
       socket.setTimeout(this.#socketTimeout);
     }
diff --git a/packages/client/lib/errors.ts b/packages/client/lib/errors.ts
index 5cb9166df0..ae4d598abd 100644
--- a/packages/client/lib/errors.ts
+++ b/packages/client/lib/errors.ts
@@ -71,6 +71,18 @@ export class BlobError extends ErrorReply {}
 
 export class TimeoutError extends Error {}
 
+export class SocketTimeoutDuringMaintananceError extends TimeoutError {
+  constructor(timeout: number) {
+    super(`Socket timeout during maintenance. Expecting data, but didn't receive any in ${timeout}ms.`);
+  }
+}
+
+export class CommandTimeoutDuringMaintananceError extends TimeoutError {
+  constructor(timeout: number) {
+    super(`Command timeout during maintenance. Waited to write command for more than ${timeout}ms.`);
+  }
+}
+
 export class MultiErrorReply extends ErrorReply {
   replies: Array<ErrorReply>;
   errorIndexes: Array<number>;
diff --git a/packages/client/lib/tests/test-scenario/fault-injector-client.ts b/packages/client/lib/tests/test-scenario/fault-injector-client.ts
new file mode 100644
index 0000000000..71af81dbb8
--- /dev/null
+++ b/packages/client/lib/tests/test-scenario/fault-injector-client.ts
@@ -0,0 +1,191 @@
+import { setTimeout } from "node:timers/promises";
+
+export type ActionType =
+  | "dmc_restart"
+  | "failover"
+  | "reshard"
+  | "sequence_of_actions"
+  | "network_failure"
+  | "execute_rlutil_command"
+  | "execute_rladmin_command"
+  | "migrate"
+  | "bind";
+
+export interface ActionRequest {
+  type: ActionType;
+  parameters?: {
+    bdb_id?: string;
+    [key: string]: unknown;
+  };
+}
+
+export interface ActionStatus {
+  status: string;
+  error: unknown;
+  output: string;
+}
+
+export class FaultInjectorClient {
+  private baseUrl: string;
+  #fetch: typeof fetch;
+
+  constructor(baseUrl: string, fetchImpl: typeof fetch = fetch) {
+    this.baseUrl = baseUrl.replace(/\/+$/, ""); // trim trailing slash
+    this.#fetch = fetchImpl;
+  }
+
+  /**
+   * Lists all available actions.
+   * @throws {Error} When the HTTP request fails or response cannot be parsed as JSON
+   */
+  public listActions<T = unknown>(): Promise<T> {
+    return this.#request<T>("GET", "/action");
+  }
+
+  /**
+   * Triggers a specific action.
+   * @param action The action request to trigger
+   * @throws {Error} When the HTTP request fails or response cannot be parsed as JSON
+   */
+  public triggerAction<T = unknown>(action: ActionRequest): Promise<T> {
+    return this.#request<T>("POST", "/action", action);
+  }
+
+  /**
+   * Gets the status of a specific action.
+   * @param actionId The ID of the action to check
+   * @throws {Error} When the HTTP request fails or response cannot be parsed as JSON
+   */
+  public getActionStatus<T = ActionStatus>(actionId: string): Promise<T> {
+    return this.#request<T>("GET", `/action/${actionId}`);
+  }
+
+  /**
+   * Executes an rladmin command.
+   * @param command The rladmin command to execute
+   * @param bdbId Optional database ID to target
+   * @throws {Error} When the HTTP request fails or response cannot be parsed as JSON
+   */
+  public executeRladminCommand<T = unknown>(
+    command: string,
+    bdbId?: string
+  ): Promise<T> {
+    const cmd = bdbId ? `rladmin -b ${bdbId} ${command}` : `rladmin ${command}`;
+    return this.#request<T>("POST", "/rladmin", cmd);
+  }
+
+  /**
+   * Waits for an action to complete.
+   * @param actionId The ID of the action to wait for
+   * @param options Optional timeout and max wait time
+   * @throws {Error} When the action does not complete within the max wait time
+   */
+  public async waitForAction(
+    actionId: string,
+    {
+      timeoutMs,
+      maxWaitTimeMs,
+    }: {
+      timeoutMs?: number;
+      maxWaitTimeMs?: number;
+    } = {}
+  ): Promise<ActionStatus> {
+    const timeout = timeoutMs || 1000;
+    const maxWaitTime = maxWaitTimeMs || 60000;
+
+    const startTime = Date.now();
+
+    while (Date.now() - startTime < maxWaitTime) {
+      const action = await this.getActionStatus<ActionStatus>(actionId);
+
+      if (["finished", "failed", "success"].includes(action.status)) {
+        return action;
+      }
+
+      await setTimeout(timeout);
+    }
+
+    throw new Error(`Timeout waiting for action ${actionId}`);
+  }
+
+  /**
+   * Triggers a migrate and bind action.
+   * @param bdbId The database ID to target
+   * @param clusterIndex The cluster index to migrate to
+   * @returns The action status
+   */
+  public async migrateAndBindAction({
+    bdbId,
+    clusterIndex,
+  }: {
+    bdbId: string | number;
+    clusterIndex: string | number;
+  }) {
+    const bdbIdStr = String(bdbId);
+    const clusterIndexStr = String(clusterIndex);
+
+    return this.triggerAction<{ action_id: string }>({
+      type: "sequence_of_actions",
+      parameters: {
+        bdb_id: bdbIdStr,
+        actions: [
+          {
+            type: "migrate",
+            params: {
+              cluster_index: clusterIndexStr,
+            },
+          },
+          {
+            type: "bind",
+            params: {
+              bdb_id: bdbIdStr,
+              cluster_index: clusterIndexStr,
+            },
+          },
+        ],
+      },
+    });
+  }
+
+  async #request<T>(
+    method: string,
+    path: string,
+    body?: Object | string
+  ): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    };
+
+    let payload: string | undefined;
+
+    if (body) {
+      if (typeof body === "string") {
+        headers["Content-Type"] = "text/plain";
+        payload = body;
+      } else {
+        headers["Content-Type"] = "application/json";
+        payload = JSON.stringify(body);
+      }
+    }
+
+    const response = await this.#fetch(url, { method, headers, body: payload });
+
+    if (!response.ok) {
+      try {
+        const text = await response.text();
+        throw new Error(`HTTP ${response.status} - ${text}`);
+      } catch {
+        throw new Error(`HTTP ${response.status}`);
+      }
+    }
+
+    try {
+      return (await response.json()) as T;
+    } catch {
+      throw new Error(
+        `HTTP ${response.status} - Unable to parse response as JSON`
+      );
+    }
+  }
+}
diff --git a/packages/client/lib/tests/test-scenario/push-notification.e2e.ts b/packages/client/lib/tests/test-scenario/push-notification.e2e.ts
new file mode 100644
index 0000000000..cab241d4b1
--- /dev/null
+++ b/packages/client/lib/tests/test-scenario/push-notification.e2e.ts
@@ -0,0 +1,92 @@
+import assert from "node:assert";
+import diagnostics_channel from "node:diagnostics_channel";
+import { FaultInjectorClient } from "./fault-injector-client";
+import {
+  getDatabaseConfig,
+  getDatabaseConfigFromEnv,
+  getEnvConfig,
+  RedisConnectionConfig,
+} from "./test-scenario.util";
+import { createClient } from "../../..";
+import { DiagnosticsEvent } from "../../client/enterprise-maintenance-manager";
+import { before } from "mocha";
+
+describe("Push Notifications", () => {
+  const diagnosticsLog: DiagnosticsEvent[] = [];
+
+  const onMessageHandler = (message: unknown) => {
+    diagnosticsLog.push(message as DiagnosticsEvent);
+  };
+
+  let clientConfig: RedisConnectionConfig;
+  let client: ReturnType<typeof createClient<any, any, any, 3>>;
+  let faultInjectorClient: FaultInjectorClient;
+
+  before(() => {
+    const envConfig = getEnvConfig();
+    const redisConfig = getDatabaseConfigFromEnv(
+      envConfig.redisEndpointsConfigPath
+    );
+
+    faultInjectorClient = new FaultInjectorClient(envConfig.faultInjectorUrl);
+    clientConfig = getDatabaseConfig(redisConfig);
+  });
+
+  beforeEach(async () => {
+    diagnosticsLog.length = 0;
+    diagnostics_channel.subscribe("redis.maintenance", onMessageHandler);
+
+    client = createClient({
+      socket: {
+        host: clientConfig.host,
+        port: clientConfig.port,
+        ...(clientConfig.tls === true ? { tls: true } : {}),
+      },
+      password: clientConfig.password,
+      username: clientConfig.username,
+      RESP: 3,
+      maintPushNotifications: "auto",
+      maintMovingEndpointType: "auto",
+    });
+
+    client.on("error", (err: Error) => {
+      throw new Error(`Client error: ${err.message}`);
+    });
+
+    await client.connect();
+  });
+
+  afterEach(() => {
+    diagnostics_channel.unsubscribe("redis.maintenance", onMessageHandler);
+    client.destroy();
+  });
+
+  it("should receive MOVING, MIGRATING, and MIGRATED push notifications", async () => {
+    const { action_id: migrateActionId } =
+      await faultInjectorClient.triggerAction<{ action_id: string }>({
+        type: "migrate",
+        parameters: {
+          cluster_index: "0",
+        },
+      });
+
+    await faultInjectorClient.waitForAction(migrateActionId);
+
+    const { action_id: bindActionId } =
+      await faultInjectorClient.triggerAction<{ action_id: string }>({
+        type: "bind",
+        parameters: {
+          cluster_index: "0",
+          bdb_id: `${clientConfig.bdbId}`,
+        },
+      });
+
+    await faultInjectorClient.waitForAction(bindActionId);
+
+    const pushNotificationLogs = diagnosticsLog.filter((log) => {
+      return ["MOVING", "MIGRATING", "MIGRATED"].includes(log?.type);
+    });
+
+    assert.strictEqual(pushNotificationLogs.length, 3);
+  });
+});
diff --git a/packages/client/lib/tests/test-scenario/test-command-runner.ts b/packages/client/lib/tests/test-scenario/test-command-runner.ts
new file mode 100644
index 0000000000..d6aeba0902
--- /dev/null
+++ b/packages/client/lib/tests/test-scenario/test-command-runner.ts
@@ -0,0 +1,104 @@
+import { randomUUID } from "node:crypto";
+import { setTimeout } from "node:timers/promises";
+import { createClient } from "../../..";
+
+/**
+ * Options for the `fireCommandsUntilStopSignal` method
+ */
+type FireCommandsUntilStopSignalOptions = {
+  /**
+   * Number of commands to fire in each batch
+   */
+  batchSize: number;
+  /**
+   * Timeout between batches in milliseconds
+   */
+  timeoutMs: number;
+  /**
+   * Function that creates the commands to be executed
+   */
+  createCommands: (
+    client: ReturnType<typeof createClient<any, any, any, any>>
+  ) => Array<() => Promise<unknown>>;
+};
+
+export class TestCommandRunner {
+  constructor(
+    private client: ReturnType<typeof createClient<any, any, any, any>>
+  ) {}
+
+  private defaultOptions: FireCommandsUntilStopSignalOptions = {
+    batchSize: 60,
+    timeoutMs: 10,
+    createCommands: (
+      client: ReturnType<typeof createClient<any, any, any, any>>
+    ) => [
+      () => client.set(randomUUID(), Date.now()),
+      () => client.get(randomUUID()),
+    ],
+  };
+
+  #toSettled<T>(p: Promise<T>) {
+    return p
+      .then((value) => ({ status: "fulfilled" as const, value, error: null }))
+      .catch((reason) => ({
+        status: "rejected" as const,
+        value: null,
+        error: reason,
+      }));
+  }
+
+  async #racePromises<S, T>({
+    timeout,
+    stopper,
+  }: {
+    timeout: Promise<S>;
+    stopper: Promise<T>;
+  }) {
+    return Promise.race([
+      this.#toSettled<S>(timeout).then((result) => ({
+        ...result,
+        stop: false,
+      })),
+      this.#toSettled<T>(stopper).then((result) => ({ ...result, stop: true })),
+    ]);
+  }
+
+  /**
+   * Fires commands until a stop signal is received.
+   * @param stopSignalPromise Promise that resolves when the command execution should stop
+   * @param options Options for the command execution
+   * @returns Promise that resolves when the stop signal is received
+   */
+  async fireCommandsUntilStopSignal(
+    stopSignalPromise: Promise<unknown>,
+    options?: Partial<FireCommandsUntilStopSignalOptions>
+  ) {
+    const executeOptions = {
+      ...this.defaultOptions,
+      ...options,
+    };
+
+    const commandPromises = [];
+
+    while (true) {
+      for (let i = 0; i < executeOptions.batchSize; i++) {
+        for (const command of executeOptions.createCommands(this.client)) {
+          commandPromises.push(this.#toSettled(command()));
+        }
+      }
+
+      const result = await this.#racePromises({
+        timeout: setTimeout(executeOptions.timeoutMs),
+        stopper: stopSignalPromise,
+      });
+
+      if (result.stop) {
+        return {
+          commandPromises,
+          stopResult: result,
+        };
+      }
+    }
+  }
+}
diff --git a/packages/client/lib/tests/test-scenario/test-scenario.util.ts b/packages/client/lib/tests/test-scenario/test-scenario.util.ts
new file mode 100644
index 0000000000..82333be8f0
--- /dev/null
+++ b/packages/client/lib/tests/test-scenario/test-scenario.util.ts
@@ -0,0 +1,110 @@
+import { readFileSync } from "fs";
+
+type DatabaseEndpoint = {
+  addr: string[];
+  addr_type: string;
+  dns_name: string;
+  oss_cluster_api_preferred_endpoint_type: string;
+  oss_cluster_api_preferred_ip_type: string;
+  port: number;
+  proxy_policy: string;
+  uid: string;
+};
+
+type DatabaseConfig = {
+  bdb_id: number;
+  username: string;
+  password: string;
+  tls: boolean;
+  raw_endpoints: DatabaseEndpoint[];
+  endpoints: string[];
+};
+
+type DatabasesConfig = {
+  [databaseName: string]: DatabaseConfig;
+};
+
+type EnvConfig = {
+  redisEndpointsConfigPath: string;
+  faultInjectorUrl: string;
+};
+
+/**
+ * Reads environment variables required for the test scenario
+ * @returns Environment configuration object
+ * @throws Error if required environment variables are not set
+ */
+export function getEnvConfig(): EnvConfig {
+  if (!process.env.REDIS_ENDPOINTS_CONFIG_PATH) {
+    throw new Error(
+      "REDIS_ENDPOINTS_CONFIG_PATH environment variable must be set"
+    );
+  }
+
+  if (!process.env.FAULT_INJECTION_API_URL) {
+    throw new Error("FAULT_INJECTION_API_URL environment variable must be set");
+  }
+
+  return {
+    redisEndpointsConfigPath: process.env.REDIS_ENDPOINTS_CONFIG_PATH,
+    faultInjectorUrl: process.env.FAULT_INJECTION_API_URL,
+  };
+}
+
+/**
+ * Reads database configuration from a file
+ * @param filePath - The path to the database configuration file
+ * @returns Parsed database configuration object
+ * @throws Error if file doesn't exist or JSON is invalid
+ */
+export function getDatabaseConfigFromEnv(filePath: string): DatabasesConfig {
+  try {
+    const fileContent = readFileSync(filePath, "utf8");
+    return JSON.parse(fileContent) as DatabasesConfig;
+  } catch (error) {
+    throw new Error(`Failed to read or parse database config from ${filePath}`);
+  }
+}
+
+export interface RedisConnectionConfig {
+  host: string;
+  port: number;
+  username: string;
+  password: string;
+  tls: boolean;
+  bdbId: number;
+}
+
+/**
+ * Gets Redis connection parameters for a specific database
+ * @param databasesConfig - The parsed database configuration object
+ * @param databaseName - Optional name of the database to retrieve (defaults to the first one)
+ * @returns Redis connection configuration with host, port, username, password, and tls
+ * @throws Error if the specified database is not found in the configuration
+ */
+export function getDatabaseConfig(
+  databasesConfig: DatabasesConfig,
+  databaseName?: string
+): RedisConnectionConfig {
+  const dbConfig = databaseName
+    ? databasesConfig[databaseName]
+    : Object.values(databasesConfig)[0];
+
+  if (!dbConfig) {
+    throw new Error(
+      `Database ${databaseName ? databaseName : ""} not found in configuration`
+    );
+  }
+
+  const endpoint = dbConfig.raw_endpoints[0]; // Use the first endpoint
+
+  return {
+    host: endpoint.dns_name,
+    port: endpoint.port,
+    username: dbConfig.username,
+    password: dbConfig.password,
+    tls: dbConfig.tls,
+    bdbId: dbConfig.bdb_id,
+  };
+}
+
diff --git a/packages/client/lib/tests/test-scenario/timeout-during-notifications.e2e.ts b/packages/client/lib/tests/test-scenario/timeout-during-notifications.e2e.ts
new file mode 100644
index 0000000000..669d99b24f
--- /dev/null
+++ b/packages/client/lib/tests/test-scenario/timeout-during-notifications.e2e.ts
@@ -0,0 +1,113 @@
+import { FaultInjectorClient } from "./fault-injector-client";
+import {
+  getDatabaseConfig,
+  getDatabaseConfigFromEnv,
+  getEnvConfig,
+  RedisConnectionConfig,
+} from "./test-scenario.util";
+import { createClient } from "../../../dist";
+import { before } from "mocha";
+import { TestCommandRunner } from "./test-command-runner";
+import assert from "node:assert";
+
+describe("Timeout Handling During Notifications", () => {
+  let clientConfig: RedisConnectionConfig;
+  let client: ReturnType<typeof createClient<any, any, any, 3>>;
+  let faultInjectorClient: FaultInjectorClient;
+  let commandRunner: TestCommandRunner;
+
+  before(() => {
+    const envConfig = getEnvConfig();
+    const redisConfig = getDatabaseConfigFromEnv(
+      envConfig.redisEndpointsConfigPath
+    );
+
+    faultInjectorClient = new FaultInjectorClient(envConfig.faultInjectorUrl);
+    clientConfig = getDatabaseConfig(redisConfig);
+  });
+
+  beforeEach(async () => {
+    client = createClient({
+      socket: {
+        host: clientConfig.host,
+        port: clientConfig.port,
+        ...(clientConfig.tls === true ? { tls: true } : {}),
+      },
+      password: clientConfig.password,
+      username: clientConfig.username,
+      RESP: 3,
+      maintPushNotifications: "auto",
+      maintMovingEndpointType: "auto",
+    });
+
+    client.on("error", (err: Error) => {
+      throw new Error(`Client error: ${err.message}`);
+    });
+
+    commandRunner = new TestCommandRunner(client);
+
+    await client.connect();
+  });
+
+  afterEach(() => {
+    client.destroy();
+  });
+
+  it("should relax command timeout on MOVING, MIGRATING, and MIGRATED", async () => {
+    // PART 1
+    // Set very low timeout to trigger errors
+    client.options!.maintRelaxedCommandTimeout = 50;
+
+    const { action_id: lowTimeoutBindAndMigrateActionId } =
+      await faultInjectorClient.migrateAndBindAction({
+        bdbId: clientConfig.bdbId,
+        clusterIndex: 0,
+      });
+
+    const lowTimeoutWaitPromise = faultInjectorClient.waitForAction(
+      lowTimeoutBindAndMigrateActionId
+    );
+
+    const lowTimeoutCommandPromises =
+      await commandRunner.fireCommandsUntilStopSignal(lowTimeoutWaitPromise);
+
+    const lowTimeoutRejectedCommands = (
+      await Promise.all(lowTimeoutCommandPromises.commandPromises)
+    ).filter((result) => result.status === "rejected");
+
+    assert.ok(lowTimeoutRejectedCommands.length > 0);
+    assert.strictEqual(
+      lowTimeoutRejectedCommands.filter((rejected) => {
+        return (
+          // TODO instanceof doesn't work for some reason
+          rejected.error.constructor.name ===
+          "CommandTimeoutDuringMaintananceError"
+        );
+      }).length,
+      lowTimeoutRejectedCommands.length
+    );
+
+    // PART 2
+    // Set high timeout to avoid errors
+    client.options!.maintRelaxedCommandTimeout = 10000;
+
+    const { action_id: highTimeoutBindAndMigrateActionId } =
+      await faultInjectorClient.migrateAndBindAction({
+        bdbId: clientConfig.bdbId,
+        clusterIndex: 0,
+      });
+
+    const highTimeoutWaitPromise = faultInjectorClient.waitForAction(
+      highTimeoutBindAndMigrateActionId
+    );
+
+    const highTimeoutCommandPromises =
+      await commandRunner.fireCommandsUntilStopSignal(highTimeoutWaitPromise);
+
+    const highTimeoutRejectedCommands = (
+      await Promise.all(highTimeoutCommandPromises.commandPromises)
+    ).filter((result) => result.status === "rejected");
+
+    assert.strictEqual(highTimeoutRejectedCommands.length, 0);
+  });
+});