diff --git a/packages/client/lib/client/commands-queue.ts b/packages/client/lib/client/commands-queue.ts
index 52a07a7e3b..96b2dee079 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,75 @@ 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)];
+
+  #inMaintenance = false;
+
+  set inMaintenance(value: boolean) {
+    this.#inMaintenance = value;
+  }
+
+  #maintenanceCommandTimeout: number | undefined
+
+  setMaintenanceCommandTimeout(ms: number | undefined) {
+    dbgMaintenance(`Setting maintenance command timeout to ${ms}`);
+    // Prevent possible api misuse
+    if (this.#maintenanceCommandTimeout === ms) return;
+
+    this.#maintenanceCommandTimeout = ms;
+
+    let counter = 0;
+
+    // Overwrite timeouts of all eligible toWrite commands
+    this.#toWrite.forEachNode(node => {
+      const command = node.value;
+
+      // Remove timeout listener if it exists
+      RedisCommandsQueue.#removeTimeoutListener(command)
+
+      // Determine newTimeout
+      const newTimeout = this.#maintenanceCommandTimeout ?? command.timeout?.originalTimeout;
+      // if no timeout is given and the command didnt have any timeout before, skip
+      if (!newTimeout)  return;
+
+      counter++;
+
+      // Overwrite the command's timeout
+      const signal = AbortSignal.timeout(newTimeout);
+      command.timeout = {
+        signal,
+        listener: () => {
+          this.#toWrite.remove(node);
+          command.reject(this.#inMaintenance ? new CommandTimeoutDuringMaintananceError(newTimeout) : new TimeoutError());
+        },
+        originalTimeout: command.timeout?.originalTimeout
+      };
+      signal.addEventListener('abort', command.timeout.listener, { once: true });
+    });
+    dbgMaintenance(`Total of ${counter} timeouts reset to ${ms}`);
+  }
+
   get isPubSubActive() {
     return this.#pubSub.isActive;
   }
 
-  #invalidateCallback?: (key: RedisArgument | null) => unknown;
-
   constructor(
     respVersion: RespVersions,
     maxLength: number | null | undefined,
@@ -107,6 +162,7 @@ export default class RedisCommandsQueue {
       }
       return true;
     }
+    return false
   }
 
   #getTypeMapping() {
