@valkey/valkey-glide 2.3.0-rc6 → 2.3.0

package/build-ts/BaseClient.d.ts

@@ -95,6 +95,26 @@ export type StreamEntryDataType = Record<string, [GlideString, GlideString][]>;
  * Union type that can store either a number or positive/negative infinity.
  */
 export type Score = number | "+inf" | "-inf";
+/**
+ * Constant representing "all channels" for unsubscribe operations.
+ * Use this to unsubscribe from all channel subscriptions at once.
+ *
+ * @example
+ * ```typescript
+ * await client.unsubscribeLazy(ALL_CHANNELS);
+ * ```
+ */
+export declare const ALL_CHANNELS: null;
+/**
+ * Constant representing "all patterns" for punsubscribe operations.
+ * Use this to unsubscribe from all pattern subscriptions at once.
+ *
+ * @example
+ * ```typescript
+ * await client.punsubscribeLazy(ALL_PATTERNS);
+ * ```
+ */
+export declare const ALL_PATTERNS: null;
 /**
  * Data type which represents sorted sets data for input parameter of ZADD command,
  * including element and its respective score.
@@ -505,6 +525,32 @@ export interface AdvancedBaseClientConfiguration {
      * - If not explicitly set, a default value of `true` will be used by the Rust core.
      */
     tcpNoDelay?: boolean;
+    /**
+     * The interval in milliseconds between PubSub subscription reconciliation attempts.
+     *
+     * The reconciliation process ensures that the client's desired subscriptions match
+     * the actual subscriptions on the server. This is useful when subscriptions may have
+     * been lost due to network issues or server restarts.
+     *
+     * If not explicitly set, the Rust core will use its default reconciliation interval.
+     *
+     * @remarks
+     * - Must be a positive integer representing milliseconds.
+     * - The reconciliation process runs automatically in the background.
+     * - A lower interval provides faster recovery from subscription issues but increases overhead.
+     * - A higher interval reduces overhead but may delay recovery from subscription issues.
+     *
+     * @example
+     * ```typescript
+     * const config: GlideClientConfiguration = {
+     *   addresses: [{ host: "localhost", port: 6379 }],
+     *   advancedConfiguration: {
+     *     pubsubReconciliationIntervalMs: 5000 // Reconcile every 5 seconds
+     *   }
+     * };
+     * ```
+     */
+    pubsubReconciliationIntervalMs?: number;
 }
 /**
  * Enum of Valkey data types
@@ -6445,6 +6491,149 @@ export declare class BaseClient {
      * ```
      */
     refreshIamToken(): Promise<GlideString>;