@@ -119,30 +175,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 +221,19 @@ 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
       if (timeout) {
+
         const signal = AbortSignal.timeout(timeout);
         value.timeout = {
           signal,
           listener: () => {
             this.#toWrite.remove(node);
-            value.reject(new TimeoutError());
-          }
+            value.reject(this.#inMaintenance ? 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..2918ec74ab
--- /dev/null
+++ b/packages/client/lib/client/enterprise-maintenance-manager.ts
@@ -0,0 +1,187 @@
+import EventEmitter from "events";
+import { RedisClientOptions } from ".";
+import RedisCommandsQueue from "./commands-queue";
+import RedisSocket from "./socket";
+import { RedisArgument } from "../..";
+import { isIP } from "net";
+import { lookup } from "dns/promises";
+
+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 interface SocketTimeoutUpdate {
+  inMaintenance: boolean;
+  timeout?: number;
+}
+
+export const dbgMaintenance = (...args: any[]) => {
+  if (!process.env.DEBUG_MAINTENANCE) return;
+  return console.log('[MNT]', ...args);
+}
+
+export default class EnterpriseMaintenanceManager extends EventEmitter {
+  #commandsQueue: RedisCommandsQueue;
+  #options: RedisClientOptions;
+
+  static async getHandshakeCommand(tls: boolean, host: string): Promise<Array<RedisArgument>> {
+    const movingEndpointType = await determineEndpoint(tls, host);
+    return ["CLIENT", "MAINT_NOTIFICATIONS", "ON", "moving-endpoint-type", movingEndpointType];
+  }
+
+  constructor(commandsQueue: RedisCommandsQueue, options: RedisClientOptions) {
+    super();
+    this.#commandsQueue = commandsQueue;
+    this.#options = options;
+
+    this.#commandsQueue.addPushHandler(this.#onPush);
+  }
+
+  #onPush = (push: Array<any>): boolean => {
+    switch (push[0].toString()) {
+      case PN.MOVING: {
+        const [_, afterMs, url] = push;
+        const [host, port] = url.toString().split(":");
+        dbgMaintenance('Received MOVING:', afterMs, host, Number(port));
+        this.#onMoving(afterMs, host, Number(port));
+        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 (
+    _afterMs: number,
+    host: string,
+    port: number,
+  ): Promise<void> => {
+    // 1 [EVENT] MOVING PN received
+    // 2 [ACTION] Pause writing
+    dbgMaintenance('Pausing writing of new commands to old socket');
+    this.emit(MAINTENANCE_EVENTS.PAUSE_WRITING);
+    this.#onMigrating();
+
+    const newSocket = new RedisSocket({
+      ...this.#options.socket,
+      host,
+      port,
+    });
+    //todo
+    newSocket.setMaintenanceTimeout();
+    dbgMaintenance(`Connecting to new socket: ${host}:${port}`);
+    await newSocket.connect();
+    dbgMaintenance(`Connected to new socket`);
+    // 3 [EVENT] New socket connected
+
+    dbgMaintenance(`Wait for all in-flight commands to complete`);
+    await this.#commandsQueue.waitForInflightCommandsToComplete();
+    dbgMaintenance(`In-flight commands completed`);
+    // 4 [EVENT] In-flight commands completed
+
+    // 5 + 6
+    dbgMaintenance('Resume writing')
+    this.emit(MAINTENANCE_EVENTS.RESUME_WRITING, newSocket);
+    this.#onMigrated();
+  };
+
+  #onMigrating = async () => {
+    this.#commandsQueue.inMaintenance = true;
+    this.#commandsQueue.setMaintenanceCommandTimeout(
+      this.#options.gracefulMaintenance?.relaxedCommandTimeout,
+    );
+
+    this.emit(MAINTENANCE_EVENTS.TIMEOUTS_UPDATE, {
+      inMaintenance: true,
+      timeout: this.#options.gracefulMaintenance?.relaxedSocketTimeout,
+    } satisfies SocketTimeoutUpdate);
+  };
+
+  #onMigrated = async () => {
+    this.#commandsQueue.inMaintenance = false;
+    this.#commandsQueue.setMaintenanceCommandTimeout(undefined);
+
+    this.emit(MAINTENANCE_EVENTS.TIMEOUTS_UPDATE, {
+      inMaintenance: false,
+      timeout: undefined,
+    } satisfies SocketTimeoutUpdate);
+  };
+}
+
+type MovingEndpointType =
+  | "internal-ip"
+  | "internal-fqdn"
+  | "external-ip"
+  | "external-fqdn";
+
+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,
+): Promise<MovingEndpointType> {
+
+  const ip = isIP(host)
+    ? host
+    : (await lookup(host, {family: 0})).address
+
+  const isPrivate = isPrivateIP(ip);
+
+  if (tlsEnabled) {
+    return isPrivate ? "internal-fqdn" : "external-fqdn";
+  } else {
+    return isPrivate ? "internal-ip" : "external-ip";
+  }
+}
diff --git a/packages/client/lib/client/index.ts b/packages/client/lib/client/index.ts
index 128dc59967..368acb0434 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,8 @@ import { BasicClientSideCache, ClientSideCacheConfig, ClientSideCacheProvider }
 import { BasicCommandParser, CommandParser } from './parser';
 import SingleEntryCache from '../single-entry-cache';
 import { version } from '../../package.json'
+import EnterpriseMaintenanceManager, { MAINTENANCE_EVENTS, SocketTimeoutUpdate, dbgMaintenance } from './enterprise-maintenance-manager';
+import assert from 'node:assert';
 
 export interface RedisClientOptions<
   M extends RedisModules = RedisModules,
@@ -144,6 +146,52 @@ export interface RedisClientOptions<
    * Tag to append to library name that is sent to the Redis server
    */
   clientInfoTag?: string;
+
+  /**
+   * Configuration for handling Redis Enterprise graceful maintenance scenarios.
+   *
+   * When Redis Enterprise performs maintenance operations, nodes will be replaced, resulting in disconnects.
+   * This configuration allows the client to handle these scenarios gracefully by automatically
+   * reconnecting and managing command execution during maintenance windows.
+   *
+   * @example Basic graceful maintenance configuration
+   * ```
+   * const client = createClient({
+   *   gracefulMaintenance: {
+   *     handleFailedCommands: 'retry',
+   *     handleTimeouts: 'exception',
+   *   }
+   * });
+   * ```
+   *
+   * @example Graceful maintenance with timeout smoothing
+   * ```
+   * const client = createClient({
+   *   gracefulMaintenance: {
+   *     handleFailedCommands: 'retry',
+   *     handleTimeouts: 5000, // Extend timeouts to 5 seconds during maintenance
+   *   }
+   * });
+   * ```
+   */
+  gracefulMaintenance?: {
+    /**
+     * Designates how failed commands should be handled. A failed command is when the time isn’t sufficient to deal with the responses on the old connection before the server shuts it down
+     */
+    handleFailedCommands?: 'exception' | 'retry',
+    /**
+     * 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.
+     */
+    relaxedCommandTimeout?: 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.
+     */
+    relaxedSocketTimeout?: number
+  }
 }
 
 type WithCommands<
@@ -366,7 +414,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>;
@@ -379,11 +427,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
+  #pausedForMaintenance = false;
+
   get clientSideCache() {
     return this._self.#clientSideCache;
   }
 
-
   get options(): RedisClientOptions<M, F, S, RESP> | undefined {
     return this._self.#options;
   }
@@ -417,6 +470,15 @@ export default class RedisClient<
     return this._self.#dirtyWatch !== undefined
   }
 
+  async #resumeFromMaintenance(newSocket: RedisSocket) {
+    this._self.#socket.removeAllListeners();
+    this._self.#socket.destroy();
+    this._self.#socket = newSocket;
+    this._self.#pausedForMaintenance = false;
+    await this._self.#initiateSocket();
+    this._self.#maybeScheduleWrite();
+  }
+
   /**
    * Marks the client's WATCH command as invalidated due to a topology change.
    * This will cause any subsequent EXEC in a transaction to fail with a WatchError.
@@ -431,7 +493,17 @@ export default class RedisClient<
     this.#validateOptions(options)
     this.#options = this.#initiateOptions(options);
     this.#queue = this.#initiateQueue();
-    this.#socket = this.#initiateSocket();
+    this.#socket = this.#createSocket(this.#options);
+
+    if(options?.gracefulMaintenance) {
+      new EnterpriseMaintenanceManager(this.#queue, this.#options!)
+        .on(MAINTENANCE_EVENTS.PAUSE_WRITING, () => this._self.#pausedForMaintenance = true )
+        .on(MAINTENANCE_EVENTS.RESUME_WRITING, this.#resumeFromMaintenance.bind(this))
+        .on(MAINTENANCE_EVENTS.TIMEOUTS_UPDATE, (value: SocketTimeoutUpdate) => {
+          this._self.#socket.inMaintenance = value.inMaintenance;
+          this._self.#socket.setMaintenanceTimeout(value.timeout);
+        })
+    }
 
     if (options?.clientSideCache) {
       if (options.clientSideCache instanceof ClientSideCacheProvider) {
@@ -440,7 +512,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
+      });
     }
   }
 
@@ -449,7 +533,12 @@ export default class RedisClient<
       throw new Error('Client Side Caching is only supported with RESP3');
     }
 
+    if (options?.gracefulMaintenance && 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
@@ -654,41 +743,26 @@ export default class RedisClient<
       commands.push({cmd: this.#clientSideCache.trackingOn()});
     }
 
+    if(this.#options?.gracefulMaintenance) {
+      const socket = this.#options.socket;
+      assert(socket !== undefined);
+      const { tls, host } = socket as RedisTcpSocketOptions;
+      assert(host !== undefined);
+      commands.push({
+        cmd: await EnterpriseMaintenanceManager.getHandshakeCommand(!!tls, host),
+        errorHandler: (err: Error) => {
+          dbgMaintenance("Maintenance handshake failed: ", err);
+        }
+      });
+    }
+
     return commands;
   }
 
-  #initiateSocket(): RedisSocket {
-    const socketInitiator = async () => {
-      const promises = [],
-        chainId = Symbol('Socket Initiator');
-
-      const resubscribePromise = this.#queue.resubscribe(chainId);
-      if (resubscribePromise) {
-        promises.push(resubscribePromise);
-      }
-
-      if (this.#monitorCallback) {
-        promises.push(
-          this.#queue.monitor(
-            this.#monitorCallback,
-            {
-              typeMapping: this._commandOptions?.typeMapping,
-              chainId,
-              asap: true
-            }
-          )
-        );
-      }
-
-      promises.push(...(await this.#handshake(chainId, true)));
-
-      if (promises.length) {
-        this.#write();
-        return Promise.all(promises);
-      }
-    };
+  async #initiateSocket(): Promise<void> {
+    await this.#socket.waitForReady();
 
-    return new RedisSocket(socketInitiator, this.#options?.socket)
+    this.#socket
       .on('data', chunk => {
         try {
           this.#queue.decoder.write(chunk);
@@ -706,15 +780,47 @@ export default class RedisClient<
           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 promises = [];
+    const chainId = Symbol('Socket Initiator');
+
+    const resubscribePromise = this.#queue.resubscribe(chainId);
+    if (resubscribePromise) {
+      promises.push(resubscribePromise);
+    }
+
+    if (this.#monitorCallback) {
+      promises.push(
+        this.#queue.monitor(
+          this.#monitorCallback,
+          {
+            typeMapping: this._commandOptions?.typeMapping,
+            chainId,
+            asap: true
+          }
+        )
+      );
+    }
+
+    promises.push(...(await this.#handshake(chainId, true)));
+
+    this.#setPingTimer();
+
+    if (promises.length) {
+      this.#write();
+      await Promise.all(promises);
+    }
+  }
+
+  #createSocket(options?: RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>): RedisSocket {
+    return new RedisSocket(options?.socket)
+      .on('connect', () => this.emit('connect'))
+      .on('ready', () => {
+        this.emit('ready');
+      });
   }
 
   #pingTimer?: NodeJS.Timeout;
@@ -823,6 +929,7 @@ export default class RedisClient<
 
   async connect() {
     await this._self.#socket.connect();
+    await this._self.#initiateSocket();
     return this as unknown as RedisClientType<M, F, S, RESP, TYPE_MAPPING>;
   }
 
@@ -1055,6 +1162,9 @@ export default class RedisClient<
   }
 
   #write() {
+    if(this.#pausedForMaintenance) {
+      return
+    }
     this.#socket.write(this.#queue.commandsToWrite());
   }
 
diff --git a/packages/client/lib/client/linked-list.ts b/packages/client/lib/client/linked-list.ts
index 29678f027b..1fc0458cfe 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,15 @@ export class DoublyLinkedList<T> {
       node = node.next;
     }
   }
+
+  forEachNode(fn: (node: DoublyLinkedNode<T>) => void) {
+    let node = this.#head;
+    while(node) {
+      fn(node);
+      node = node.next;
+    }
+  }
+
 }
 
 export interface SinglyLinkedNode<T> {
@@ -201,3 +212,26 @@ export class SinglyLinkedList<T> {
     }
   }
 }
+
+export class EmptyAwareSinglyLinkedList<T> extends SinglyLinkedList<T> {
+  readonly events = new EventEmitter();
+  reset() {
+    super.reset();
+    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..b2c2e23c6e 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;
@@ -51,15 +52,14 @@ export type RedisTcpSocketOptions = RedisTcpOptions | RedisTlsOptions;
 
 export type RedisSocketOptions = RedisTcpSocketOptions | RedisIpcOptions;
 
-export type RedisSocketInitiator = () => void | Promise<unknown>;
-
 export default class RedisSocket extends EventEmitter {
-  readonly #initiator;
   readonly #connectTimeout;
   readonly #reconnectStrategy;
   readonly #socketFactory;
   readonly #socketTimeout;
 
+  #maintenanceTimeout: number | undefined;
+
   #socket?: net.Socket | tls.TLSSocket;
 
   #isOpen = false;
@@ -82,16 +82,29 @@ export default class RedisSocket extends EventEmitter {
     return this.#socketEpoch;
   }
 
-  constructor(initiator: RedisSocketInitiator, options?: RedisSocketOptions) {
+  #inMaintenance = false;
+
+  set inMaintenance(value: boolean) {
+    this.#inMaintenance = value;
+  }
+
+  constructor(options?: RedisSocketOptions) {
     super();
 
-    this.#initiator = initiator;
     this.#connectTimeout = options?.connectTimeout ?? 5000;
     this.#reconnectStrategy = this.#createReconnectStrategy(options);
     this.#socketFactory = this.#createSocketFactory(options);
     this.#socketTimeout = options?.socketTimeout;
   }
 
+  async waitForReady(): Promise<void> {
+    if (this.#isReady) return
+    return new Promise((resolve, reject) => {
+      this.once('ready', resolve);
+      this.once('error', reject);
+    });
+  }
+
   #createReconnectStrategy(options?: RedisSocketOptions): ReconnectStrategyFunction {
     const strategy = options?.reconnectStrategy;
     if (strategy === false || typeof strategy === 'number') {
@@ -214,14 +227,6 @@ export default class RedisSocket extends EventEmitter {
       try {
         this.#socket = await this.#createSocket();
         this.emit('connect');
-
-        try {
-          await this.#initiator();
-        } catch (err) {
-          this.#socket.destroy();
-          this.#socket = undefined;
-          throw err;
-        }
         this.#isReady = true;
         this.#socketEpoch++;
         this.emit('ready');
@@ -238,6 +243,19 @@ export default class RedisSocket extends EventEmitter {
     } while (this.#isOpen && !this.#isReady);
   }
 
+  setMaintenanceTimeout(ms?: number) {
+    dbgMaintenance(`Reset socket timeout to ${ms}`);
+    if (this.#maintenanceTimeout === ms) 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 +278,10 @@ export default class RedisSocket extends EventEmitter {
 
     if (this.#socketTimeout) {
       socket.once('timeout', () => {
-        socket.destroy(new SocketTimeoutError(this.#socketTimeout!));
+        const error = this.#inMaintenance
+          ? new SocketTimeoutDuringMaintananceError(this.#socketTimeout!)
+          : 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 db37ec1a9b..4833c984e1 100644
--- a/packages/client/lib/errors.ts
+++ b/packages/client/lib/errors.ts
@@ -76,6 +76,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>;