+    /**
+     * Subscribes the client to the specified channels (non-blocking).
+     * Returns immediately without waiting for subscription confirmation.
+     *
+     * @see {@link https://valkey.io/commands/subscribe/|valkey.io} for details.
+     *
+     * @param channels - A collection of channel names to subscribe to.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await client.subscribeLazy(new Set(["news", "updates"]));
+     * ```
+     */
+    subscribeLazy(channels: Iterable<GlideString>, options?: DecoderOption): Promise<void>;
+    /**
+     * Subscribes the client to the specified channels (blocking).
+     * Waits for subscription confirmation or until timeout.
+     *
+     * @see {@link https://valkey.io/commands/subscribe/|valkey.io} for details.
+     *
+     * @param channels - A collection of channel names to subscribe to.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when subscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * // Wait up to 5 seconds
+     * await client.subscribe(new Set(["news"]), 5000);
+     * // Wait indefinitely
+     * await client.subscribe(new Set(["news"]), 0);
+     * ```
+     */
+    subscribe(channels: Iterable<GlideString>, timeoutMs: number, options?: DecoderOption): Promise<void>;
+    /**
+     * Subscribes the client to the specified patterns (non-blocking).
+     * Returns immediately without waiting for subscription confirmation.
+     *
+     * @see {@link https://valkey.io/commands/psubscribe/|valkey.io} for details.
+     *
+     * @param patterns - An array of glob-style patterns to subscribe to.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await client.psubscribeLazy(["news.*", "updates.*"]);
+     * ```
+     */
+    psubscribeLazy(patterns: Iterable<GlideString>, options?: DecoderOption): Promise<void>;
+    /**
+     * Subscribes the client to the specified patterns (blocking).
+     * Waits for subscription confirmation or until timeout.
+     *
+     * @see {@link https://valkey.io/commands/psubscribe/|valkey.io} for details.
+     *
+     * @param patterns - An array of glob-style patterns to subscribe to.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when subscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * await client.psubscribe(["news.*"], 5000);
+     * ```
+     */
+    psubscribe(patterns: Iterable<GlideString>, timeoutMs: number, options?: DecoderOption): Promise<void>;
+    /**
+     * Unsubscribes the client from the specified channels (non-blocking).
+     * Pass null or ALL_CHANNELS to unsubscribe from all exact channels.
+     *
+     * @see {@link https://valkey.io/commands/unsubscribe/|valkey.io} for details.
+     *
+     * @param channels - Channel names to unsubscribe from, or null for all channels.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await client.unsubscribeLazy(new Set(["news"]));
+     * // Unsubscribe from all channels
+     * await client.unsubscribeLazy(ALL_CHANNELS);
+     * ```
+     */
+    unsubscribeLazy(channels?: Iterable<GlideString> | null, options?: DecoderOption): Promise<void>;
+    /**
+     * Unsubscribes the client from the specified channels (blocking).
+     * Pass null or ALL_CHANNELS to unsubscribe from all exact channels.
+     *
+     * @see {@link https://valkey.io/commands/unsubscribe/|valkey.io} for details.
+     *
+     * @param channels - Channel names to unsubscribe from, or null for all channels.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when unsubscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * await client.unsubscribe(new Set(["news"]), 5000);
+     * // Unsubscribe from all channels with timeout
+     * await client.unsubscribe(ALL_CHANNELS, 5000);
+     * ```
+     */
+    unsubscribe(channels: Iterable<GlideString> | null, timeoutMs: number, options?: DecoderOption): Promise<void>;
+    /**
+     * Unsubscribes the client from the specified patterns (non-blocking).
+     * Pass null or ALL_PATTERNS to unsubscribe from all patterns.
+     *
+     * @see {@link https://valkey.io/commands/punsubscribe/|valkey.io} for details.
+     *
+     * @param patterns - Pattern names to unsubscribe from, or null for all patterns.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await client.punsubscribeLazy(new Set(["news.*"]));
+     * // Unsubscribe from all patterns
+     * await client.punsubscribeLazy(ALL_PATTERNS);
+     * ```
+     */
+    punsubscribeLazy(patterns?: Iterable<GlideString> | null, options?: DecoderOption): Promise<void>;
+    /**
+     * Unsubscribes the client from the specified patterns (blocking).
+     * Pass null or ALL_PATTERNS to unsubscribe from all patterns.
+     *
+     * @see {@link https://valkey.io/commands/punsubscribe/|valkey.io} for details.
+     *
+     * @param patterns - Pattern names to unsubscribe from, or null for all patterns.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when unsubscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * await client.punsubscribe(new Set(["news.*"]), 5000);
+     * // Unsubscribe from all patterns with timeout
+     * await client.punsubscribe(ALL_PATTERNS, 5000);
+     * ```
+     */
+    punsubscribe(patterns: Iterable<GlideString> | null, timeoutMs: number, options?: DecoderOption): Promise<void>;
     /**
      * Return a statistics
      *

package/build-ts/BaseClient.js

@@ -39,7 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseClient = exports.ObjectType = exports.ServiceType = exports.Decoder = exports.ProtocolVersion = void 0;
+exports.BaseClient = exports.ObjectType = exports.ServiceType = exports.ALL_PATTERNS = exports.ALL_CHANNELS = exports.Decoder = exports.ProtocolVersion = void 0;
 exports.convertGlideRecord = convertGlideRecord;
 exports.convertGlideRecordToRecord = convertGlideRecordToRecord;
 exports.isGlideRecord = isGlideRecord;
@@ -74,6 +74,26 @@ var Decoder;
      */
     Decoder[Decoder["String"] = 1] = "String";
 })(Decoder || (exports.Decoder = Decoder = {}));
+/**
+ * Constant representing "all channels" for unsubscribe operations.
+ * Use this to unsubscribe from all channel subscriptions at once.
+ *
+ * @example
+ * ```typescript
+ * await client.unsubscribeLazy(ALL_CHANNELS);
+ * ```
+ */
+exports.ALL_CHANNELS = null;
+/**
+ * Constant representing "all patterns" for punsubscribe operations.
+ * Use this to unsubscribe from all pattern subscriptions at once.
+ *
+ * @example
+ * ```typescript
+ * await client.punsubscribeLazy(ALL_PATTERNS);
+ * ```
+ */
+exports.ALL_PATTERNS = null;
 /**
  * @internal
  * Convert `GlideRecord<number>` recevied after resolving the value pointer into `SortedSetDataType`.
@@ -644,10 +664,9 @@ class BaseClient {
         if (this.isClosed) {
             throw new _1.ClosingError("Unable to execute requests; the client is closed. Please create a new client.");
         }
-        if (!this.isPubsubConfigured(this.config)) {
-            throw new _1.ConfigurationError("The operation will never complete since there was no pubsbub subscriptions applied to the client.");
-        }
-        if (this.getPubsubCallbackAndContext(this.config)[0]) {
+        // only throw error if BOTH config exists AND callback exists
+        if (this.isPubsubConfigured(this.config) &&
+            this.getPubsubCallbackAndContext(this.config)[0]) {
             throw new _1.ConfigurationError("The operation will never complete since messages will be passed to the configured callback.");
         }
         return new Promise((resolve, reject) => {
@@ -659,10 +678,9 @@ class BaseClient {
         if (this.isClosed) {
             throw new _1.ClosingError("Unable to execute requests; the client is closed. Please create a new client.");
         }
-        if (!this.isPubsubConfigured(this.config)) {
-            throw new _1.ConfigurationError("The operation will never complete since there was no pubsbub subscriptions applied to the client.");
-        }
-        if (this.getPubsubCallbackAndContext(this.config)[0]) {
+        // only throw error if BOTH config exists AND callback exists
+        if (this.isPubsubConfigured(this.config) &&
+            this.getPubsubCallbackAndContext(this.config)[0]) {
             throw new _1.ConfigurationError("The operation will never complete since messages will be passed to the configured callback.");
         }
         let msg = null;
@@ -7037,6 +7055,11 @@ class BaseClient {
         if (options.tcpNoDelay !== undefined) {
             request.tcpNodelay = options.tcpNoDelay;
         }
+        // Set PubSub reconciliation interval if explicitly configured
+        if (options.pubsubReconciliationIntervalMs !== undefined) {
+            request.pubsubReconciliationIntervalMs =
+                options.pubsubReconciliationIntervalMs;
+        }
         // Apply TLS configuration if present
         if (options.tlsAdvancedConfiguration) {
             // request.tlsMode is either SecureTls or InsecureTls here
@@ -7198,6 +7221,225 @@ class BaseClient {
         const response = await this.createRefreshIamTokenPromise(refresh);
         return response; // "OK"
     }
+    /**
+     * Subscribes the client to the specified channels (non-blocking).
+     * Returns immediately without waiting for subscription confirmation.
+     *
+     * @see {@link https://valkey.io/commands/subscribe/|valkey.io} for details.
+     *
+     * @param channels - A collection of channel names to subscribe to.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await client.subscribeLazy(new Set(["news", "updates"]));
+     * ```
+     */
+    async subscribeLazy(channels, options) {
+        const channelsArray = Array.from(channels);
+        return this.createWritePromise((0, _1.createSubscribeLazy)(channelsArray), options);
+    }
+    /**
+     * Subscribes the client to the specified channels (blocking).
+     * Waits for subscription confirmation or until timeout.
+     *
+     * @see {@link https://valkey.io/commands/subscribe/|valkey.io} for details.
+     *
+     * @param channels - A collection of channel names to subscribe to.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when subscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * // Wait up to 5 seconds
+     * await client.subscribe(new Set(["news"]), 5000);
+     * // Wait indefinitely
+     * await client.subscribe(new Set(["news"]), 0);
+     * ```
+     */
+    async subscribe(channels, timeoutMs, options) {
+        const channelsArray = Array.from(channels);
+        return this.createWritePromise((0, _1.createSubscribe)(channelsArray, timeoutMs), options);
+    }
+    /**
+     * Subscribes the client to the specified patterns (non-blocking).
+     * Returns immediately without waiting for subscription confirmation.
+     *
+     * @see {@link https://valkey.io/commands/psubscribe/|valkey.io} for details.
+     *
+     * @param patterns - An array of glob-style patterns to subscribe to.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await client.psubscribeLazy(["news.*", "updates.*"]);
+     * ```
+     */
+    async psubscribeLazy(patterns, options) {
+        const patternsArray = Array.from(patterns);
+        return this.createWritePromise((0, _1.createPSubscribeLazy)(patternsArray), options);
+    }
+    /**
+     * Subscribes the client to the specified patterns (blocking).
+     * Waits for subscription confirmation or until timeout.
+     *
+     * @see {@link https://valkey.io/commands/psubscribe/|valkey.io} for details.
+     *
+     * @param patterns - An array of glob-style patterns to subscribe to.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when subscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * await client.psubscribe(["news.*"], 5000);
+     * ```
+     */
+    async psubscribe(patterns, timeoutMs, options) {
+        const patternsArray = Array.from(patterns);
+        return this.createWritePromise((0, _1.createPSubscribe)(patternsArray, timeoutMs), options);
+    }
+    /**
+     * Unsubscribes the client from the specified channels (non-blocking).
+     * Pass null or ALL_CHANNELS to unsubscribe from all exact channels.
+     *
+     * @see {@link https://valkey.io/commands/unsubscribe/|valkey.io} for details.
+     *
+     * @param channels - Channel names to unsubscribe from, or null for all channels.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await client.unsubscribeLazy(new Set(["news"]));
+     * // Unsubscribe from all channels
+     * await client.unsubscribeLazy(ALL_CHANNELS);
+     * ```
+     */
+    async unsubscribeLazy(channels, options) {
+        const channelsArray = channels ? Array.from(channels) : undefined;
+        return this.createWritePromise((0, _1.createUnsubscribeLazy)(channelsArray), options);
+    }
+    /**
+     * Unsubscribes the client from the specified channels (blocking).
+     * Pass null or ALL_CHANNELS to unsubscribe from all exact channels.
+     *
+     * @see {@link https://valkey.io/commands/unsubscribe/|valkey.io} for details.
+     *
+     * @param channels - Channel names to unsubscribe from, or null for all channels.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when unsubscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * await client.unsubscribe(new Set(["news"]), 5000);
+     * // Unsubscribe from all channels with timeout
+     * await client.unsubscribe(ALL_CHANNELS, 5000);
+     * ```
+     */
+    async unsubscribe(channels, timeoutMs, options) {
+        const channelsArray = channels ? Array.from(channels) : [];
+        return this.createWritePromise((0, _1.createUnsubscribe)(channelsArray, timeoutMs), options);
+    }
+    /**
+     * Unsubscribes the client from the specified patterns (non-blocking).
+     * Pass null or ALL_PATTERNS to unsubscribe from all patterns.
+     *
+     * @see {@link https://valkey.io/commands/punsubscribe/|valkey.io} for details.
+     *
+     * @param patterns - Pattern names to unsubscribe from, or null for all patterns.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await client.punsubscribeLazy(new Set(["news.*"]));
+     * // Unsubscribe from all patterns
+     * await client.punsubscribeLazy(ALL_PATTERNS);
+     * ```
+     */
+    async punsubscribeLazy(patterns, options) {
+        const patternsArray = patterns ? Array.from(patterns) : undefined;
+        return this.createWritePromise((0, _1.createPUnsubscribeLazy)(patternsArray), options);
+    }
+    /**
+     * Unsubscribes the client from the specified patterns (blocking).
+     * Pass null or ALL_PATTERNS to unsubscribe from all patterns.
+     *
+     * @see {@link https://valkey.io/commands/punsubscribe/|valkey.io} for details.
+     *
+     * @param patterns - Pattern names to unsubscribe from, or null for all patterns.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when unsubscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * await client.punsubscribe(new Set(["news.*"]), 5000);
+     * // Unsubscribe from all patterns with timeout
+     * await client.punsubscribe(ALL_PATTERNS, 5000);
+     * ```
+     */
+    async punsubscribe(patterns, timeoutMs, options) {
+        const patternsArray = patterns ? Array.from(patterns) : [];
+        return this.createWritePromise((0, _1.createPUnsubscribe)(patternsArray, timeoutMs), options);
+    }
+    /**
+     * @internal
+     * Helper method to parse GetSubscriptions response from Rust core.
+     * Converts array response to structured object with desired and actual subscriptions.
+     *
+     * The Rust core returns subscription data as a Value::Map with string keys ("Exact", "Pattern", "Sharded").
+     * The NAPI layer converts this to GlideRecord format: [{key: "Exact", value: [...]}, ...]
+     *
+     * @param response - The response array from Rust core with format:
+     *   ["desired", GlideRecord, "actual", GlideRecord]
+     * @returns Parsed subscription state with desired and actual subscriptions
+     */
+    parseGetSubscriptionsResponse(response) {
+        // Response format: ["desired", GlideRecord, "actual", GlideRecord]
+        if (!Array.isArray(response) || response.length !== 4) {
+            throw new Error(`Invalid GetSubscriptions response format: expected array of length 4, got ${JSON.stringify(response)}`);
+        }
+        // Map string mode names to numeric enum values
+        const modeNameToNumber = {
+            Exact: 0,
+            Pattern: 1,
+            Sharded: 2,
+        };
+        const desiredSubscriptions = {};
+        const actualSubscriptions = {};
+        // Helper function to parse subscription data from GlideRecord format
+        const parseSubscriptionData = (data, target) => {
+            if (!Array.isArray(data)) {
+                return;
+            }
+            for (const entry of data) {
+                if (!entry ||
+                    typeof entry !== "object" ||
+                    !("key" in entry) ||
+                    !("value" in entry)) {
+                    continue;
+                }
+                // Key might be a Buffer, convert to string
+                const modeName = entry.key instanceof Buffer
+                    ? entry.key.toString()
+                    : String(entry.key);
+                const modeKey = modeNameToNumber[modeName];
+                if (modeKey !== undefined && Array.isArray(entry.value)) {
+                    target[modeKey] = new Set(entry.value);
+                }
+            }
+        };
+        // Parse desired and actual subscriptions
+        parseSubscriptionData(response[1], desiredSubscriptions);
+        parseSubscriptionData(response[3], actualSubscriptions);
+        return { desiredSubscriptions, actualSubscriptions };
+    }
     /**
      * Return a statistics
      *

package/build-ts/Commands.js

@@ -218,6 +218,19 @@ exports.createPubSubNumPat = createPubSubNumPat;
 exports.createPubSubNumSub = createPubSubNumSub;
 exports.createPubsubShardChannels = createPubsubShardChannels;
 exports.createPubSubShardNumSub = createPubSubShardNumSub;
+exports.createSubscribeLazy = createSubscribeLazy;
+exports.createSubscribe = createSubscribe;
+exports.createPSubscribeLazy = createPSubscribeLazy;
+exports.createPSubscribe = createPSubscribe;
+exports.createUnsubscribeLazy = createUnsubscribeLazy;
+exports.createUnsubscribe = createUnsubscribe;
+exports.createPUnsubscribeLazy = createPUnsubscribeLazy;
+exports.createPUnsubscribe = createPUnsubscribe;
+exports.createSSubscribeLazy = createSSubscribeLazy;
+exports.createSSubscribe = createSSubscribe;
+exports.createSUnsubscribeLazy = createSUnsubscribeLazy;
+exports.createSUnsubscribe = createSUnsubscribe;
+exports.createGetSubscriptions = createGetSubscriptions;
 exports.createBZPopMax = createBZPopMax;
 exports.createBZPopMin = createBZPopMin;
 exports.createScriptShow = createScriptShow;
@@ -2849,6 +2862,102 @@ function createPubsubShardChannels(pattern) {
 function createPubSubShardNumSub(channels) {
     return createCommand(RequestType.PubSubShardNumSub, channels ? channels : []);
 }
+/**
+ * @internal
+ */
+function createSubscribeLazy(channels) {
+    return createCommand(RequestType.Subscribe, channels);
+}
+/**
+ * @internal
+ */
+function createSubscribe(channels, timeout) {
+    return createCommand(RequestType.SubscribeBlocking, [
+        ...channels,
+        timeout.toString(),
+    ]);
+}
+/**
+ * @internal
+ */
+function createPSubscribeLazy(patterns) {
+    return createCommand(RequestType.PSubscribe, patterns);
+}
+/**
+ * @internal
+ */
+function createPSubscribe(patterns, timeout) {
+    return createCommand(RequestType.PSubscribeBlocking, [
+        ...patterns,
+        timeout.toString(),
+    ]);
+}
+/**
+ * @internal
+ */
+function createUnsubscribeLazy(channels) {
+    return createCommand(RequestType.Unsubscribe, channels ? channels : []);
+}
+/**
+ * @internal
+ */
+function createUnsubscribe(channels, timeout) {
+    return createCommand(RequestType.UnsubscribeBlocking, [
+        ...channels,
+        timeout.toString(),
+    ]);
+}
+/**
+ * @internal
+ */
+function createPUnsubscribeLazy(patterns) {
+    return createCommand(RequestType.PUnsubscribe, patterns ?? []);
+}
+/**
+ * @internal
+ */
+function createPUnsubscribe(patterns, timeout) {
+    return createCommand(RequestType.PUnsubscribeBlocking, [
+        ...patterns,
+        timeout.toString(),
+    ]);
+}
+/**
+ * @internal
+ */
+function createSSubscribeLazy(channels) {
+    return createCommand(RequestType.SSubscribe, channels);
+}
+/**
+ * @internal
+ */
+function createSSubscribe(channels, timeout) {
+    return createCommand(RequestType.SSubscribeBlocking, [
+        ...channels,
+        timeout.toString(),
+    ]);
+}
+/**
+ * @internal
+ */
+function createSUnsubscribeLazy(channels) {
+    return createCommand(RequestType.SUnsubscribe, channels ? channels : []);
+}
+/**
+ * @internal
+ */
+function createSUnsubscribe(channels, timeout) {
+    return createCommand(RequestType.SUnsubscribeBlocking, [
+        ...channels,
+        timeout.toString(),
+    ]);
+}
+/**
+ * @internal
+ */
+function createGetSubscriptions() {
+    return createCommand(RequestType.GetSubscriptions, []);
+}
 /**
  * @internal
  */

package/build-ts/GlideClient.d.ts

@@ -34,6 +34,37 @@ export declare namespace GlideClientConfiguration {
         context?: any;
     }
 }
+/**
+ * Represents the subscription state for a standalone client.
+ *
+ * @remarks
+ * This interface provides information about the current PubSub subscriptions for a standalone client.
+ * It includes both the desired subscriptions (what the client wants to maintain) and the actual
+ * subscriptions (what is currently established on the server).
+ *
+ * The subscriptions are organized by channel mode:
+ * - {@link GlideClientConfiguration.PubSubChannelModes.Exact | Exact}: Exact channel names
+ * - {@link GlideClientConfiguration.PubSubChannelModes.Pattern | Pattern}: Channel patterns using glob-style matching
+ *
+ * @example
+ * ```typescript
+ * const state = await client.getSubscriptions();
+ * console.log("Desired exact channels:", state.desiredSubscriptions[GlideClientConfiguration.PubSubChannelModes.Exact]);
+ * console.log("Actual exact channels:", state.actualSubscriptions[GlideClientConfiguration.PubSubChannelModes.Exact]);
+ * ```
+ */
+export interface StandalonePubSubState {
+    /**
+     * Desired subscriptions organized by channel mode.
+     * These are the subscriptions the client wants to maintain.
+     */
+    desiredSubscriptions: Partial<Record<GlideClientConfiguration.PubSubChannelModes, Set<GlideString>>>;
+    /**
+     * Actual subscriptions currently active on the server.
+     * These are the subscriptions that are actually established.
+     */
+    actualSubscriptions: Partial<Record<GlideClientConfiguration.PubSubChannelModes, Set<GlideString>>>;
+}
 /**
  * Configuration options for creating a {@link GlideClient | GlideClient}.
  *
@@ -789,4 +820,20 @@ export declare class GlideClient extends BaseClient {
      * ```
      */
     scan(cursor: GlideString, options?: ScanOptions & DecoderOption): Promise<[GlideString, GlideString[]]>;
+    /**
+     * Returns the current subscription state for the client.
+     *
+     * @see {@link https://valkey.io/commands/pubsub/|valkey.io} for details.
+     *
+     * @returns A promise that resolves to the subscription state containing
+     *          desired and actual subscriptions organized by channel mode.
+     *
+     * @example
+     * ```typescript
+     * const state = await client.getSubscriptions();
+     * console.log("Desired exact channels:", state.desiredSubscriptions[GlideClientConfiguration.PubSubChannelModes.Exact]);
+     * console.log("Actual exact channels:", state.actualSubscriptions[GlideClientConfiguration.PubSubChannelModes.Exact]);
+     * ```
+     */
+    getSubscriptions(): Promise<StandalonePubSubState>;
 }

package/build-ts/GlideClient.js

@@ -824,5 +824,24 @@ class GlideClient extends BaseClient_1.BaseClient {
     async scan(cursor, options) {
         return this.createWritePromise((0, Commands_1.createScan)(cursor, options), options);
     }
+    /**
+     * Returns the current subscription state for the client.
+     *
+     * @see {@link https://valkey.io/commands/pubsub/|valkey.io} for details.
+     *
+     * @returns A promise that resolves to the subscription state containing
+     *          desired and actual subscriptions organized by channel mode.
+     *
+     * @example
+     * ```typescript
+     * const state = await client.getSubscriptions();
+     * console.log("Desired exact channels:", state.desiredSubscriptions[GlideClientConfiguration.PubSubChannelModes.Exact]);
+     * console.log("Actual exact channels:", state.actualSubscriptions[GlideClientConfiguration.PubSubChannelModes.Exact]);
+     * ```
+     */
+    async getSubscriptions() {
+        const response = await this.createWritePromise((0, Commands_1.createGetSubscriptions)());
+        return this.parseGetSubscriptionsResponse(response);
+    }
 }
 exports.GlideClient = GlideClient;

package/build-ts/GlideClusterClient.d.ts

@@ -5,6 +5,16 @@ import { ClusterScanCursor, Script } from "../build-ts/native";
 import { AdvancedBaseClientConfiguration, BaseClient, BaseClientConfiguration, DecoderOption, GlideReturnType, GlideString, PubSubMsg } from "./BaseClient";
 import { ClusterBatch } from "./Batch";
 import { ClusterBatchOptions, ClusterScanOptions, FlushMode, FunctionListOptions, FunctionListResponse, FunctionRestorePolicy, FunctionStatsSingleResponse, InfoOptions, LolwutOptions } from "./Commands";
+/**
+ * Constant representing all sharded channels.
+ * Use this to unsubscribe from all sharded channel subscriptions at once..
+ *
+ * @example
+ * ```typescript
+ * await client.sunsubscribeLazy(ALL_SHARDED_CHANNELS);
+ * ```
+ */
+export declare const ALL_SHARDED_CHANNELS: null;
 /** An extension to command option types with {@link Routes}. */
 export interface RouteOption {
     /**
@@ -75,6 +85,38 @@ export declare namespace GlideClusterClientConfiguration {
         context?: any;
     }
 }
+/**
+ * Represents the subscription state for a cluster client.
+ *
+ * @remarks
+ * This interface provides information about the current PubSub subscriptions for a cluster client.
+ * It includes both the desired subscriptions (what the client wants to maintain) and the actual
+ * subscriptions (what is currently established on the server).
+ *
+ * The subscriptions are organized by channel mode:
+ * - {@link GlideClusterClientConfiguration.PubSubChannelModes.Exact | Exact}: Exact channel names
+ * - {@link GlideClusterClientConfiguration.PubSubChannelModes.Pattern | Pattern}: Channel patterns using glob-style matching
+ * - {@link GlideClusterClientConfiguration.PubSubChannelModes.Sharded | Sharded}: Sharded channels (available since Valkey 7.0)
+ *
+ * @example
+ * ```typescript
+ * const state = await clusterClient.getSubscriptions();
+ * console.log("Desired exact channels:", state.desiredSubscriptions[GlideClusterClientConfiguration.PubSubChannelModes.Exact]);
+ * console.log("Actual sharded channels:", state.actualSubscriptions[GlideClusterClientConfiguration.PubSubChannelModes.Sharded]);
+ * ```
+ */
+export interface ClusterPubSubState {
+    /**
+     * Desired subscriptions organized by channel mode.
+     * These are the subscriptions the client wants to maintain.
+     */
+    desiredSubscriptions: Partial<Record<GlideClusterClientConfiguration.PubSubChannelModes, Set<GlideString>>>;
+    /**
+     * Actual subscriptions currently active on the server.
+     * These are the subscriptions that are actually established.
+     */
+    actualSubscriptions: Partial<Record<GlideClusterClientConfiguration.PubSubChannelModes, Set<GlideString>>>;
+}
 /**
  * Configuration options for creating a {@link GlideClusterClient | GlideClusterClient}.
  *
@@ -1380,4 +1422,97 @@ export declare class GlideClusterClient extends BaseClient {
      * ```
      */
     scriptKill(options?: RouteOption): Promise<"OK">;
+    /**
+     * Subscribes the client to the specified sharded channels (non-blocking).
+     * Returns immediately without waiting for subscription confirmation.
+     * Available since Valkey 7.0.
+     *
+     * @see {@link https://valkey.io/commands/ssubscribe/|valkey.io} for details.
+     *
+     * @param channels - A collection of channel names to subscribe to.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await clusterClient.ssubscribeLazy(new Set(["shard-channel-1"]));
+     * ```
+     */
+    ssubscribeLazy(channels: Iterable<GlideString>, options?: DecoderOption): Promise<void>;
+    /**
+     * Subscribes the client to the specified sharded channels (blocking).
+     * Waits for subscription confirmation or until timeout.
+     * Available since Valkey 7.0.
+     *
+     * @see {@link https://valkey.io/commands/ssubscribe/|valkey.io} for details.
+     *
+     * @param channels - A collection of channel names to subscribe to.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when subscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * // Wait up to 5 seconds
+     * await clusterClient.ssubscribe(new Set(["shard-channel-1"]), 5000);
+     * // Wait indefinitely
+     * await clusterClient.ssubscribe(new Set(["shard-channel-1"]), 0);
+     * ```
+     */
+    ssubscribe(channels: Iterable<GlideString>, timeoutMs: number, options?: DecoderOption): Promise<void>;
+    /**
+     * Unsubscribes the client from the specified sharded channels (non-blocking).
+     * Pass null or ALL_CHANNELS to unsubscribe from all sharded channels.
+     * Available since Valkey 7.0.
+     *
+     * @see {@link https://valkey.io/commands/sunsubscribe/|valkey.io} for details.
+     *
+     * @param channels - Sharded channel names to unsubscribe from, or null for all channels.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await clusterClient.sunsubscribeLazy(new Set(["shard-channel-1"]));
+     * // Unsubscribe from all sharded channels
+     * await clusterClient.sunsubscribeLazy(ALL_SHARDED_CHANNELS);
+     * ```
+     */
+    sunsubscribeLazy(channels?: Iterable<GlideString> | null, options?: DecoderOption): Promise<void>;
+    /**
+     * Unsubscribes the client from the specified sharded channels (blocking).
+     * Pass null or ALL_CHANNELS to unsubscribe from all sharded channels.
+     * Available since Valkey 7.0.
+     *
+     * @see {@link https://valkey.io/commands/sunsubscribe/|valkey.io} for details.
+     *
+     * @param channels - Sharded channel names to unsubscribe from, or null for all channels.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when unsubscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * await clusterClient.sunsubscribe(new Set(["shard-channel-1"]), 5000);
+     * // Unsubscribe from all sharded channels with timeout
+     * await clusterClient.sunsubscribe(ALL_SHARDED_CHANNELS, 5000);
+     * ```
+     */
+    sunsubscribe(channels: Iterable<GlideString> | null, timeoutMs: number, options?: DecoderOption): Promise<void>;
+    /**
+     * Returns the current subscription state for the cluster client.
+     *
+     * @see {@link https://valkey.io/commands/pubsub/|valkey.io} for details.
+     *
+     * @returns A promise that resolves to the subscription state containing
+     *          desired and actual subscriptions organized by channel mode.
+     *
+     * @example
+     * ```typescript
+     * const state = await clusterClient.getSubscriptions();
+     * console.log("Desired exact channels:", state.desiredSubscriptions[GlideClusterClientConfiguration.PubSubChannelModes.Exact]);
+     * console.log("Actual sharded channels:", state.actualSubscriptions[GlideClusterClientConfiguration.PubSubChannelModes.Sharded]);
+     * ```
+     */
+    getSubscriptions(): Promise<ClusterPubSubState>;
 }

package/build-ts/GlideClusterClient.js

@@ -3,11 +3,21 @@
  * Copyright Valkey GLIDE Project Contributors - SPDX Identifier: Apache-2.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlideClusterClient = exports.GlideClusterClientConfiguration = void 0;
+exports.GlideClusterClient = exports.GlideClusterClientConfiguration = exports.ALL_SHARDED_CHANNELS = void 0;
 const native_1 = require("../build-ts/native");
 const ProtobufMessage_1 = require("../build-ts/ProtobufMessage");
 const BaseClient_1 = require("./BaseClient");
 const Commands_1 = require("./Commands");
+/**
+ * Constant representing all sharded channels.
+ * Use this to unsubscribe from all sharded channel subscriptions at once..
+ *
+ * @example
+ * ```typescript
+ * await client.sunsubscribeLazy(ALL_SHARDED_CHANNELS);
+ * ```
+ */
+exports.ALL_SHARDED_CHANNELS = null;
 /* eslint-disable-next-line @typescript-eslint/no-namespace */
 var GlideClusterClientConfiguration;
 (function (GlideClusterClientConfiguration) {
@@ -1239,5 +1249,113 @@ class GlideClusterClient extends BaseClient_1.BaseClient {
             ...options,
         });
     }
+    /**
+     * Subscribes the client to the specified sharded channels (non-blocking).
+     * Returns immediately without waiting for subscription confirmation.
+     * Available since Valkey 7.0.
+     *
+     * @see {@link https://valkey.io/commands/ssubscribe/|valkey.io} for details.
+     *
+     * @param channels - A collection of channel names to subscribe to.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await clusterClient.ssubscribeLazy(new Set(["shard-channel-1"]));
+     * ```
+     */
+    async ssubscribeLazy(channels, options) {
+        const channelsArray = Array.from(channels);
+        return this.createWritePromise((0, Commands_1.createSSubscribeLazy)(channelsArray), options);
+    }
+    /**
+     * Subscribes the client to the specified sharded channels (blocking).
+     * Waits for subscription confirmation or until timeout.
+     * Available since Valkey 7.0.
+     *
+     * @see {@link https://valkey.io/commands/ssubscribe/|valkey.io} for details.
+     *
+     * @param channels - A collection of channel names to subscribe to.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when subscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * // Wait up to 5 seconds
+     * await clusterClient.ssubscribe(new Set(["shard-channel-1"]), 5000);
+     * // Wait indefinitely
+     * await clusterClient.ssubscribe(new Set(["shard-channel-1"]), 0);
+     * ```
+     */
+    async ssubscribe(channels, timeoutMs, options) {
+        const channelsArray = Array.from(channels);
+        return this.createWritePromise((0, Commands_1.createSSubscribe)(channelsArray, timeoutMs), options);
+    }
+    /**
+     * Unsubscribes the client from the specified sharded channels (non-blocking).
+     * Pass null or ALL_CHANNELS to unsubscribe from all sharded channels.
+     * Available since Valkey 7.0.
+     *
+     * @see {@link https://valkey.io/commands/sunsubscribe/|valkey.io} for details.
+     *
+     * @param channels - Sharded channel names to unsubscribe from, or null for all channels.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves immediately.
+     *
+     * @example
+     * ```typescript
+     * await clusterClient.sunsubscribeLazy(new Set(["shard-channel-1"]));
+     * // Unsubscribe from all sharded channels
+     * await clusterClient.sunsubscribeLazy(ALL_SHARDED_CHANNELS);
+     * ```
+     */
+    async sunsubscribeLazy(channels, options) {
+        const channelsArray = channels ? Array.from(channels) : undefined;
+        return this.createWritePromise((0, Commands_1.createSUnsubscribeLazy)(channelsArray), options);
+    }
+    /**
+     * Unsubscribes the client from the specified sharded channels (blocking).
+     * Pass null or ALL_CHANNELS to unsubscribe from all sharded channels.
+     * Available since Valkey 7.0.
+     *
+     * @see {@link https://valkey.io/commands/sunsubscribe/|valkey.io} for details.
+     *
+     * @param channels - Sharded channel names to unsubscribe from, or null for all channels.
+     * @param timeoutMs - Maximum time in milliseconds to wait. Use 0 for indefinite wait.
+     * @param options - (Optional) See {@link DecoderOption}.
+     * @returns A promise that resolves when unsubscription is confirmed or timeout occurs.
+     *
+     * @example
+     * ```typescript
+     * await clusterClient.sunsubscribe(new Set(["shard-channel-1"]), 5000);
+     * // Unsubscribe from all sharded channels with timeout
+     * await clusterClient.sunsubscribe(ALL_SHARDED_CHANNELS, 5000);
+     * ```
+     */
+    async sunsubscribe(channels, timeoutMs, options) {
+        const channelsArray = channels ? Array.from(channels) : [];
+        return this.createWritePromise((0, Commands_1.createSUnsubscribe)(channelsArray, timeoutMs), options);
+    }
+    /**
+     * Returns the current subscription state for the cluster client.
+     *
+     * @see {@link https://valkey.io/commands/pubsub/|valkey.io} for details.
+     *
+     * @returns A promise that resolves to the subscription state containing
+     *          desired and actual subscriptions organized by channel mode.
+     *
+     * @example
+     * ```typescript
+     * const state = await clusterClient.getSubscriptions();
+     * console.log("Desired exact channels:", state.desiredSubscriptions[GlideClusterClientConfiguration.PubSubChannelModes.Exact]);
+     * console.log("Actual sharded channels:", state.actualSubscriptions[GlideClusterClientConfiguration.PubSubChannelModes.Sharded]);
+     * ```
+     */
+    async getSubscriptions() {
+        const response = await this.createWritePromise((0, Commands_1.createGetSubscriptions)());
+        return this.parseGetSubscriptionsResponse(response);
+    }
 }
 exports.GlideClusterClient = GlideClusterClient;

package/package.json

@@ -4,7 +4,7 @@
   "main": "build-ts/index.js",
   "module": "build-ts/index.js",
   "types": "build-ts/index.d.ts",
-  "version": "2.3.0-rc6",
+  "version": "2.3.0",
   "exports": {
     ".": {
       "import": {
@@ -135,11 +135,11 @@
     }
   },
   "optionalDependencies": {
-    "@valkey/valkey-glide-darwin-x64": "2.3.0-rc6",
-    "@valkey/valkey-glide-darwin-arm64": "2.3.0-rc6",
-    "@valkey/valkey-glide-linux-x64-gnu": "2.3.0-rc6",
-    "@valkey/valkey-glide-linux-arm64-gnu": "2.3.0-rc6",
-    "@valkey/valkey-glide-linux-x64-musl": "2.3.0-rc6",
-    "@valkey/valkey-glide-linux-arm64-musl": "2.3.0-rc6"
+    "@valkey/valkey-glide-darwin-x64": "2.3.0",
+    "@valkey/valkey-glide-darwin-arm64": "2.3.0",
+    "@valkey/valkey-glide-linux-x64-gnu": "2.3.0",
+    "@valkey/valkey-glide-linux-arm64-gnu": "2.3.0",
+    "@valkey/valkey-glide-linux-x64-musl": "2.3.0",
+    "@valkey/valkey-glide-linux-arm64-musl": "2.3.0"
   }
 }