@valkey/valkey-glide 2.0.0-rc5 → 2.0.0

package/build-ts/BaseClient.js

@@ -721,10 +721,13 @@ class BaseClient {
      * ```typescript
      * // Example usage of get method to retrieve the value of a key
      * const result = await client.get("key");
-     * console.log(result); // Output: 'value'
+     * console.log(result);
+     * // Output: 'value'
+     *
      * // Example usage of get method to retrieve the value of a key with Bytes decoder
      * const result = await client.get("key", { decoder: Decoder.Bytes });
-     * console.log(result); // Output: <Buffer 76 61 6c 75 65>
+     * console.log(result);
+     * // Output: <Buffer 76 61 6c 75 65>
      * ```
      */
     async get(key, options) {
@@ -747,7 +750,8 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.getex("key", {expiry: { type: TimeUnit.Seconds, count: 5 }});
-     * console.log(result); // Output: 'value'
+     * console.log(result);
+     * // Output: 'value'
      * ```
      */
     async getex(key, options) {
@@ -765,7 +769,8 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = client.getdel("key");
-     * console.log(result); // Output: 'value'
+     * console.log(result);
+     * // Output: 'value'
      *
      * const value = client.getdel("key");  // value is null
      * ```
@@ -792,13 +797,21 @@ class BaseClient {
      * ```typescript
      * await client.set("mykey", "This is a string")
      * let result = await client.getrange("mykey", 0, 3)
-     * console.log(result); // Output: "This"
+     * console.log(result);
+     * // Output: "This"
+     *
      * result = await client.getrange("mykey", -3, -1)
-     * console.log(result); // Output: "ing" - extracted last 3 characters of a string
+     * console.log(result);
+     * // Output: "ing"
+     * // extracted last 3 characters of a string
+     *
      * result = await client.getrange("mykey", 0, 100)
-     * console.log(result); // Output: "This is a string"
+     * console.log(result);
+     * // Output: "This is a string"
+     *
      * result = await client.getrange("mykey", 5, 6)
-     * console.log(result); // Output: ""
+     * console.log(result);
+     * // Output: ""
      * ```
      */
     async getrange(key, start, end, options) {
@@ -824,22 +837,33 @@ class BaseClient {
      *
      * // Example usage of set method with conditional options and expiration
      * const result2 = await client.set("key", "new_value", {conditionalSet: "onlyIfExists", expiry: { type: TimeUnit.Seconds, count: 5 }});
-     * console.log(result2); // Output: 'OK' - Set "new_value" to "key" only if "key" already exists, and set the key expiration to 5 seconds.
+     * console.log(result2);
+     * // Output: 'OK'
+     * // Set "new_value" to `key" only if `key` already exists, and set the key expiration to 5 seconds.
      *
      * // Example usage of set method with conditional options and returning old value
      * const result3 = await client.set("key", "value", {conditionalSet: "onlyIfDoesNotExist", returnOldValue: true});
-     * console.log(result3); // Output: 'new_value' - Returns the old value of "key".
+     * console.log(result3);
+     * // Output: 'new_value'
+     * // Returns the old value of `key`.
      *
      * // Example usage of get method to retrieve the value of a key
      * const result4 = await client.get("key");
-     * console.log(result4); // Output: 'new_value' - Value wasn't modified back to being "value" because of "NX" flag.
+     * console.log(result4);
+     * // Output: 'new_value'
+     * // Value wasn't modified back to being "value" because of "NX" flag.
      *
      * // Example usage of set method with conditional option IFEQ
      * await client.set("key", "value we will compare to");
      * const result5 = await client.set("key", "new_value", {conditionalSet: "onlyIfEqual", comparisonValue: "value we will compare to"});
-     * console.log(result5); // Output: 'OK' - Set "new_value" to "key" only if comparisonValue is equal to the current value of "key".
+     * console.log(result5);
+     * // Output: 'OK'
+     * // Set "new_value" to "key" only if comparisonValue is equal to the current value of "key".
+     *
      * const result6 = await client.set("key", "another_new_value", {conditionalSet: "onlyIfEqual", comparisonValue: "value we will compare to"});
-     * console.log(result6); // Output: `null` - Value wasn't set because the comparisonValue is not equal to the current value of "key". Value of "key" remains "new_value".
+     * console.log(result6);
+     * // Output: null
+     * // Value wasn't set because the comparisonValue is not equal to the current value of `key`. Value of `key` remains "new_value".
      * ```
      */
     async set(key, value, options) {
@@ -890,13 +914,15 @@ class BaseClient {
      * @example
      * ```typescript
      * let result = await client.dump("myKey");
-     * console.log(result); // Output: the serialized value of "myKey"
+     * console.log(result);
+     * // Result contains the serialized value of `myKey`
      * ```
      *
      * @example
      * ```typescript
      * result = await client.dump("nonExistingKey");
-     * console.log(result); // Output: `null`
+     * console.log(result);
+     * // Output: null
      * ```
      */
     async dump(key) {
@@ -967,7 +993,8 @@ class BaseClient {
      * await client.set("key1", "value1");
      * await client.set("key2", "value2");
      * const result = await client.mget(["key1", "key2"]);
-     * console.log(result); // Output: ['value1', 'value2']
+     * console.log(result);
+     * // Output: ['value1', 'value2']
      * ```
      */
     async mget(keys, options) {
@@ -1140,10 +1167,14 @@ class BaseClient {
      * await client.set("key1", "A"); // "A" has binary value 01000001
      * await client.set("key2", "B"); // "B" has binary value 01000010
      * const result1 = await client.bitop(BitwiseOperation.AND, "destination", ["key1", "key2"]);
-     * console.log(result1); // Output: 1 - The size of the resulting string stored in "destination" is 1.
+     * console.log(result1);
+     * // Output: 1
+     * // The size of the resulting string stored in "destination" is 1.
      *
      * const result2 = await client.get("destination");
-     * console.log(result2); // Output: "@" - "@" has binary value 01000000
+     * console.log(result2);
+     * // Output: "@"
+     * // "@" has binary value 01000000
      * ```
      */
     async bitop(operation, destination, keys) {
@@ -1163,7 +1194,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.getbit("key", 1);
-     * console.log(result); // Output: 1 - The second bit of the string stored at "key" is set to 1.
+     * console.log(result);
+     * // Output: 1
+     * // The second bit of the string stored at `key` is set to 1.
      * ```
      */
     async getbit(key, offset) {
@@ -1185,7 +1218,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.setbit("key", 1, 1);
-     * console.log(result); // Output: 0 - The second bit value was 0 before setting to 1.
+     * console.log(result);
+     * // Output: 0
+     * // The second bit value was 0 before setting to 1.
      * ```
      */
     async setbit(key, offset, value) {
@@ -1210,17 +1245,25 @@ class BaseClient {
      * ```typescript
      * await client.set("key1", "A1");  // "A1" has binary value 01000001 00110001
      * const result1 = await client.bitpos("key1", 1);
-     * console.log(result1); // Output: 1 - The first occurrence of bit value 1 in the string stored at "key1" is at the second position.
+     * console.log(result1);
+     * // Output: 1
+     * // The first occurrence of bit value 1 in the string stored at `key1` is at the second position.
      *
      * const result2 = await client.bitpos("key1", 1, { start: -1 });
-     * console.log(result2); // Output: 10 - The first occurrence of bit value 1, starting at the last byte in the string stored at "key1", is at the eleventh position.
+     * console.log(result2);
+     * // Output: 10
+     * // The first occurrence of bit value 1, starting at the last byte in the string stored at `key1`, is at the eleventh position.
      *
      * await client.set("key1", "A12");  // "A12" has binary value 01000001 00110001 00110010
      * const result3 = await client.bitpos("key1", 1, { start: 1, end: -1 });
-     * console.log(result3); // Output: 10 - The first occurrence of bit value 1 in the second byte to the last byte of the string stored at "key1" is at the eleventh position.
+     * console.log(result3);
+     * // Output: 10
+     * // The first occurrence of bit value 1 in the second byte to the last byte of the string stored at `key1` is at the eleventh position.
      *
      * const result4 = await client.bitpos("key1", 1, { start: 2, end: 9, indexType: BitmapIndexType.BIT });
-     * console.log(result4); // Output: 7 - The first occurrence of bit value 1 in the third to tenth bits of the string stored at "key1" is at the eighth position.
+     * console.log(result4);
+     * // Output: 7
+     * // The first occurrence of bit value 1 in the third to tenth bits of the string stored at `key1` is at the eighth position.
      * ```
      */
     async bitpos(key, bit, options) {
@@ -1254,7 +1297,9 @@ class BaseClient {
      * ```typescript
      * await client.set("key", "A");  // "A" has binary value 01000001
      * const result = await client.bitfield("key", [new BitFieldSet(new UnsignedEncoding(2), new BitOffset(1), 3), new BitFieldGet(new UnsignedEncoding(2), new BitOffset(1))]);
-     * console.log(result); // Output: [2, 3] - The old value at offset 1 with an unsigned encoding of 2 was 2. The new value at offset 1 with an unsigned encoding of 2 is 3.
+     * console.log(result);
+     * // Output: [2, 3]
+     * // The old value at offset 1 with an unsigned encoding of 2 was 2. The new value at offset 1 with an unsigned encoding of 2 is 3.
      * ```
      */
     async bitfield(key, subcommands) {
@@ -1274,7 +1319,9 @@ class BaseClient {
      * ```typescript
      * await client.set("key", "A");  // "A" has binary value 01000001
      * const result = await client.bitfieldReadOnly("key", [new BitFieldGet(new UnsignedEncoding(2), new BitOffset(1))]);
-     * console.log(result); // Output: [2] - The value at offset 1 with an unsigned encoding of 2 is 2.
+     * console.log(result);
+     * // Output: [2]
+     * // The value at offset 1 with an unsigned encoding of 2 is 2.
      * ```
      */
     async bitfieldReadOnly(key, subcommands) {
@@ -1294,14 +1341,18 @@ class BaseClient {
      * // Example usage of the hget method on an-existing field
      * await client.hset("my_hash", {"field": "value"});
      * const result = await client.hget("my_hash", "field");
-     * console.log(result); // Output: "value"
+     * console.log(result);
+     * // Output: "value"
+     * // The value associated with `field` in the key `my_hash`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the hget method on a non-existing field
      * const result = await client.hget("my_hash", "nonexistent_field");
-     * console.log(result); // Output: null
+     * console.log(result);
+     * // Output: null
+     * // Indicates non existent key.
      * ```
      */
     async hget(key, field, options) {
@@ -1319,11 +1370,15 @@ class BaseClient {
      * ```typescript
      * // Example usage of the hset method using HashDataType as input type
      * const result = await client.hset("my_hash", [{"field": "field1", "value": "value1"}, {"field": "field2", "value": "value2"}]);
-     * console.log(result); // Output: 2 - Indicates that 2 fields were successfully set in the hash "my_hash".
+     * console.log(result);
+     * // Output: 2
+     * // Indicates that 2 fields were successfully set in the hash `my_hash`.
      *
      * // Example usage of the hset method using Record<string, GlideString> as input
      * const result = await client.hset("my_hash", {"field1": "value", "field2": "value2"});
-     * console.log(result); // Output: 2 - Indicates that 2 fields were successfully set in the hash "my_hash".
+     * console.log(result);
+     * // Output: 2
+     * // Indicates that 2 fields were successfully set in the hash `my_hash`.
      * ```
      */
     async hset(key, fieldsAndValues) {
@@ -1343,7 +1398,9 @@ class BaseClient {
      * // Example usage of the hkeys method:
      * await client.hset("my_hash", {"field1": "value1", "field2": "value2", "field3": "value3"});
      * const result = await client.hkeys("my_hash");
-     * console.log(result); // Output: ["field1", "field2", "field3"]  - Returns all the field names stored in the hash "my_hash".
+     * console.log(result);
+     * // Output: ["field1", "field2", "field3"]
+     * // Returns all the field names stored in the hash `my_hash`.
      * ```
      */
     async hkeys(key, options) {
@@ -1364,14 +1421,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the hsetnx method
      * const result = await client.hsetnx("my_hash", "field", "value");
-     * console.log(result); // Output: true - Indicates that the field "field" was set successfully in the hash "my_hash".
+     * console.log(result);
+     * // Output: true
+     * // Indicates that the field "field" was set successfully in the hash `my_hash`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the hsetnx method on a field that already exists
      * const result = await client.hsetnx("my_hash", "field", "new_value");
-     * console.log(result); // Output: false - Indicates that the field "field" already existed in the hash "my_hash" and was not set again.
+     * console.log(result);
+     * // Output: false
+     * // Indicates that the field `field` already existed in the hash `my_hash` and was not set again.
      * ```
      */
     async hsetnx(key, field, value) {
@@ -1391,7 +1452,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the hdel method
      * const result = await client.hdel("my_hash", ["field1", "field2"]);
-     * console.log(result); // Output: 2 - Indicates that two fields were successfully removed from the hash.
+     * console.log(result);
+     * // Output: 2
+     * // Indicates that two fields were successfully removed from the hash.
      * ```
      */
     async hdel(key, fields) {
@@ -1412,7 +1475,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the hmget method
      * const result = await client.hmget("my_hash", ["field1", "field2"]);
-     * console.log(result); // Output: ["value1", "value2"] - A list of values associated with the specified fields.
+     * console.log(result);
+     * // Output: ["value1", "value2"]
+     * // A list of values associated with the specified fields.
      * ```
      */
     async hmget(key, fields, options) {
@@ -1430,14 +1495,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the hexists method with existing field
      * const result = await client.hexists("my_hash", "field1");
-     * console.log(result); // Output: true
+     * console.log(result);
+     * // Output: true
+     * // Returns true because `my_hash` hash contains `field1` field.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the hexists method with non-existing field
      * const result = await client.hexists("my_hash", "nonexistent_field");
-     * console.log(result); // Output: false
+     * console.log(result);
+     * // Output: false
+     * // Returns false because `my_hash` hash does not contain `nonexistent_field` field.
      * ```
      */
     async hexists(key, field) {
@@ -1457,7 +1526,8 @@ class BaseClient {
      * ```typescript
      * // Example usage of the hgetall method
      * const result = await client.hgetall("my_hash");
-     * console.log(result); // Output:
+     * console.log(result);
+     * // Output: all fields and values stored at `my_hash`
      * // [
      * //     { field: "field1", value: "value1"},
      * //     { field: "field2", value: "value2"}
@@ -1484,7 +1554,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the hincrby method to increment the value in a hash by a specified amount
      * const result = await client.hincrby("my_hash", "field1", 5);
-     * console.log(result); // Output: 5
+     * console.log(result);
+     * // Output: 5
+     * // Increments the value stored at hash field `field1` by 5
      * ```
      */
     async hincrBy(key, field, amount) {
@@ -1505,7 +1577,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the hincrbyfloat method to increment the value of a floating point in a hash by a specified amount
      * const result = await client.hincrbyfloat("my_hash", "field1", 2.5);
-     * console.log(result); // Output: 2.5
+     * console.log(result);
+     * // Output: 2.5
+     * // Increments the value stored at hash field `field1` by 2.5
      * ```
      */
     async hincrByFloat(key, field, amount) {
@@ -1522,14 +1596,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the hlen method with an existing key
      * const result = await client.hlen("my_hash");
-     * console.log(result); // Output: 3
+     * console.log(result);
+     * // Output: 3
+     * // Returns the number of fields for the hash stored at key `my_hash`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the hlen method with a non-existing key
      * const result = await client.hlen("non_existing_key");
-     * console.log(result); // Output: 0
+     * console.log(result);
+     * // Output: 0
+     * // Returns 0 for non-existent key.
      * ```
      */
     async hlen(key) {
@@ -1547,7 +1625,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the hvals method
      * const result = await client.hvals("my_hash");
-     * console.log(result); // Output: ["value1", "value2", "value3"] - Returns all the values stored in the hash "my_hash".
+     * console.log(result);
+     * // Output: ["value1", "value2", "value3"]
+     * // Returns all the values stored in the hash `my_hash`.
      * ```
      */
     async hvals(key, options) {
@@ -1566,7 +1646,9 @@ class BaseClient {
      * ```typescript
      * await client.hset("my_hash", {"field": "value"});
      * const result = await client.hstrlen("my_hash", "field");
-     * console.log(result); // Output: 5
+     * console.log(result);
+     * // Output: 5
+     * // Returns the string length of `value` which is the value associated with the field `field` stored at key `my_hash`.
      * ```
      */
     async hstrlen(key, field) {
@@ -1585,7 +1667,10 @@ class BaseClient {
      *
      * @example
      * ```typescript
-     * console.log(await client.hrandfield("myHash")); // Output: 'field'
+     * const result = await client.hrandfield("myHash")
+     * console.log(result);
+     * // Output: 'field'
+     * // Returns a random field stored at the key `my_hash`.
      * ```
      */
     async hrandfield(key, options) {
@@ -1621,12 +1706,13 @@ class BaseClient {
      *      console.log("Members: ", result[1]);
      * } while (newCursor !== "0");
      * // The output of the code above is something similar to:
-     * // Cursor:  31
-     * // Members:  ['field 79', 'value 79', 'field 20', 'value 20', 'field 115', 'value 115']
-     * // Cursor:  39
-     * // Members:  ['field 63', 'value 63', 'field 293', 'value 293', 'field 162', 'value 162']
-     * // Cursor:  0
+     * // Cursor:  31  // The cursor after the first interation.
+     * // Members:  ['field 79', 'value 79', 'field 20', 'value 20', 'field 115', 'value 115'] // First 3 hash field-value pairs stored at the key `key1`
+     * // Cursor:  39 // The cursor after the second interation.
+     * // Members:  ['field 63', 'value 63', 'field 293', 'value 293', 'field 162', 'value 162'] // The next 3 hash field-value pairs at key `key1`
+     * // Cursor:  0 // The cursor after the last batch of elements is fetched.
      * // Members:  ['field 55', 'value 55', 'field 24', 'value 24', 'field 90', 'value 90', 'field 113', 'value 113']
+     * // You can get more than `count` elements in the result set. Read the count documentation for more information.
      * ```
      * @example
      * ```typescript
@@ -1644,12 +1730,13 @@ class BaseClient {
      *      console.log("Members: ", result[1]);
      * } while (newCursor !== "0");
      * // The output of the code above is something similar to:
-     * // Cursor:  31
-     * // Members:  ['field 79', 'field 20', 'field 115']
-     * // Cursor:  39
-     * // Members:  ['field 63', 'field 293', 'field 162']
-     * // Cursor:  0
+     * // Cursor:  31 // The cursor after the first interation.
+     * // Members:  ['field 79', 'field 20', 'field 115'] // First 3 hash fields stored at the key `key1`
+     * // Cursor:  39 // The cursor after the second interation.
+     * // Members:  ['field 63', 'field 293', 'field 162'] // Next 3 hash fields stored at the key `key1`
+     * // Cursor:  0 // The cursor after the last batch of elements is fetched.
      * // Members:  ['field 55', 'field 24', 'field 90', 'field 113']
+     * // You can get more than `count` elements in the result set. Read the count documentation for more information.
      * ```
      */
     async hscan(key, cursor, options) {
@@ -1671,7 +1758,10 @@ class BaseClient {
      *
      * @example
      * ```typescript
-     * console.log(await client.hrandfieldCount("myHash", 2)); // Output: ['field1', 'field2']
+     * result = await client.hrandfieldCount("my_hash", 2)
+     * console.log(result);
+     * // Output: ['field1', 'field2']
+     * // Returns 2 random fields from the hash stored at key `my_hash`.
      * ```
      */
     async hrandfieldCount(key, count, options) {
@@ -1696,7 +1786,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.hrandfieldCountWithValues("myHash", 2);
-     * console.log(result); // Output: [['field1', 'value1'], ['field2', 'value2']]
+     * console.log(result);
+     * // Output: [['field1', 'value1'], ['field2', 'value2']]
+     * // Returns 2 random field-value pairs from the hash stored at key `my_hash`.
      * ```
      */
     async hrandfieldWithValues(key, count, options) {
@@ -1716,14 +1808,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the lpush method with an existing list
      * const result = await client.lpush("my_list", ["value2", "value3"]);
-     * console.log(result); // Output: 3 - Indicated that the new length of the list is 3 after the push operation.
+     * console.log(result);
+     * // Output: 3
+     * // Indicates that the new length of the list is 3 after the push operation.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the lpush method with a non-existing list
      * const result = await client.lpush("nonexistent_list", ["new_value"]);
-     * console.log(result); // Output: 1 - Indicates that a new list was created with one element
+     * console.log(result);
+     * // Output: 1
+     * // Indicates that a new list was created with one element
      * ```
      */
     async lpush(key, elements) {
@@ -1740,8 +1836,10 @@ class BaseClient {
      * @returns The length of the list after the push operation.
      * @example
      * ```typescript
-     * const listLength = await client.lpushx("my_list", ["value1", "value2"]);
-     * console.log(result); // Output: 2 - Indicates that the list has two elements.
+     * const result = await client.lpushx("my_list", ["value1", "value2"]);
+     * console.log(result);
+     * // Output: 2
+     * // Indicates that the list has two elements after the push operation.
      * ```
      */
     async lpushx(key, elements) {
@@ -1761,14 +1859,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the lpop method with an existing list
      * const result = await client.lpop("my_list");
-     * console.log(result); // Output: 'value1'
+     * console.log(result);
+     * // Output: 'value1'
+     * // Returns and removes the first element of the list `value1`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the lpop method with a non-existing list
      * const result = await client.lpop("non_exiting_key");
-     * console.log(result); // Output: null
+     * console.log(result);
+     * // Output: null
+     * // Returns null for non-existent key.
      * ```
      */
     async lpop(key, options) {
@@ -1788,14 +1890,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the lpopCount method with an existing list
      * const result = await client.lpopCount("my_list", 2);
-     * console.log(result); // Output: ["value1", "value2"]
+     * console.log(result);
+     * // Output: ["value1", "value2"]
+     * // Returns and removes 2 elements from the list.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the lpopCount method with a non-existing list
      * const result = await client.lpopCount("non_exiting_key", 3);
-     * console.log(result); // Output: null
+     * console.log(result);
+     * // Output: null
+     * // Returns null in case of non-existent key.
      * ```
      */
     async lpopCount(key, count, options) {
@@ -1821,21 +1927,27 @@ class BaseClient {
      * ```typescript
      * // Example usage of the lrange method with an existing list and positive indices
      * const result = await client.lrange("my_list", 0, 2);
-     * console.log(result); // Output: ["value1", "value2", "value3"]
+     * console.log(result);
+     * // Output: ["value1", "value2", "value3"]
+     * // Returns the first 3 elements of the list.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the lrange method with an existing list and negative indices
      * const result = await client.lrange("my_list", -2, -1);
-     * console.log(result); // Output: ["value2", "value3"]
+     * console.log(result);
+     * // Output: ["value2", "value3"]
+     * // Returns the last 2 elements of the list.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the lrange method with a non-existing list
      * const result = await client.lrange("non_exiting_key", 0, 2);
-     * console.log(result); // Output: []
+     * console.log(result);
+     * // Output: []
+     * // Returns an empty list for non-existent key.
      * ```
      */
     async lrange(key, start, end, options) {
@@ -1853,7 +1965,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the llen method
      * const result = await client.llen("my_list");
-     * console.log(result); // Output: 3 - Indicates that there are 3 elements in the list.
+     * console.log(result);
+     * // Output: 3
+     * // Indicates that there are 3 elements in the list.
      * ```
      */
     async llen(key) {
@@ -1876,17 +1990,23 @@ class BaseClient {
      *
      * @example
      * ```typescript
-     * await client.lpush("testKey1", ["two", "one"]);
-     * await client.lpush("testKey2", ["four", "three"]);
+     * await client.lpush("testKey1", ["two", "one"]); // The key `testKey1` has a list ["one", "two"] after this operation.
+     * await client.lpush("testKey2", ["four", "three"]); // The key `testKey2` has a list ["three", "four"] after this operation.
      *
-     * const result1 = await client.lmove("testKey1", "testKey2", ListDirection.LEFT, ListDirection.LEFT);
-     * console.log(result1); // Output: "one".
+     * const result = await client.lmove("testKey1", "testKey2", ListDirection.LEFT, ListDirection.LEFT);
+     * console.log(result);
+     * // Output: "one".
+     * // Removes "one" from the list at key `testKey1` and adds it to the left of the list at `testKey2`.
      *
      * const updated_array_key1 = await client.lrange("testKey1", 0, -1);
-     * console.log(updated_array); // Output: "two".
+     * console.log(updated_array_key1);
+     * // Output: ["two"]
+     * // The elements in the list at `testKey1` after lmove command.
      *
      * const updated_array_key2 = await client.lrange("testKey2", 0, -1);
-     * console.log(updated_array_key2); // Output: ["one", "three", "four"].
+     * console.log(updated_array_key2);
+     * // Output: ["one", "three", "four"]
+     * // The elements in the list at `testKey2` after lmove command.
      * ```
      */
     async lmove(source, destination, whereFrom, whereTo, options) {
@@ -1913,16 +2033,22 @@ class BaseClient {
      *
      * @example
      * ```typescript
-     * await client.lpush("testKey1", ["two", "one"]);
-     * await client.lpush("testKey2", ["four", "three"]);
+     * await client.lpush("testKey1", ["two", "one"]); // The key `testKey1` has a list ["one", "two"] after this operation.
+     * await client.lpush("testKey2", ["four", "three"]); // The key `testKey2` has a list ["three", "four"] after this operation.
      * const result = await client.blmove("testKey1", "testKey2", ListDirection.LEFT, ListDirection.LEFT, 0.1);
-     * console.log(result); // Output: "one"
+     * console.log(result);
+     * // Output: "one"
+     * // Removes "one" from the list at key `testKey1` and adds it to the left of the list at `testKey2`.
      *
-     * const result2 = await client.lrange("testKey1", 0, -1);
-     * console.log(result2);   // Output: "two"
+     * const updated_array1 = await client.lrange("testKey1", 0, -1);
+     * console.log(updated_array1);
+     * // Output: "two"
+     * // The elements in the list at `testKey1` after blmove command.
      *
      * const updated_array2 = await client.lrange("testKey2", 0, -1);
-     * console.log(updated_array2); // Output: ["one", "three", "four"]
+     * console.log(updated_array2);
+     * // Output: ["one", "three", "four"]
+     * // The elements in the list at `testKey2` after blmove command.
      * ```
      */
     async blmove(source, destination, whereFrom, whereTo, timeout, options) {
@@ -1944,8 +2070,10 @@ class BaseClient {
      * @example
      * ```typescript
      * // Example usage of the lset method
-     * const response = await client.lset("test_key", 1, "two");
-     * console.log(response); // Output: 'OK' - Indicates that the second index of the list has been set to "two".
+     * const result = await client.lset("test_key", 1, "two");
+     * console.log(result);
+     * // Output: 'OK'
+     * // Indicates that the second index of the list has been set to "two".
      * ```
      */
     async lset(key, index, element) {
@@ -1964,7 +2092,7 @@ class BaseClient {
      * @param start - The starting point of the range.
      * @param end - The end of the range.
      * @returns always "OK".
-     * If `start` exceeds the end of the list, or if `start` is greater than `end`, the result will be an empty list (which causes key to be removed).
+     * If `start` exceeds the end of the list, or if `start` is greater than `end`, the list is emptied and the key is removed.
      * If `end` exceeds the actual end of the list, it will be treated like the last element of the list.
      * If `key` does not exist the command will be ignored.
      *
@@ -1972,7 +2100,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the ltrim method
      * const result = await client.ltrim("my_list", 0, 1);
-     * console.log(result); // Output: 'OK' - Indicates that the list has been trimmed to contain elements from 0 to 1.
+     * console.log(result);
+     * // Output: 'OK'
+     * // Indicates that the list has been trimmed to contain elements from 0 to 1.
      * ```
      */
     async ltrim(key, start, end) {
@@ -1981,12 +2111,12 @@ class BaseClient {
         });
     }
     /** Removes the first `count` occurrences of elements equal to `element` from the list stored at `key`.
-     * If `count` is positive : Removes elements equal to `element` moving from head to tail.
-     * If `count` is negative : Removes elements equal to `element` moving from tail to head.
-     * If `count` is 0 or `count` is greater than the occurrences of elements equal to `element`: Removes all elements equal to `element`.
      *
      * @param key - The key of the list.
      * @param count - The count of the occurrences of elements equal to `element` to remove.
+     * If `count` is positive : Removes elements equal to `element` moving from head to tail.
+     * If `count` is negative : Removes elements equal to `element` moving from tail to head.
+     * If `count` is 0 or `count` is greater than the occurrences of elements equal to `element`: Removes all elements equal to `element`.
      * @param element - The element to remove from the list.
      * @returns the number of the removed elements.
      * If `key` does not exist, 0 is returned.
@@ -1995,7 +2125,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the lrem method
      * const result = await client.lrem("my_list", 2, "value");
-     * console.log(result); // Output: 2 - Removes the first 2 occurrences of "value" in the list.
+     * console.log(result);
+     * // Output: 2
+     * // Removes the first 2 occurrences of "value" in the list.
      * ```
      */
     async lrem(key, count, element) {
@@ -2015,14 +2147,17 @@ class BaseClient {
      * ```typescript
      * // Example usage of the rpush method with an existing list
      * const result = await client.rpush("my_list", ["value2", "value3"]);
-     * console.log(result); // Output: 3 - Indicates that the new length of the list is 3 after the push operation.
+     * console.log(result);
+     * // Output: 3
+     * // Indicates that the new length of the list is 3 after the push operation.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the rpush method with a non-existing list
      * const result = await client.rpush("nonexistent_list", ["new_value"]);
-     * console.log(result); // Output: 1
+     * console.log(result);
+     * // Output: 1
      * ```
      */
     async rpush(key, elements) {
@@ -2040,7 +2175,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.rpushx("my_list", ["value1", "value2"]);
-     * console.log(result);  // Output: 2 - Indicates that the list has two elements.
+     * console.log(result);
+     * // Output: 2
+     * // Indicates that the list has two elements.
      * ```
      * */
     async rpushx(key, elements) {
@@ -2060,14 +2197,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the rpop method with an existing list
      * const result = await client.rpop("my_list");
-     * console.log(result); // Output: 'value1'
+     * console.log(result);
+     * // Output: 'value1'
+     * // Returns and removes the last element of the list stored at `my_list`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the rpop method with a non-existing list
      * const result = await client.rpop("non_exiting_key");
-     * console.log(result); // Output: null
+     * console.log(result);
+     * // Output: null
+     * // Returns null for non-existent key.
      * ```
      */
     async rpop(key, options) {
@@ -2087,14 +2228,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the rpopCount method with an existing list
      * const result = await client.rpopCount("my_list", 2);
-     * console.log(result); // Output: ["value1", "value2"]
+     * console.log(result);
+     * // Output: ["value1", "value2"]
+     * // Returns and removes the last 2 elements from the list stored at `my_list`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the rpopCount method with a non-existing list
      * const result = await client.rpopCount("non_exiting_key", 7);
-     * console.log(result); // Output: null
+     * console.log(result);
+     * // Output: null
+     * // Returns null for a non-existing key.
      * ```
      */
     async rpopCount(key, count, options) {
@@ -2113,7 +2258,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the sadd method with an existing set
      * const result = await client.sadd("my_set", ["member1", "member2"]);
-     * console.log(result); // Output: 2
+     * console.log(result);
+     * // Output: 2
+     * // Adds 2 members to the set at key `my_set`
      * ```
      */
     async sadd(key, members) {
@@ -2132,7 +2279,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the srem method
      * const result = await client.srem("my_set", ["member1", "member2"]);
-     * console.log(result); // Output: 2
+     * console.log(result);
+     * // Output: 2
+     * // Removes `member1` and `member2` from the set at key `my_set`.
      * ```
      */
     async srem(key, members) {
@@ -2190,7 +2339,8 @@ class BaseClient {
      * ```typescript
      * // Example usage of the smembers method
      * const result = await client.smembers("my_set");
-     * console.log(result); // Output: Set {'member1', 'member2', 'member3'}
+     * console.log(result);
+     * // Output: Set(3) {'member1', 'member2', 'member3'}
      * ```
      */
     async smembers(key, options) {
@@ -2210,7 +2360,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.smove("set1", "set2", "member1");
-     * console.log(result); // Output: true - "member1" was moved from "set1" to "set2".
+     * console.log(result);
+     * // Output: true
+     * // `member1` was moved from `set1` to `set2`.
      * ```
      */
     async smove(source, destination, member) {
@@ -2227,7 +2379,8 @@ class BaseClient {
      * ```typescript
      * // Example usage of the scard method
      * const result = await client.scard("my_set");
-     * console.log(result); // Output: 3
+     * console.log(result);
+     * // Output: 3
      * ```
      */
     async scard(key) {
@@ -2247,14 +2400,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of sinter method when member exists
      * const result = await client.sinter(["my_set1", "my_set2"]);
-     * console.log(result); // Output: Set {'member2'} - Indicates that sets have one common member
+     * console.log(result);
+     * // Output: Set(1) {'member2'}
+     * // Indicates that sets have one common member
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of sinter method with non-existing key
      * const result = await client.sinter(["my_set", "non_existing_key"]);
-     * console.log(result); // Output: Set {} - An empty set is returned since the key does not exist.
+     * console.log(result);
+     * // Output: Set(0) {}
+     * // An empty set is returned since the key does not exist.
      * ```
      */
     async sinter(keys, options) {
@@ -2277,10 +2434,14 @@ class BaseClient {
      * await client.sadd("set1", ["a", "b", "c"]);
      * await client.sadd("set2", ["b", "c", "d"]);
      * const result1 = await client.sintercard(["set1", "set2"]);
-     * console.log(result1); // Output: 2 - The intersection of "set1" and "set2" contains 2 elements: "b" and "c".
+     * console.log(result1);
+     * // Output: 2
+     * // The intersection of `set1` and `set2` contains 2 elements: `b` and `c`.
      *
      * const result2 = await client.sintercard(["set1", "set2"], { limit: 1 });
-     * console.log(result2); // Output: 1 - The computation stops early as the intersection cardinality reaches the limit of 1.
+     * console.log(result2);
+     * // Output: 1
+     * // The computation stops early as the intersection cardinality reaches the limit of 1.
      * ```
      */
     async sintercard(keys, options) {
@@ -2299,7 +2460,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.sinterstore("my_set", ["set1", "set2"]);
-     * console.log(result); // Output: 2 - Two elements were stored at "my_set", and those elements are the intersection of "set1" and "set2".
+     * console.log(result);
+     * // Output: 2
+     * // Two elements were stored at `my_set`, and those elements are the intersection of `set1` and `set2`.
      * ```
      */
     async sinterstore(destination, keys) {
@@ -2321,7 +2484,9 @@ class BaseClient {
      * await client.sadd("set1", ["member1", "member2"]);
      * await client.sadd("set2", ["member1"]);
      * const result = await client.sdiff(["set1", "set2"]);
-     * console.log(result); // Output: Set {"member1"} - "member2" is in "set1" but not "set2"
+     * console.log(result);
+     * // Output: Set(1) {"member1"}
+     * // `member2` is in `set1` but not `set2`
      * ```
      */
     async sdiff(keys, options) {
@@ -2342,7 +2507,9 @@ class BaseClient {
      * await client.sadd("set1", ["member1", "member2"]);
      * await client.sadd("set2", ["member1"]);
      * const result = await client.sdiffstore("set3", ["set1", "set2"]);
-     * console.log(result); // Output: 1 - One member was stored in "set3", and that member is the diff between "set1" and "set2".
+     * console.log(result);
+     * // Output: 1
+     * // One member was stored in `set3`, and that member is the diff between `set1` and `set2`.
      * ```
      */
     async sdiffstore(destination, keys) {
@@ -2364,10 +2531,13 @@ class BaseClient {
      * await client.sadd("my_set1", ["member1", "member2"]);
      * await client.sadd("my_set2", ["member2", "member3"]);
      * const result1 = await client.sunion(["my_set1", "my_set2"]);
-     * console.log(result1); // Output: Set {'member1', 'member2', 'member3'} - Sets "my_set1" and "my_set2" have three unique members.
+     * console.log(result1);
+     * // Output: Set(3) {'member1', 'member2', 'member3'}
+     * // Sets `my_set1` and `my_set2` have three unique members.
      *
      * const result2 = await client.sunion(["my_set1", "non_existing_set"]);
-     * console.log(result2); // Output: Set {'member1', 'member2'}
+     * console.log(result2);
+     * // Output: Set(2) {'member1', 'member2'}
      * ```
      */
     async sunion(keys, options) {
@@ -2387,7 +2557,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const length = await client.sunionstore("mySet", ["set1", "set2"]);
-     * console.log(length); // Output: 2 - Two elements were stored in "mySet", and those two members are the union of "set1" and "set2".
+     * console.log(length);
+     * // Output: 2
+     * // Two elements were stored in `mySet`, and those two members are the union of `set1` and `set2`.
      * ```
      */
     async sunionstore(destination, keys) {
@@ -2406,14 +2578,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the sismember method when member exists
      * const result = await client.sismember("my_set", "member1");
-     * console.log(result); // Output: true - Indicates that "member1" exists in the set "my_set".
+     * console.log(result);
+     * // Output: true
+     * // Indicates that `member1` exists in the set `my_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the sismember method when member does not exist
      * const result = await client.sismember("my_set", "non_existing_member");
-     * console.log(result); // Output: false - Indicates that "non_existing_member" does not exist in the set "my_set".
+     * console.log(result);
+     * // Output: false
+     * // Indicates that `non_existing_member` does not exist in the set `my_set`.
      * ```
      */
     async sismember(key, member) {
@@ -2433,7 +2609,9 @@ class BaseClient {
      * ```typescript
      * await client.sadd("set1", ["a", "b", "c"]);
      * const result = await client.smismember("set1", ["b", "c", "d"]);
-     * console.log(result); // Output: [true, true, false] - "b" and "c" are members of "set1", but "d" is not.
+     * console.log(result);
+     * // Output: [true, true, false]
+     * // `b` and `c` are members of `set1`, but `d` is not.
      * ```
      */
     async smismember(key, members) {
@@ -2453,14 +2631,17 @@ class BaseClient {
      * ```typescript
      * // Example usage of spop method to remove and return a random member from a set
      * const result = await client.spop("my_set");
-     * console.log(result); // Output: 'member1' - Removes and returns a random member from the set "my_set".
+     * console.log(result);
+     * // Output: 'member1'
+     * // Removes and returns a random member from the set `my_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of spop method with non-existing key
      * const result = await client.spop("non_existing_key");
-     * console.log(result); // Output: null
+     * console.log(result);
+     * // Output: null
      * ```
      */
     async spop(key, options) {
@@ -2480,14 +2661,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of spopCount method to remove and return multiple random members from a set
      * const result = await client.spopCount("my_set", 2);
-     * console.log(result); // Output: Set {'member2', 'member3'} - Removes and returns 2 random members from the set "my_set".
+     * console.log(result);
+     * // Output: Set(2) {'member2', 'member3'}
+     * // Removes and returns 2 random members from the set `my_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of spopCount method with non-existing key
      * const result = await client.spopCount("non_existing_key");
-     * console.log(result); // Output: Set {} - An empty set is returned since the key does not exist.
+     * console.log(result);
+     * // Output: Set(0) {}
+     * // An empty set is returned since the key does not exist.
      * ```
      */
     async spopCount(key, count, options) {
@@ -2506,14 +2691,17 @@ class BaseClient {
      * ```typescript
      * // Example usage of srandmember method to return a random member from a set
      * const result = await client.srandmember("my_set");
-     * console.log(result); // Output: 'member1' - A random member of "my_set".
+     * console.log(result);
+     * // Output: 'member1'
+     * // A random member of `my_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of srandmember method with non-existing key
      * const result = await client.srandmember("non_existing_set");
-     * console.log(result); // Output: null
+     * console.log(result);
+     * // Output: null
      * ```
      */
     async srandmember(key, options) {
@@ -2535,14 +2723,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of srandmemberCount method to return multiple random members from a set
      * const result = await client.srandmemberCount("my_set", -3);
-     * console.log(result); // Output: ['member1', 'member1', 'member2'] - Random members of "my_set".
+     * console.log(result);
+     * // Output: ['member1', 'member1', 'member2']
+     * // Random members of `my_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of srandmemberCount method with non-existing key
      * const result = await client.srandmemberCount("non_existing_set", 3);
-     * console.log(result); // Output: [] - An empty list since the key does not exist.
+     * console.log(result);
+     * // Output: []
+     * // An empty list since the key does not exist.
      * ```
      */
     async srandmemberCount(key, count, options) {
@@ -2569,7 +2761,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the exists method
      * const result = await client.exists(["key1", "key2", "key3"]);
-     * console.log(result); // Output: 3 - Indicates that all three keys exist in the database.
+     * console.log(result);
+     * // Output: 3
+     * // Indicates that all three keys exist in the database.
      * ```
      */
     async exists(keys) {
@@ -2597,7 +2791,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the unlink method
      * const result = await client.unlink(["key1", "key2", "key3"]);
-     * console.log(result); // Output: 3 - Indicates that all three keys were unlinked from the database.
+     * console.log(result);
+     * // Output: 3
+     * // Indicates that all three keys were unlinked from the database.
      * ```
      */
     async unlink(keys) {
@@ -2622,14 +2818,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the expire method
      * const result = await client.expire("my_key", 60);
-     * console.log(result); // Output: true - Indicates that a timeout of 60 seconds has been set for "my_key".
+     * console.log(result);
+     * // Output: true
+     * // Indicates that a timeout of 60 seconds has been set for `my_key`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the expire method with exisiting expiry
      * const result = await client.expire("my_key", 60, { expireOption: ExpireOptions.HasNoExpiry });
-     * console.log(result); // Output: false - Indicates that "my_key" has an existing expiry.
+     * console.log(result);
+     * // Output: false
+     * // Indicates that `my_key` has an existing expiry.
      * ```
      */
     async expire(key, seconds, options) {
@@ -2654,7 +2854,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the expireAt method on a key with no previous expiry
      * const result = await client.expireAt("my_key", 1672531200, { expireOption: ExpireOptions.HasNoExpiry });
-     * console.log(result); // Output: true - Indicates that the expiration time for "my_key" was successfully set.
+     * console.log(result);
+     * // Output: true
+     * // Indicates that the expiration time for `my_key` was successfully set.
      * ```
      */
     async expireAt(key, unixSeconds, options) {
@@ -2673,15 +2875,21 @@ class BaseClient {
      * @example
      * ```typescript
      * const result1 = await client.expiretime("myKey");
-     * console.log(result1); // Output: -2 - myKey doesn't exist.
+     * console.log(result1);
+     * // Output: -2
+     * // `myKey` doesn't exist.
      *
-     * const result2 = await client.set(myKey, "value");
-     * const result3 = await client.expireTime(myKey);
-     * console.log(result2); // Output: -1 - myKey has no associated expiration.
+     * const result2 = await client.set("myKey", "value");
+     * const result3 = await client.expireTime("myKey");
+     * console.log(result3);
+     * // Output: -1
+     * // `myKey` has no associated expiration.
      *
      * client.expire(myKey, 60);
-     * const result3 = await client.expireTime(myKey);
-     * console.log(result3); // Output: 123456 - the Unix timestamp (in seconds) when "myKey" will expire.
+     * const result3 = await client.expireTime("myKey");
+     * console.log(result3);
+     * // Output: 123456
+     * // The Unix timestamp (in seconds) when `myKey` will expire.
      * ```
      */
     async expiretime(key) {
@@ -2706,7 +2914,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the pexpire method on a key with no previous expiry
      * const result = await client.pexpire("my_key", 60000, { expireOption: ExpireOptions.HasNoExpiry });
-     * console.log(result); // Output: true - Indicates that a timeout of 60,000 milliseconds has been set for "my_key".
+     * console.log(result);
+     * // Output: true
+     * // Indicates that a timeout of 60,000 milliseconds has been set for `my_key`.
      * ```
      */
     async pexpire(key, milliseconds, options) {
@@ -2731,7 +2941,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of the pexpireAt method on a key with no previous expiry
      * const result = await client.pexpireAt("my_key", 1672531200000, { expireOption: ExpireOptions.HasNoExpiry });
-     * console.log(result); // Output: true - Indicates that the expiration time for "my_key" was successfully set.
+     * console.log(result);
+     * // Output: true
+     * // Indicates that the expiration time for `my_key` was successfully set.
      * ```
      */
     async pexpireAt(key, unixMilliseconds, options) {
@@ -2749,15 +2961,21 @@ class BaseClient {
      * @example
      * ```typescript
      * const result1 = client.pexpiretime("myKey");
-     * console.log(result1); // Output: -2 - myKey doesn't exist.
+     * console.log(result1);
+     * // Output: -2
+     * // `myKey` doesn't exist.
      *
      * const result2 = client.set(myKey, "value");
      * const result3 = client.pexpireTime(myKey);
-     * console.log(result2); // Output: -1 - myKey has no associated expiration.
+     * console.log(result2);
+     * // Output: -1
+     * // `myKey` has no associated expiration.
      *
      * client.expire(myKey, 60);
      * const result3 = client.pexpireTime(myKey);
-     * console.log(result3); // Output: 123456789 - the Unix timestamp (in milliseconds) when "myKey" will expire.
+     * console.log(result3);
+     * // Output: 123456789
+     * // The Unix timestamp (in milliseconds) when `myKey` will expire.
      * ```
      */
     async pexpiretime(key) {
@@ -2775,21 +2993,27 @@ class BaseClient {
      * ```typescript
      * // Example usage of the ttl method with existing key
      * const result = await client.ttl("my_key");
-     * console.log(result); // Output: 3600 - Indicates that "my_key" has a remaining time to live of 3600 seconds.
+     * console.log(result);
+     * // Output: 3600
+     * // Indicates that `my_key` has a remaining time to live of 3600 seconds.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the ttl method with existing key that has no associated expire.
      * const result = await client.ttl("key");
-     * console.log(result); // Output: -1 - Indicates that the key has no associated expire.
+     * console.log(result);
+     * // Output: -1
+     * // Indicates that the key has no associated expire.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the ttl method with a non-existing key
      * const result = await client.ttl("nonexistent_key");
-     * console.log(result); // Output: -2 - Indicates that the key doesn't exist.
+     * console.log(result);
+     * // Output: -2
+     * // Indicates that the key doesn't exist.
      * ```
      */
     async ttl(key) {
@@ -2819,7 +3043,9 @@ class BaseClient {
      *      args: ["bar"],
      * };
      * const result = await invokeScript(luaScript, scriptOptions);
-     * console.log(result); // Output: ['foo', 'bar']
+     * console.log(result);
+     * // Output: ['foo', 'bar']
+     * // The result for the script.
      * ```
      */
     async invokeScript(script, options) {
@@ -2845,7 +3071,9 @@ class BaseClient {
      * ```typescript
      * const scriptHash = script.getHash();
      * const scriptSource = await client.scriptShow(scriptHash);
-     * console.log(scriptSource); // Output: "return { KEYS[1], ARGV[1] }"
+     * console.log(scriptSource);
+     * // Output: "return { KEYS[1], ARGV[1] }"
+     * // The source for the script
      * ```
      */
     async scriptShow(sha1, options) {
@@ -2880,7 +3108,8 @@ class BaseClient {
      * // {
      * //     "0-1": [["field1", "value1"]],
      * //     "0-2": [["field2", "value2"], ["field2", "value3"]],
-     * // } // Indicates the stream entry IDs and their associated field-value pairs for all stream entries in "mystream".
+     * // }
+     * // Indicates the stream entry IDs and their associated field-value pairs for all stream entries in `mystream`.
      * ```
      */
     async xrange(key, start, end, options) {
@@ -2916,7 +3145,8 @@ class BaseClient {
      * // {
      * //     "0-2": [["field2", "value2"], ["field2", "value3"]],
      * //     "0-1": [["field1", "value1"]],
-     * // } // Indicates the stream entry IDs and their associated field-value pairs for all stream entries in "mystream".
+     * // }
+     * // Indicates the stream entry IDs and their associated field-value pairs for all stream entries in `mystream`.
      * ```
      */
     async xrevrange(key, end, start, options) {
@@ -2939,7 +3169,9 @@ class BaseClient {
      * // Example usage of the zadd method to add elements to a sorted set
      * const data = [{ element: "member1", score: 10.5 }, { element: "member2", score: 8.2 }]
      * const result = await client.zadd("my_sorted_set", data);
-     * console.log(result); // Output: 2 - Indicates that two elements have been added to the sorted set "my_sorted_set."
+     * console.log(result);
+     * // Output: 2
+     * // Indicates that two elements have been added to the sorted set `my_sorted_set`.
      * ```
      *
      * @example
@@ -2947,7 +3179,9 @@ class BaseClient {
      * // Example usage of the zadd method to update scores in an existing sorted set
      * const options = { conditionalChange: ConditionalChange.ONLY_IF_EXISTS, changed: true };
      * const result = await client.zadd("existing_sorted_set", { "member1": 10.5, "member2": 8.2 }, options);
-     * console.log(result); // Output: 2 - Updates the scores of two existing members in the sorted set "existing_sorted_set."
+     * console.log(result);
+     * // Output: 2
+     * // Updates the scores of two existing members in the sorted set `existing_sorted_set`.
      * ```
      */
     async zadd(key, membersAndScores, options) {
@@ -2971,14 +3205,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the zaddIncr method to add a member with a score to a sorted set
      * const result = await client.zaddIncr("my_sorted_set", member, 5.0);
-     * console.log(result); // Output: 5.0
+     * console.log(result);
+     * // Output: 5.0
+     * // Score of the member after being updated.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the zaddIncr method to add or update a member with a score in an existing sorted set
      * const result = await client.zaddIncr("existing_sorted_set", member, "3.0", { updateOptions: UpdateByScore.LESS_THAN });
-     * console.log(result); // Output: null - Indicates that the member in the sorted set haven't been updated.
+     * console.log(result);
+     * // Output: null
+     * // Indicates that the member in the sorted set haven't been updated.
      * ```
      */
     async zaddIncr(key, member, increment, options) {
@@ -2999,14 +3237,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the zrem function to remove members from a sorted set
      * const result = await client.zrem("my_sorted_set", ["member1", "member2"]);
-     * console.log(result); // Output: 2 - Indicates that two members have been removed from the sorted set "my_sorted_set."
+     * console.log(result);
+     * // Output: 2
+     * // Indicates that two members have been removed from the sorted set `my_sorted_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the zrem function when the sorted set does not exist
      * const result = await client.zrem("non_existing_sorted_set", ["member1", "member2"]);
-     * console.log(result); // Output: 0 - Indicates that no members were removed as the sorted set "non_existing_sorted_set" does not exist.
+     * console.log(result);
+     * // Output: 0
+     * // Indicates that no members were removed as the sorted set `non_existing_sorted_set` does not exist.
      * ```
      */
     async zrem(key, members) {
@@ -3025,14 +3267,17 @@ class BaseClient {
      * ```typescript
      * // Example usage of the zcard method to get the cardinality of a sorted set
      * const result = await client.zcard("my_sorted_set");
-     * console.log(result); // Output: 3 - Indicates that there are 3 elements in the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: 3
+     * // Indicates that there are 3 elements in the sorted set `my_sorted_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the zcard method with a non-existing key
      * const result = await client.zcard("non_existing_key");
-     * console.log(result); // Output: 0
+     * console.log(result);
+     * // Output: 0
      * ```
      */
     async zcard(key) {
@@ -3053,7 +3298,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const cardinality = await client.zintercard(["key1", "key2"], { limit: 10 });
-     * console.log(cardinality); // Output: 3 - The intersection of the sorted sets at "key1" and "key2" has a cardinality of 3.
+     * console.log(cardinality);
+     * // Output: 3
+     * // The intersection of the sorted sets at `key1` and `key2` has a cardinality of 3.
      * ```
      */
     async zintercard(keys, options) {
@@ -3078,7 +3325,9 @@ class BaseClient {
      * await client.zadd("zset2", {"member2": 2.0});
      * await client.zadd("zset3", {"member3": 3.0});
      * const result = await client.zdiff(["zset1", "zset2", "zset3"]);
-     * console.log(result); // Output: ["member1"] - "member1" is in "zset1" but not "zset2" or "zset3".
+     * console.log(result);
+     * // Output: ["member1"]
+     * // `member1` is in `zset1` but not `zset2` or `zset3`.
      * ```
      */
     async zdiff(keys, options) {
@@ -3103,8 +3352,9 @@ class BaseClient {
      * await client.zadd("zset2", {"member2": 2.0});
      * await client.zadd("zset3", {"member3": 3.0});
      * const result = await client.zdiffWithScores(["zset1", "zset2", "zset3"]);
-     * console.log(result); // Output: "member1" is in "zset1" but not "zset2" or "zset3"
-     * // [{ element: "member1", score: 1.0 }]
+     * console.log(result);
+     * // Output: [{ element: "member1", score: 1.0 }]
+     * // `member1` is in `zset1` but not `zset2` or `zset3`
      * ```
      */
     async zdiffWithScores(keys, options) {
@@ -3128,10 +3378,14 @@ class BaseClient {
      * await client.zadd("zset1", {"member1": 1.0, "member2": 2.0});
      * await client.zadd("zset2", {"member1": 1.0});
      * const result1 = await client.zdiffstore("zset3", ["zset1", "zset2"]);
-     * console.log(result1); // Output: 1 - One member exists in "key1" but not "key2", and this member was stored in "zset3".
+     * console.log(result1);
+     * // Output: 1
+     * // One member exists in `key1` but not `key2`, and this member was stored in `zset3`.
      *
      * const result2 = await client.zrange("zset3", {start: 0, end: -1});
-     * console.log(result2); // Output: ["member2"] - "member2" is now stored in "my_sorted_set".
+     * console.log(result2);
+     * // Output: ["member2"]
+     * // `member2` is now stored in `my_sorted_set`.
      * ```
      */
     async zdiffstore(destination, keys) {
@@ -3152,21 +3406,25 @@ class BaseClient {
      * ```typescript
      * // Example usage of the zscore method∂∂ to get the score of a member in a sorted set
      * const result = await client.zscore("my_sorted_set", "member");
-     * console.log(result); // Output: 10.5 - Indicates that the score of "member" in the sorted set "my_sorted_set" is 10.5.
+     * console.log(result);
+     * // Output: 10.5
+     * // Indicates that the score of `member` in the sorted set `my_sorted_set` is 10.5.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the zscore method when the member does not exist in the sorted set
      * const result = await client.zscore("my_sorted_set", "non_existing_member");
-     * console.log(result); // Output: null
+     * console.log(result);
+     * // Output: null
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the zscore method with non existimng key
      * const result = await client.zscore("non_existing_set", "member");
-     * console.log(result); // Output: null
+     * console.log(result);
+     * // Output: null
      * ```
      */
     async zscore(key, member) {
@@ -3196,25 +3454,35 @@ class BaseClient {
      *
      * // use `zunionstore` with default aggregation and weights
      * console.log(await client.zunionstore("my_sorted_set", ["key1", "key2"]))
-     * // Output: 2 - Indicates that the sorted set "my_sorted_set" contains two elements.
+     * // Output: 2
+     * // Indicates that the sorted set `my_sorted_set` contains two elements.
+     *
      * console.log(await client.zrangeWithScores("my_sorted_set", {start: 0, stop: -1}))
-     * // Output: {'member1': 20, 'member2': 8.2} - "member1" is now stored in "my_sorted_set" with score of 20 and "member2" with score of 8.2.
+     * // Output: {'member1': 20, 'member2': 8.2}
+     * // `member1` is now stored in `my_sorted_set` with score of 20 and `member2` with score of 8.2.
      * ```
      *
      * @example
      * ```typescript
      * // use `zunionstore` with default weights
      * console.log(await client.zunionstore("my_sorted_set", ["key1", "key2"], { aggregationType: AggregationType.MAX }))
-     * // Output: 2 - Indicates that the sorted set "my_sorted_set" contains two elements, and each score is the maximum score between the sets.
+     * // Output: 2
+     * // Indicates that the sorted set `my_sorted_set` contains two elements, and each score is the maximum score between the sets.
+     *
      * console.log(await client.zrangeWithScores("my_sorted_set", {start: 0, stop: -1}))
-     * // Output: {'member1': 10.5, 'member2': 8.2} - "member1" is now stored in "my_sorted_set" with score of 10.5 and "member2" with score of 8.2.
+     * // Output: {'member1': 10.5, 'member2': 8.2}
+     * // `member1` is now stored in `my_sorted_set` with score of 10.5 and `member2` with score of 8.2.
      * ```
      *
      * @example
      * ```typescript
      * // use `zunionstore` with default aggregation
-     * console.log(await client.zunionstore("my_sorted_set", [["key1", 2], ["key2", 1]])) // Output: 2
-     * console.log(await client.zrangeWithScores("my_sorted_set", {start: 0, stop: -1})) // Output: { member2: 16.4, member1: 30.5 }
+     * console.log(await client.zunionstore("my_sorted_set", [["key1", 2], ["key2", 1]]))
+     * // Output: 2
+     * // Indicates that the sorted set `my_sorted_set` contains two elements
+     *
+     * console.log(await client.zrangeWithScores("my_sorted_set", {start: 0, stop: -1}))
+     * // Output: { member2: 16.4, member1: 30.5 }
      * ```
      */
     async zunionstore(destination, keys, options) {
@@ -3234,7 +3502,8 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.zmscore("zset1", ["member1", "non_existent_member", "member2"]);
-     * console.log(result); // Output: [1.0, null, 2.0] - "member1" has a score of 1.0, "non_existent_member" does not exist in the sorted set, and "member2" has a score of 2.0.
+     * console.log(result); // Output: [1.0, null, 2.0]
+     * // `member1` has a score of 1.0, `non_existent_member` does not exist in the sorted set, and `member2` has a score of 2.0.
      * ```
      */
     async zmscore(key, members) {
@@ -3256,14 +3525,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of the zcount method to count members in a sorted set within a score range
      * const result = await client.zcount("my_sorted_set", { value: 5.0, isInclusive: true }, InfBoundary.PositiveInfinity);
-     * console.log(result); // Output: 2 - Indicates that there are 2 members with scores between 5.0 (inclusive) and +inf in the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: 2
+     * // Indicates that there are 2 members with scores between 5.0 (inclusive) and +inf in the sorted set `my_sorted_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of the zcount method to count members in a sorted set within a score range
      * const result = await client.zcount("my_sorted_set", { value: 5.0, isInclusive: true }, { value: 10.0, isInclusive: false });
-     * console.log(result); // Output: 1 - Indicates that there is one member with score between 5.0 (inclusive) and 10.0 (exclusive) in the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: 1
+     * // Indicates that there is one member with score between 5.0 (inclusive) and 10.0 (exclusive) in the sorted set `my_sorted_set`.
      * ```
      */
     async zcount(key, minScore, maxScore) {
@@ -3292,8 +3565,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of zrange method to retrieve all members of a sorted set in ascending order
      * const result = await client.zrange("my_sorted_set", { start: 0, end: -1 });
-     * console.log(result1); // Output: all members in ascending order
-     * // ['member1', 'member2', 'member3']
+     * console.log(result1);
+     * // Output: ['member1', 'member2', 'member3']
+     * // All members in ascending order
      * ```
      * @example
      * ```typescript
@@ -3303,8 +3577,9 @@ class BaseClient {
      *              end: InfBoundary.NegativeInfinity,
      *              type: "byScore",
      *           }, { reverse: true });
-     * console.log(result); // Output: members with scores within the range of negative infinity to 3, in descending order
-     * // ['member2', 'member1']
+     * console.log(result);
+     * // Output: ['member2', 'member1']
+     * // Members with scores within the range of negative infinity to 3, in descending order
      * ```
      */
     async zrange(key, rangeQuery, options) {
@@ -3334,8 +3609,9 @@ class BaseClient {
      *              end: { value: 20, isInclusive: false },
      *              type: "byScore",
      *           });
-     * console.log(result); // Output: members with scores between 10 and 20 with their scores
-     * // [{ element: 'member1', score: 10.5 }, { element: 'member2', score: 15.2 }]
+     * console.log(result);
+     * // Output: [{ element: 'member1', score: 10.5 }, { element: 'member2', score: 15.2 }]
+     * // Members with scores between 10 and 20 with their scores
      * ```
      * @example
      * ```typescript
@@ -3345,8 +3621,9 @@ class BaseClient {
      *              end: InfBoundary.NegativeInfinity,
      *              type: "byScore",
      *           }, { reverse: true });
-     * console.log(result); // Output: members with scores within the range of negative infinity to 3, with their scores
-     * // [{ element: 'member7', score: 1.5 }, { element: 'member4', score: -2.0 }]
+     * console.log(result);
+     * // Output: [{ element: 'member7', score: 1.5 }, { element: 'member4', score: -2.0 }]
+     * // Members with scores within the range of negative infinity to 3, with their scores
      * ```
      */
     async zrangeWithScores(key, rangeQuery, options) {
@@ -3374,17 +3651,21 @@ class BaseClient {
      * ```typescript
      * // Example usage of zrangeStore to retrieve and store all members of a sorted set in ascending order.
      * const result = await client.zrangeStore("destination_key", "my_sorted_set", { start: 0, end: -1 });
-     * console.log(result); // Output: 7 - "destination_key" contains a sorted set with the 7 members from "my_sorted_set".
+     * console.log(result);
+     * // Output: 7
+     * // `destination_key` contains a sorted set with the 7 members from `my_sorted_set`.
      * ```
      * @example
      * ```typescript
-     * // Example usage of zrangeStore method to retrieve members within a score range in ascending order and store in "destination_key"
+     * // Example usage of zrangeStore method to retrieve members within a score range in ascending order and store in `destination_key`
      * const result = await client.zrangeStore("destination_key", "my_sorted_set", {
      *              start: InfBoundary.NegativeInfinity,
      *              end: { value: 3, isInclusive: false },
      *              type: "byScore",
      *           });
-     * console.log(result); // Output: 5 - Stores 5 members with scores within the range of negative infinity to 3, in ascending order, in "destination_key".
+     * console.log(result);
+     * // Output: 5
+     * // Stores 5 members with scores within the range of negative infinity to 3, in ascending order, in `destination_key`.
      * ```
      */
     async zrangeStore(destination, source, rangeQuery, reverse = false) {
@@ -3414,15 +3695,21 @@ class BaseClient {
      *
      * // use `zinterstore` with default aggregation and weights
      * console.log(await client.zinterstore("my_sorted_set", ["key1", "key2"]))
-     * // Output: 1 - Indicates that the sorted set "my_sorted_set" contains one element.
+     * // Output: 1
+     * // Indicates that the sorted set `my_sorted_set` contains one element.
+     *
      * console.log(await client.zrangeWithScores("my_sorted_set", {start: 0, end: -1}))
-     * // Output: {'member1': 20} - "member1" is now stored in "my_sorted_set" with score of 20.
+     * // Output: {'member1': 20}
+     * // `member1` is now stored in `my_sorted_set` with score of 20.
      *
      * // use `zinterstore` with default weights
      * console.log(await client.zinterstore("my_sorted_set", ["key1", "key2"] , { aggregationType: AggregationType.MAX }))
-     * // Output: 1 - Indicates that the sorted set "my_sorted_set" contains one element, and it's score is the maximum score between the sets.
+     * // Output: 1
+     * // Indicates that the sorted set `my_sorted_set` contains one element, and it's score is the maximum score between the sets.
+     *
      * console.log(await client.zrangeWithScores("my_sorted_set", {start: 0, end: -1}))
-     * // Output: {'member1': 10.5} - "member1" is now stored in "my_sorted_set" with score of 10.5.
+     * // Output: {'member1': 10.5}
+     * // `member1` is now stored in `my_sorted_set` with score of 10.5.
      * ```
      */
     async zinterstore(destination, keys, options) {
@@ -3448,7 +3735,9 @@ class BaseClient {
      * await client.zadd("key1", {"member1": 10.5, "member2": 8.2});
      * await client.zadd("key2", {"member1": 9.5});
      * const result = await client.zinter(["key1", "key2"]);
-     * console.log(result); // Output: ['member1']
+     * console.log(result);
+     * // Output: ['member1']
+     * // The intersecting element for the sorted sets at `key1` and `key2`.
      * ```
      */
     async zinter(keys, options) {
@@ -3480,11 +3769,14 @@ class BaseClient {
      * await client.zadd("key1", {"member1": 10.5, "member2": 8.2});
      * await client.zadd("key2", {"member1": 9.5});
      * const result1 = await client.zinterWithScores(["key1", "key2"]);
-     * console.log(result1); // Output: "member1" with score of 20 is the result
-     * // [{ element: 'member1', score: 20 }]
+     * console.log(result1);
+     * // Output: [{ element: 'member1', score: 20 }]
+     * // `member1` with score of 20 is the result
+     *
      * const result2 = await client.zinterWithScores(["key1", "key2"], AggregationType.MAX)
-     * console.log(result2); // Output: "member1" with score of 10.5 is the result
-     * // [{ element: 'member1', score: 10.5 }]
+     * console.log(result2);
+     * // Output: [{ element: 'member1', score: 10.5 }]
+     * // `member1` with score of 10.5 is the result
      * ```
      */
     async zinterWithScores(keys, options) {
@@ -3509,7 +3801,9 @@ class BaseClient {
      * await client.zadd("key1", {"member1": 10.5, "member2": 8.2});
      * await client.zadd("key2", {"member1": 9.5});
      * const result = await client.zunion(["key1", "key2"]);
-     * console.log(result); // Output: ['member1', 'member2']
+     * console.log(result);
+     * // Output: ['member1', 'member2']
+     * // Union elements from sets stored at keys `key1` and `key2`.
      * ```
      */
     async zunion(keys, options) {
@@ -3539,11 +3833,14 @@ class BaseClient {
      * await client.zadd("key1", {"member1": 10.5, "member2": 8.2});
      * await client.zadd("key2", {"member1": 9.5});
      * const result1 = await client.zunionWithScores(["key1", "key2"]);
-     * console.log(result1); // Output:
-     * // [{ element: 'member1', score: 20 }, { element: 'member2', score: 8.2 }]
+     * console.log(result1);
+     * // Output: [{ element: 'member1', score: 20 }, { element: 'member2', score: 8.2 }]
+     * // A list of union elements with scores.
+     *
      * const result2 = await client.zunionWithScores(["key1", "key2"], "MAX");
-     * console.log(result2); // Output:
-     * // [{ element: 'member1', score: 10.5}, { element: 'member2', score: 8.2 }]
+     * console.log(result2);
+     * // Output: [{ element: 'member1', score: 10.5}, { element: 'member2', score: 8.2 }]
+     * // A list of union elements with score. The score of the common element in both sets (`member1`), is the maximum of scores(10.5) for that member from both sets.
      * ```
      */
     async zunionWithScores(keys, options) {
@@ -3562,13 +3859,17 @@ class BaseClient {
      * @example
      * ```typescript
      * const payload1 = await client.zrandmember("mySortedSet");
-     * console.log(payload1); // Output: "Glide" (a random member from the set)
+     * console.log(payload1);
+     * // Output: "Glide"
+     * // A random member from the set
      * ```
      *
      * @example
      * ```typescript
      * const payload2 = await client.zrandmember("nonExistingSortedSet");
-     * console.log(payload2); // Output: null since the sorted set does not exist.
+     * console.log(payload2);
+     * // Output: null
+     * // Since the sorted set does not exist.
      * ```
      */
     async zrandmember(key, options) {
@@ -3590,13 +3891,17 @@ class BaseClient {
      * @example
      * ```typescript
      * const payload1 = await client.zrandmemberWithCount("mySortedSet", -3);
-     * console.log(payload1); // Output: ["Glide", "GLIDE", "node"]
+     * console.log(payload1);
+     * // Output: ["Glide", "GLIDE", "node"]
+     * // Returns 3 random members from the sorted set, with duplicates allowed.
      * ```
      *
      * @example
      * ```typescript
      * const payload2 = await client.zrandmemberWithCount("nonExistingKey", 3);
-     * console.log(payload1); // Output: [] since the sorted set does not exist.
+     * console.log(payload1);
+     * // Output: []
+     * // Since the sorted set does not exist.
      * ```
      */
     async zrandmemberWithCount(key, count, options) {
@@ -3618,13 +3923,17 @@ class BaseClient {
      * @example
      * ```typescript
      * const payload1 = await client.zrandmemberWithCountWithScore("mySortedSet", -3);
-     * console.log(payload1); // Output: [["Glide", 1.0], ["GLIDE", 1.0], ["node", 2.0]]
+     * console.log(payload1);
+     * // Output: [["Glide", 1.0], ["GLIDE", 1.0], ["node", 2.0]]
+     * // Returns 3 random members with scores, with duplicates allowed.
      * ```
      *
      * @example
      * ```typescript
      * const payload2 = await client.zrandmemberWithCountWithScore("nonExistingKey", 3);
-     * console.log(payload1); // Output: [] since the sorted set does not exist.
+     * console.log(payload1);
+     * // Output: []
+     * // Since the sorted set does not exist.
      * ```
      */
     async zrandmemberWithCountWithScores(key, count, options) {
@@ -3643,15 +3952,17 @@ class BaseClient {
      * ```typescript
      * // Example usage of strlen method with an existing key
      * await client.set("key", "GLIDE");
-     * const len1 = await client.strlen("key");
-     * console.log(len1); // Output: 5
+     * const length1 = await client.strlen("key");
+     * console.log(length1);
+     * // Output: 5
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of strlen method with a non-existing key
-     * const len2 = await client.strlen("non_existing_key");
-     * console.log(len2); // Output: 0
+     * const length2 = await client.strlen("non_existing_key");
+     * console.log(length2);
+     * // Output: 0
      * ```
      */
     async strlen(key) {
@@ -3670,7 +3981,8 @@ class BaseClient {
      * // Example usage of type method with a string value
      * await client.set("key", "value");
      * const type = await client.type("key");
-     * console.log(type); // Output: 'string'
+     * console.log(type);
+     * // Output: 'string'
      * ```
      *
      * @example
@@ -3678,7 +3990,8 @@ class BaseClient {
      * // Example usage of type method with a list
      * await client.lpush("key", ["value"]);
      * const type = await client.type("key");
-     * console.log(type); // Output: 'list'
+     * console.log(type);
+     * // Output: 'list'
      * ```
      */
     async type(key) {
@@ -3705,21 +4018,22 @@ class BaseClient {
      * ```typescript
      * // Example usage of zpopmin method to remove and return the member with the lowest score from a sorted set
      * const result = await client.zpopmin("my_sorted_set");
-     * console.log(result); // Output:
-     * // 'member1' with a score of 5.0 has been removed from the sorted set
-     * // [{ element: 'member1', score: 5.0 }]
+     * console.log(result);
+     * // Output: [{ element: 'member1', score: 5.0 }]
+     * // `member1` with a score of 5.0 has been removed from the sorted set
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of zpopmin method to remove and return multiple members with the lowest scores from a sorted set
      * const result = await client.zpopmin("my_sorted_set", 2);
-     * console.log(result); // Output:
-     * // 'member3' with a score of 7.5 and 'member2' with a score of 8.0 have been removed from the sorted set
+     * console.log(result);
+     * // Output:
      * // [
      * //     { element: 'member3', score: 7.5 },
      * //     { element: 'member2', score: 8.0 }
      * // ]
+     * // `member3` with a score of 7.5 and `member2` with a score of 8.0 have been removed from the sorted set
      * ```
      */
     async zpopmin(key, options) {
@@ -3744,7 +4058,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const data = await client.bzpopmin(["zset1", "zset2"], 0.5);
-     * console.log(data); // Output: ["zset1", "a", 2];
+     * console.log(data);
+     * // Output: ["zset1", "a", 2];
+     * // Pops the member `a` with score 2 stored at key `zset1`.
      * ```
      */
     async bzpopmin(keys, timeout, options) {
@@ -3769,21 +4085,22 @@ class BaseClient {
      * ```typescript
      * // Example usage of zpopmax method to remove and return the member with the highest score from a sorted set
      * const result = await client.zpopmax("my_sorted_set");
-     * console.log(result); // Output:
-     * // 'member1' with a score of 10.0 has been removed from the sorted set
-     * // [{ element: 'member1', score: 10.0 }]
+     * console.log(result);
+     * // Output: [{ element: 'member1', score: 10.0 }]
+     * // `member1` with a score of 10.0 has been removed from the sorted set
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of zpopmax method to remove and return multiple members with the highest scores from a sorted set
      * const result = await client.zpopmax("my_sorted_set", 2);
-     * console.log(result); // Output:
-     * // 'member3' with a score of 7.5 and 'member2' with a score of 8.0 have been removed from the sorted set
+     * console.log(result);
+     * // Output:
      * // [
      * //     { element: 'member3', score: 7.5 },
      * //     { element: 'member2', score: 8.0 }
      * // ]
+     * // `member3` with a score of 7.5 and `member2` with a score of 8.0 have been removed from the sorted set
      * ```
      */
     async zpopmax(key, options) {
@@ -3808,7 +4125,8 @@ class BaseClient {
      * @example
      * ```typescript
      * const data = await client.bzpopmax(["zset1", "zset2"], 0.5);
-     * console.log(data); // Output: ["zset1", "c", 2];
+     * console.log(data);
+     * // Output: ["zset1", "c", 2];
      * ```
      */
     async bzpopmax(keys, timeout, options) {
@@ -3826,21 +4144,27 @@ class BaseClient {
      * ```typescript
      * // Example usage of pttl method with an existing key
      * const result = await client.pttl("my_key");
-     * console.log(result); // Output: 5000 - Indicates that the key "my_key" has a remaining time to live of 5000 milliseconds.
+     * console.log(result);
+     * // Output: 5000
+     * // Indicates that the key `my_key` has a remaining time to live of 5000 milliseconds.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of pttl method with a non-existing key
      * const result = await client.pttl("non_existing_key");
-     * console.log(result); // Output: -2 - Indicates that the key "non_existing_key" does not exist.
+     * console.log(result);
+     * // Output: -2
+     * // Indicates that the key `non_existing_key` does not exist.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of pttl method with an exisiting key that has no associated expire.
      * const result = await client.pttl("key");
-     * console.log(result); // Output: -1 - Indicates that the key "key" has no associated expire.
+     * console.log(result);
+     * // Output: -1
+     * // Indicates that the key `key` has no associated expire.
      * ```
      */
     async pttl(key) {
@@ -3865,7 +4189,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of zremRangeByRank method
      * const result = await client.zremRangeByRank("my_sorted_set", 0, 2);
-     * console.log(result); // Output: 3 - Indicates that three elements have been removed from the sorted set "my_sorted_set" between ranks 0 and 2.
+     * console.log(result);
+     * // Output: 3
+     * // Indicates that three elements have been removed from the sorted set `my_sorted_set` between ranks 0 and 2.
      * ```
      */
     async zremRangeByRank(key, start, end) {
@@ -3887,14 +4213,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of zremRangeByLex method to remove members from a sorted set based on lexicographical order range
      * const result = await client.zremRangeByLex("my_sorted_set", { value: "a", isInclusive: false }, { value: "e" });
-     * console.log(result); // Output: 4 - Indicates that 4 members, with lexicographical values ranging from "a" (exclusive) to "e" (inclusive), have been removed from "my_sorted_set".
+     * console.log(result);
+     * // Output: 4
+     * // Indicates that 4 members, with lexicographical values ranging from `a` (exclusive) to `e` (inclusive), have been removed from `my_sorted_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of zremRangeByLex method when the sorted set does not exist
      * const result = await client.zremRangeByLex("non_existing_sorted_set", InfBoundary.NegativeInfinity, { value: "e" });
-     * console.log(result); // Output: 0 - Indicates that no elements were removed.
+     * console.log(result);
+     * // Output: 0
+     * // Indicates that no elements were removed.
      * ```
      */
     async zremRangeByLex(key, minLex, maxLex) {
@@ -3916,14 +4246,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of zremRangeByScore method to remove members from a sorted set based on score range
      * const result = await client.zremRangeByScore("my_sorted_set", { value: 5.0, isInclusive: true }, InfBoundary.PositiveInfinity);
-     * console.log(result); // Output: 2 - Indicates that 2 members with scores between 5.0 (inclusive) and +inf have been removed from the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: 2
+     * // Indicates that 2 members with scores between 5.0 (inclusive) and +inf have been removed from the sorted set `my_sorted_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of zremRangeByScore method when the sorted set does not exist
      * const result = await client.zremRangeByScore("non_existing_sorted_set", { value: 5.0, isInclusive: true }, { value: 10.0, isInclusive: false });
-     * console.log(result); // Output: 0 - Indicates that no members were removed as the sorted set "non_existing_sorted_set" does not exist.
+     * console.log(result);
+     * // Output: 0
+     * // Indicates that no members were removed as the sorted set `non_existing_sorted_set` does not exist.
      * ```
      */
     async zremRangeByScore(key, minScore, maxScore) {
@@ -3944,13 +4278,17 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.zlexcount("my_sorted_set", {value: "c"}, InfBoundary.PositiveInfinity);
-     * console.log(result); // Output: 2 - Indicates that there are 2 members with lex scores between "c" (inclusive) and positive infinity in the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: 2
+     * // Indicates that there are 2 members with lex scores between `c` (inclusive) and positive infinity in the sorted set `my_sorted_set`.
      * ```
      *
      * @example
      * ```typescript
      * const result = await client.zlexcount("my_sorted_set", {value: "c"}, {value: "k", isInclusive: false});
-     * console.log(result); // Output: 1 - Indicates that there is one member with a lex score between "c" (inclusive) and "k" (exclusive) in the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: 1
+     * // Indicates that there is one member with a lex score between `c` (inclusive) and `k` (exclusive) in the sorted set `my_sorted_set`.
      * ```
      */
     async zlexcount(key, minLex, maxLex) {
@@ -3971,14 +4309,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of zrank method to retrieve the rank of a member in a sorted set
      * const result = await client.zrank("my_sorted_set", "member2");
-     * console.log(result); // Output: 1 - Indicates that "member2" has the second-lowest score in the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: 1
+     * // Indicates that `member2` has the second-lowest score in the sorted set `my_sorted_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of zrank method with a non-existing member
      * const result = await client.zrank("my_sorted_set", "non_existing_member");
-     * console.log(result); // Output: null - Indicates that "non_existing_member" is not present in the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: null
+     * // Indicates that `non_existing_member` is not present in the sorted set `my_sorted_set`.
      * ```
      */
     async zrank(key, member) {
@@ -3999,14 +4341,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of zrank_withscore method to retrieve the rank and score of a member in a sorted set
      * const result = await client.zrank_withscore("my_sorted_set", "member2");
-     * console.log(result); // Output: [1, 6.0] - Indicates that "member2" with score 6.0 has the second-lowest score in the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: [1, 6.0]
+     * // Indicates that `member2` with score 6.0 has the second-lowest score in the sorted set `my_sorted_set`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of zrank_withscore method with a non-existing member
      * const result = await client.zrank_withscore("my_sorted_set", "non_existing_member");
-     * console.log(result); // Output: null - Indicates that "non_existing_member" is not present in the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: null
+     * // Indicates that `non_existing_member` is not present in the sorted set `my_sorted_set`.
      * ```
      */
     async zrankWithScore(key, member) {
@@ -4027,7 +4373,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.zrevrank("my_sorted_set", "member2");
-     * console.log(result); // Output: 1 - Indicates that "member2" has the second-highest score in the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: 1
+     * // Indicates that `member2` has the second-highest score in the sorted set `my_sorted_set`.
      * ```
      */
     async zrevrank(key, member) {
@@ -4049,7 +4397,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.zrevankWithScore("my_sorted_set", "member2");
-     * console.log(result); // Output: [1, 6.0] - Indicates that "member2" with score 6.0 has the second-highest score in the sorted set "my_sorted_set".
+     * console.log(result);
+     * // Output: [1, 6.0]
+     * // Indicates that `member2` with score 6.0 has the second-highest score in the sorted set `my_sorted_set`.
      * ```
      */
     async zrevrankWithScore(key, member) {
@@ -4082,7 +4432,8 @@ class BaseClient {
      * @example
      * ```typescript
      * console.log(await client.xdel("key", ["1538561698944-0", "1538561698944-1"]));
-     * // Output is 2 since the stream marked 2 entries as deleted.
+     * // Output: 2
+     * // the stream marked 2 entries as deleted.
      * ```
      */
     async xdel(key, ids) {
@@ -4112,12 +4463,13 @@ class BaseClient {
      * @example
      * ```typescript
      * const streamResults = await client.xread({"my_stream": "0-0", "writers": "0-0"});
-     * console.log(result); // Output:
+     * console.log(result);
+     * // Output:
      * // [
      * //     {
-     * //         key: "my_stream",
-     * //         value: {
-     * //             "1526984818136-0": [["duration", "1532"], ["event-id", "5"], ["user-id", "7782813"]],
+     * //         key: "my_stream",                                                                         // Stream key
+     * //         value: {                                                                                  // Stream Ids mapped to entries array.
+     * //             "1526984818136-0": [["duration", "1532"], ["event-id", "5"], ["user-id", "7782813"]], // Each entry is a key/value tuple.
      * //             "1526999352406-0": [["duration", "812"], ["event-id", "9"], ["user-id", "388234"]],
      * //         }
      * //     },
@@ -4155,7 +4507,8 @@ class BaseClient {
      * @example
      * ```typescript
      * const streamResults = await client.xreadgroup("my_group", "my_consumer", {"my_stream": "0-0", "writers_stream": "0-0", "readers_stream", ">"});
-     * console.log(result); // Output:
+     * console.log(result);
+     * // Output:
      * // [
      * //     {
      * //         key: "my_stream",
@@ -4197,7 +4550,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const numEntries = await client.xlen("my_stream");
-     * console.log(numEntries); // Output: 2 - "my_stream" contains 2 entries.
+     * console.log(numEntries);
+     * // Output: 2
+     * // `my_stream` contains 2 entries.
      * ```
      */
     async xlen(key) {
@@ -4213,7 +4568,8 @@ class BaseClient {
      * @returns An `array` that includes the summary of the pending messages. See example for more details.
      * @example
      * ```typescript
-     * console.log(await client.xpending("my_stream", "my_group")); // Output:
+     * console.log(await client.xpending("my_stream", "my_group"));
+     * // Output:
      * // [
      * //     42,                            // The total number of pending messages
      * //     "1722643465939-0",             // The smallest ID among the pending messages
@@ -4245,7 +4601,8 @@ class BaseClient {
      *     end: InfBoundary.PositiveInfinity,
      *     count: 2,
      *     consumer: "consumer1"
-     * }); // Output:
+     * });
+     * // Output:
      * // [
      * //     [
      * //         "1722643465939-0",  // The ID of the message
@@ -4280,13 +4637,14 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.xinfoConsumers("my_stream", "my_group");
-     * console.log(result); // Output:
+     * console.log(result);
+     * // Output:
      * // [
      * //     {
-     * //         "name": "Alice",
-     * //         "pending": 1,
-     * //         "idle": 9104628,
-     * //         "inactive": 18104698   // Added in 7.2.0
+     * //         "name": "Alice",      // The consumer name.
+     * //         "pending": 1,         // The number of entries in Pending entries list.
+     * //         "idle": 9104628,      // The time passed since last attempted interaction.
+     * //         "inactive": 18104698  // The time passed since last successful interaction. Added in Valkey 7.2.0.
      * //     },
      * //     ...
      * // ]
@@ -4307,23 +4665,24 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.xinfoGroups("my_stream");
-     * console.log(result); // Output:
+     * console.log(result);
+     * // Output:
      * // [
      * //     {
-     * //         "name": "mygroup",
-     * //         "consumers": 2,
-     * //         "pending": 2,
-     * //         "last-delivered-id": "1638126030001-0",
-     * //         "entries-read": 2,                       // Added in version 7.0.0
-     * //         "lag": 0                                 // Added in version 7.0.0
+     * //         "name": "mygroup",                      // The consumer group name.
+     * //         "consumers": 2,                         // Number of consumers in the group.
+     * //         "pending": 2,                           // The length of the group's pending entry list.
+     * //         "last-delivered-id": "1638126030001-0", // The id of the last delivered entry to the consumers.
+     * //         "entries-read": 2,                      // The read counter. Added in Valkey 7.0.0.
+     * //         "lag": 0                                // The number of entries that are still waiting to be delivered. Added in Valkey 7.0.0.
      * //     },
      * //     {
      * //         "name": "some-other-group",
      * //         "consumers": 1,
      * //         "pending": 0,
      * //         "last-delivered-id": "0-0",
-     * //         "entries-read": null,                    // Added in version 7.0.0
-     * //         "lag": 1                                 // Added in version 7.0.0
+     * //         "entries-read": null,                    // Added in Valkey 7.0.0.
+     * //         "lag": 1                                 // Added in Valkey 7.0.0.
      * //     }
      * // ]
      * ```
@@ -4348,9 +4707,14 @@ class BaseClient {
      * ```typescript
      * const result = await client.xclaim("myStream", "myGroup", "myConsumer", 42,
      *     ["1-0", "2-0", "3-0"], { idle: 500, retryCount: 3, isForce: true });
-     * console.log(result); // Output:
+     * console.log(result);
+     * // Output:
      * // {
-     * //     "2-0": [["duration", "1532"], ["event-id", "5"], ["user-id", "7782813"]]
+     * //     "2-0": [                    // Stream Entry id
+     * //         ["duration", "1532"],   // Entry data tuple containing the field and associated value.
+     * //         ["event-id", "5"],
+     * //         ["user-id", "7782813"]
+     * //     ]
      * // }
      * ```
      */
@@ -4384,7 +4748,8 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.xautoclaim("myStream", "myGroup", "myConsumer", 42, "0-0", { count: 25 });
-     * console.log(result); // Output:
+     * console.log(result);
+     * // Output:
      * // [
      * //     "1609338788321-0",                // value to be used as `start` argument
      * //                                       // for the next `xautoclaim` call
@@ -4432,7 +4797,8 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.xautoclaim("myStream", "myGroup", "myConsumer", 42, "0-0", { count: 25 });
-     * console.log(result); // Output:
+     * console.log(result);
+     * // Output:
      * // [
      * //     "1609338788321-0",                // value to be used as `start` argument
      * //                                       // for the next `xautoclaim` call
@@ -4468,7 +4834,9 @@ class BaseClient {
      * ```typescript
      * const result = await client.xclaimJustId("my_stream", "my_group", "my_consumer", 42,
      *     ["1-0", "2-0", "3-0"], { idle: 500, retryCount: 3, isForce: true });
-     * console.log(result); // Output: [ "2-0", "3-0" ]
+     * console.log(result);
+     * // Output: [ "2-0", "3-0" ]
+     * // A list of entry ids.
      * ```
      */
     async xclaimJustId(key, group, consumer, minIdleTime, ids, options) {
@@ -4488,7 +4856,8 @@ class BaseClient {
      * @example
      * ```typescript
      * // Create the consumer group "mygroup", using zero as the starting ID:
-     * console.log(await client.xgroupCreate("mystream", "mygroup", "0-0")); // Output is "OK"
+     * console.log(await client.xgroupCreate("mystream", "mygroup", "0-0"));
+     * // Output: "OK"
      * ```
      */
     async xgroupCreate(key, groupName, id, options) {
@@ -4506,7 +4875,8 @@ class BaseClient {
      * @example
      * ```typescript
      * // Destroys the consumer group "mygroup"
-     * console.log(await client.xgroupDestroy("mystream", "mygroup")); // Output is true
+     * console.log(await client.xgroupDestroy("mystream", "mygroup"));
+     * // Output: true
      * ```
      */
     async xgroupDestroy(key, groupName) {
@@ -4522,6 +4892,7 @@ class BaseClient {
      * - (Optional) `fullOptions`: If `true`, returns verbose information with a limit of the first 10 PEL entries.
      * If `number` is specified, returns verbose information limiting the returned PEL entries.
      * If `0` is specified, returns verbose information with no limit.
+     * @remark `fullOptions` - Available since Valkey version 6.0.0
      * - (Optional) `decoder`: see {@link DecoderOption}.
      * @returns A {@link ReturnTypeXinfoStream} of detailed stream information for the given `key`. See
      *     the example for a sample response.
@@ -4531,46 +4902,46 @@ class BaseClient {
      * const infoResult = await client.xinfoStream("my_stream");
      * console.log(infoResult);
      * // Output: {
-     * //   length: 2,
-     * //   "radix-tree-keys": 1,
-     * //   "radix-tree-nodes": 2,
-     * //   "last-generated-id": "1719877599564-1",
-     * //   "max-deleted-entry-id": "0-0",
-     * //   "entries-added": 2,
-     * //   "recorded-first-entry-id": "1719877599564-0",
-     * //   "first-entry": [ "1719877599564-0", ["some_field", "some_value", ...] ],
-     * //   "last-entry": [ "1719877599564-0", ["some_field", "some_value", ...] ],
-     * //   groups: 1,
+     * //   length: 2,                                                                // The number of entries in the stream.
+     * //   "radix-tree-keys": 1,                                                     // The number of keys in the underlying radix data structure.
+     * //   "radix-tree-nodes": 2,                                                    // The number of nodes in the underlying radix data structure.
+     * //   "last-generated-id": "1719877599564-1",                                   // The ID of the least-recently entry that was added to the stream.
+     * //   "max-deleted-entry-id": "0-0",                                            // The maximal entry ID that was deleted from the stream. Added in Valkey 7.0.0.
+     * //   "entries-added": 2,                                                       // The count of all entries added to the stream during its lifetime. Added in Valkey 7.0.0.
+     * //   "recorded-first-entry-id": "1719877599564-0",                             // Recorded first entry id. Added in Valkey 7.0.0.
+     * //   "first-entry": [ "1719877599564-0", ["some_field", "some_value", ...] ],  // The ID and field-value tuples of the first entry in the stream.
+     * //   "last-entry": [ "1719877599564-0", ["some_field", "some_value", ...] ],   // The ID and field-value tuples of the last entry in the stream.
+     * //   "groups": 1,                                                              // The number of consumer groups defined for the stream
      * // }
      * ```
      *
      * @example
      * ```typescript
      * const infoResult = await client.xinfoStream("my_stream", true); // default limit of 10 entries
-     * const infoResult = await client.xinfoStream("my_stream", 15); // limit of 15 entries
+     * const infoResult = await client.xinfoStream("my_stream", 15);   // limit of 15 entries
      * console.log(infoResult);
      * // Output: {
-     * //   "length": 2,
-     * //   "radix-tree-keys": 1,
-     * //   "radix-tree-nodes": 2,
-     * //   "last-generated-id": "1719877599564-1",
-     * //   "max-deleted-entry-id": "0-0",
-     * //   "entries-added": 2,
-     * //   "recorded-first-entry-id": "1719877599564-0",
-     * //   "entries": [ [ "1719877599564-0", ["some_field", "some_value", ...] ] ],
-     * //   "groups': [ {
-     * //     "name': "group",
-     * //     "last-delivered-id": "1719877599564-0",
-     * //     "entries-read": 1,
-     * //     "lag": 1,
-     * //     "pel-count": 1,
-     * //     "pending": [ [ "1719877599564-0", "consumer", 1722624726802, 1 ] ],
+     * //   "length": 2,                                                              // The number of entries in the stream.
+     * //   "radix-tree-keys": 1,                                                     // The number of keys in the underlying radix data structure.
+     * //   "radix-tree-nodes": 2,                                                    // The number of nodes in the underlying radix data structure.
+     * //   "last-generated-id": "1719877599564-1",                                   // The ID of the least-recently entry that was added to the stream.
+     * //   "max-deleted-entry-id": "0-0",                                            // The maximal entry ID that was deleted from the stream. Added in Valkey 7.0.0.
+     * //   "entries-added": 2,                                                       // The count of all entries added to the stream during its lifetime. Added in Valkey 7.0.0.
+     * //   "recorded-first-entry-id": "1719877599564-0",                             // Recorded first entry id. Added in Valkey 7.0.0.
+     * //   "entries": [ [ "1719877599564-0", ["some_field", "some_value", ...] ] ],  // Array of the stream entries (ID and field-value tuples) in ascending order.
+     * //   "groups': [ {                                                             // An array of groups containing information about each consumer group.
+     * //     "name': "group",                                                        // The consumer group's name.
+     * //     "last-delivered-id": "1719877599564-0",                                 // The ID of the last entry delivered to the group's consumers.
+     * //     "entries-read": 1,                                                      // The logical "read counter" of the last entry delivered to the group's consumers. Added in Valkey 7.0.0.
+     * //     "lag": 1,                                                               // The number of entries in the stream that are still waiting to be delivered. Added in Valkey 7.0.0.
+     * //     "pel-count": 1,                                                         // The length of the group's pending entries list (PEL).
+     * //     "pending": [ [ "1719877599564-0", "consumer", 1722624726802, 1 ] ],     // An array with pending entries.
      * //     "consumers": [ {
-     * //         "name": "consumer",
-     * //         "seen-time": 1722624726802,
-     * //         "active-time": 1722624726802,
-     * //         "pel-count": 1,
-     * //         "pending": [ [ "1719877599564-0", "consumer", 1722624726802, 1 ] ],
+     * //         "name": "consumer",                                                 // The consumer's name.
+     * //         "seen-time": 1722624726802,                                         // The UNIX timestamp of the last attempted interaction.
+     * //         "active-time": 1722624726802,                                       // The UNIX timestamp of the last successful interaction. Added in Valkey 7.2.0.
+     * //         "pel-count": 1,                                                     // The number of entries in the PEL.
+     * //         "pending": [ [ "1719877599564-0", "consumer", 1722624726802, 1 ] ], // An array with pending entries information.
      * //         }
      * //       ]
      * //     }
@@ -4594,7 +4965,8 @@ class BaseClient {
      * @example
      * ```typescript
      * // The consumer "myconsumer" was created in consumer group "mygroup" for the stream "mystream".
-     * console.log(await client.xgroupCreateConsumer("mystream", "mygroup", "myconsumer")); // Output is true
+     * console.log(await client.xgroupCreateConsumer("mystream", "mygroup", "myconsumer"));
+     * // Output: true
      * ```
      */
     async xgroupCreateConsumer(key, groupName, consumerName) {
@@ -4613,7 +4985,8 @@ class BaseClient {
      * * @example
      * ```typescript
      * // Consumer "myconsumer" was deleted, and had 5 pending messages unclaimed.
-     * console.log(await client.xgroupDelConsumer("mystream", "mygroup", "myconsumer")); // Output is 5
+     * console.log(await client.xgroupDelConsumer("mystream", "mygroup", "myconsumer"));
+     * // Output: 5
      * ```
      */
     async xgroupDelConsumer(key, groupName, consumerName) {
@@ -4642,7 +5015,8 @@ class BaseClient {
      * // read messages from streamId
      * const readResult = await client.xreadgroup(["myfield", "mydata"], "mygroup", "my0consumer");
      * // acknowledge messages on stream
-     * console.log(await client.xack("mystream", "mygroup", [entryId])); // Output: 1
+     * console.log(await client.xack("mystream", "mygroup", [entryId]));
+     * // Output: 1
      * ```
      */
     async xack(key, group, ids) {
@@ -4663,7 +5037,8 @@ class BaseClient {
      *
      * * @example
      * ```typescript
-     * console.log(await client.xgroupSetId("mystream", "mygroup", "0", { entriesRead: 1 })); // Output is "OK"
+     * console.log(await client.xgroupSetId("mystream", "mygroup", "0", { entriesRead: 1 }));
+     * // Output: "OK"
      * ```
      */
     async xgroupSetId(key, groupName, id, options) {
@@ -4686,14 +5061,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of lindex method to retrieve elements from a list by index
      * const result = await client.lindex("my_list", 0);
-     * console.log(result); // Output: 'value1' - Returns the first element in the list stored at 'my_list'.
+     * console.log(result);
+     * // Output: 'value1'
+     * // Returns the first element in the list stored at `my_list`.
      * ```
      *
      * @example
      * ```typescript
      * // Example usage of lindex method to retrieve elements from a list by negative index
      * const result = await client.lindex("my_list", -1);
-     * console.log(result); // Output: 'value3' - Returns the last element in the list stored at 'my_list'.
+     * console.log(result);
+     * // Output: 'value3'
+     * // Returns the last element in the list stored at `my_list`.
      * ```
      */
     async lindex(key, index, options) {
@@ -4716,7 +5095,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const length = await client.linsert("my_list", InsertPosition.Before, "World", "There");
-     * console.log(length); // Output: 2 - The list has a length of 2 after performing the insert.
+     * console.log(length);
+     * // Output: 2
+     * // The list has a length of 2 after performing the insert.
      * ```
      */
     async linsert(key, position, pivot, element) {
@@ -4735,7 +5116,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of persist method to remove the timeout associated with a key
      * const result = await client.persist("my_key");
-     * console.log(result); // Output: true - Indicates that the timeout associated with the key "my_key" was successfully removed.
+     * console.log(result);
+     * // Output: true
+     * // Indicates that the timeout associated with the key `my_key` was successfully removed.
      * ```
      */
     async persist(key) {
@@ -4757,7 +5140,9 @@ class BaseClient {
      * // Example usage of rename method to rename a key
      * await client.set("old_key", "value");
      * const result = await client.rename("old_key", "new_key");
-     * console.log(result); // Output: OK - Indicates successful renaming of the key "old_key" to "new_key".
+     * console.log(result);
+     * // Output: OK
+     * // Indicates successful renaming of the key `old_key` to `new_key`.
      * ```
      */
     async rename(key, newKey) {
@@ -4781,7 +5166,9 @@ class BaseClient {
      * // Example usage of renamenx method to rename a key
      * await client.set("old_key", "value");
      * const result = await client.renamenx("old_key", "new_key");
-     * console.log(result); // Output: true - Indicates successful renaming of the key "old_key" to "new_key".
+     * console.log(result);
+     * // Output: true
+     * // Indicates successful renaming of the key `old_key` to `new_key`.
      * ```
      */
     async renamenx(key, newKey) {
@@ -4806,7 +5193,9 @@ class BaseClient {
      * ```typescript
      * // Example usage of brpop method to block and wait for elements from multiple lists
      * const result = await client.brpop(["list1", "list2"], 5);
-     * console.log(result); // Output: ["list1", "element"] - Indicates an element "element" was popped from "list1".
+     * console.log(result);
+     * // Output: ["list1", "element"]
+     * // Indicates an element `element` was popped from `list1`.
      * ```
      */
     async brpop(keys, timeout, options) {
@@ -4830,7 +5219,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.blpop(["list1", "list2"], 5);
-     * console.log(result); // Output: ['list1', 'element']
+     * console.log(result);
+     * // Output: ['list1', 'element']
+     * // An element `element` popped from the list stored at key `list1`.
      * ```
      */
     async blpop(keys, timeout, options) {
@@ -4849,9 +5240,14 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.pfadd("hll_1", ["a", "b", "c"]);
-     * console.log(result); // Output: true - Indicates that a data structure was created or modified
+     * console.log(result);
+     * // Output: true
+     * // Indicates that a data structure was created or modified.
+     *
      * const result = await client.pfadd("hll_2", []);
-     * console.log(result); // Output: true - Indicates that a new empty data structure was created
+     * console.log(result);
+     * // Output: true
+     * // Indicates that a new empty data structure was created.
      * ```
      */
     async pfadd(key, elements) {
@@ -4869,7 +5265,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.pfcount(["hll_1", "hll_2"]);
-     * console.log(result); // Output: 4 - The approximated cardinality of the union of "hll_1" and "hll_2"
+     * console.log(result);
+     * // Output: 4
+     * // The approximate cardinality of the union of `hll_1` and `hll_2`
      * ```
      */
     async pfcount(keys) {
@@ -4891,9 +5289,14 @@ class BaseClient {
      * await client.pfadd("hll1", ["a", "b"]);
      * await client.pfadd("hll2", ["b", "c"]);
      * const result = await client.pfmerge("new_hll", ["hll1", "hll2"]);
-     * console.log(result); // Output: OK  - The value of "hll1" merged with "hll2" was stored in "new_hll".
+     * console.log(result);
+     * // Output: OK
+     * // The value of `hll1` merged with `hll2` was stored in `new_hll`.
+     *
      * const count = await client.pfcount(["new_hll"]);
-     * console.log(count); // Output: 3  - The approximated cardinality of "new_hll" is 3.
+     * console.log(count);
+     * // Output: 3
+     * // The approximate cardinality of `new_hll` is 3.
      * ```
      */
     async pfmerge(destination, sourceKeys) {
@@ -4913,7 +5316,8 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.objectEncoding("my_hash");
-     * console.log(result); // Output: "listpack"
+     * console.log(result);
+     * // Output: "listpack"
      * ```
      */
     async objectEncoding(key) {
@@ -4933,7 +5337,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.objectFreq("my_hash");
-     * console.log(result); // Output: 2 - The logarithmic access frequency counter of "my_hash".
+     * console.log(result);
+     * // Output: 2
+     * // The logarithmic access frequency counter of `my_hash`.
      * ```
      */
     async objectFreq(key) {
@@ -4950,7 +5356,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.objectIdletime("my_hash");
-     * console.log(result); // Output: 13 - "my_hash" was last accessed 13 seconds ago.
+     * console.log(result);
+     * // Output: 13
+     * // `my_hash` was last accessed 13 seconds ago.
      * ```
      */
     async objectIdletime(key) {
@@ -4968,7 +5376,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.objectRefcount("my_hash");
-     * console.log(result); // Output: 2 - "my_hash" has a reference count of 2.
+     * console.log(result);
+     * // Output: 2
+     * // `my_hash` has a reference count of 2.
      * ```
      */
     async objectRefcount(key) {
@@ -4991,7 +5401,7 @@ class BaseClient {
      * @example
      * ```typescript
      * const response = await client.fcall("Deep_Thought", [], []);
-     * console.log(response); // Output: Returns the function's return value.
+     * console.log(response); // Returns the function's return value.
      * ```
      */
     async fcall(func, keys, args, options) {
@@ -5015,7 +5425,9 @@ class BaseClient {
      * ```typescript
      * const response = await client.fcallReadOnly("Deep_Thought", ["key1"], ["Answer", "to", "the",
      *            "Ultimate", "Question", "of", "Life,", "the", "Universe,", "and", "Everything"]);
-     * console.log(response); // Output: 42 # The return value on the function that was executed.
+     * console.log(response);
+     * // Output: 42
+     * // The return value on the function that was executed.
      * ```
      */
     async fcallReadonly(func, keys, args, options) {
@@ -5038,8 +5450,13 @@ class BaseClient {
      * @example
      * ```typescript
      * await client.rpush("myList", ["a", "b", "c", "d", "e", "e"]);
-     * console.log(await client.lpos("myList", "e", { rank: 2 })); // Output: 5 - the second occurrence of "e" is at index 5.
-     * console.log(await client.lpos("myList", "e", { count: 3 })); // Output: [ 4, 5 ] - indices for the occurrences of "e" in list "myList".
+     * console.log(await client.lpos("myList", "e", { rank: 2 }));
+     * // Output: 5
+     * // The second occurrence of `e` is at index 5.
+     *
+     * console.log(await client.lpos("myList", "e", { count: 3 }));
+     * // Output: [ 4, 5 ]
+     * // indices for the occurrences of `e` in list `myList`.
      * ```
      */
     async lpos(key, element, options) {
@@ -5059,11 +5476,25 @@ class BaseClient {
      *
      * @example
      * ```typescript
-     * console.log(await client.bitcount("my_key1")); // Output: 2 - The string stored at "my_key1" contains 2 set bits.
-     * console.log(await client.bitcount("my_key2", { start: 1 })); // Output: 8 - From the second to to the last bytes of the string stored at "my_key2" are contain 8 set bits.
-     * console.log(await client.bitcount("my_key2", { start: 1, end: 3 })); // Output: 2 - The second to fourth bytes of the string stored at "my_key2" contain 2 set bits.
-     * console.log(await client.bitcount("my_key3", { start: 1, end: 1, indexType: BitmapIndexType.BIT })); // Output: 1 - Indicates that the second bit of the string stored at "my_key3" is set.
-     * console.log(await client.bitcount("my_key3", { start: -1, end: -1, indexType: BitmapIndexType.BIT })); // Output: 1 - Indicates that the last bit of the string stored at "my_key3" is set.
+     * console.log(await client.bitcount("my_key1"));
+     * // Output: 2
+     * // The string stored at `my_key1` contains 2 set bits.
+     *
+     * console.log(await client.bitcount("my_key2", { start: 1 }));
+     * // Output: 8
+     * // From the second to to the last bytes of the string stored at `my_key2` are contain 8 set bits.
+     *
+     * console.log(await client.bitcount("my_key2", { start: 1, end: 3 }));
+     * // Output: 2
+     * // The second to fourth bytes of the string stored at `my_key2` contain 2 set bits.
+     *
+     * console.log(await client.bitcount("my_key3", { start: 1, end: 1, indexType: BitmapIndexType.BIT }));
+     * // Output: 1
+     * // Indicates that the second bit of the string stored at `my_key3` is set.
+     *
+     * console.log(await client.bitcount("my_key3", { start: -1, end: -1, indexType: BitmapIndexType.BIT }));
+     * // Output: 1
+     * // Indicates that the last bit of the string stored at `my_key3` is set.
      * ```
      */
     async bitcount(key, options) {
@@ -5090,7 +5521,9 @@ class BaseClient {
      *      ["Palermo", { longitude: 13.361389, latitude: 38.115556 }],
      * ]);
      * const num = await client.geoadd("mySortedSet", membersToCoordinates, options);
-     * console.log(num); // Output: 1 - Indicates that the position of an existing member in the sorted set "mySortedSet" has been updated.
+     * console.log(num);
+     * // Output: 1
+     * // Indicates that the position of an existing member in the sorted set `mySortedSet` has been updated.
      * ```
      */
     async geoadd(key, membersToGeospatialData, options) {
@@ -5126,7 +5559,9 @@ class BaseClient {
      * await client.geoadd("mySortedSet", data);
      * // search for locations within 200 km circle around stored member named 'Palermo'
      * const result1 = await client.geosearch("mySortedSet", { member: "Palermo" }, { radius: 200, unit: GeoUnit.KILOMETERS });
-     * console.log(result1); // Output: ['Palermo', 'Catania']
+     * console.log(result1);
+     * // Output: ['Palermo', 'Catania']
+     * // Locations within the specified radius.
      *
      * // search for locations in 200x300 mi rectangle centered at coordinate (15, 37), requesting additional info,
      * // limiting results by 2 best matches, ordered by ascending distance from the search area center
@@ -5142,7 +5577,8 @@ class BaseClient {
      *         withHash: true,
      *     },
      * );
-     * console.log(result2); // Output:
+     * console.log(result2);
+     * // Output:
      * // [
      * //     [
      * //         'Catania',                                       // location name
@@ -5198,7 +5634,8 @@ class BaseClient {
      * await client.geosearchstore("destination", "mySortedSet", { member: "Palermo" }, { radius: 200, unit: GeoUnit.KILOMETERS });
      * // query the stored results
      * const result1 = await client.zrangeWithScores("destination", { start: 0, end: -1 });
-     * console.log(result1); // Output:
+     * console.log(result1);
+     * // Output:
      * // {
      * //     Palermo: 3479099956230698,   // geohash of the location is stored as element's score
      * //     Catania: 3479447370796909
@@ -5219,7 +5656,8 @@ class BaseClient {
      * );
      * // query the stored results
      * const result2 = await client.zrangeWithScores("destination", { start: 0, end: -1 });
-     * console.log(result2); // Output:
+     * console.log(result2);
+     * // Output:
      * // {
      * //     Palermo: 190.4424,   // distance from the search area center is stored as element's score
      * //     Catania: 56.4413,    // the distance is measured in units used for the search query (miles)
@@ -5248,11 +5686,12 @@ class BaseClient {
      * const result = await client.geopos("mySortedSet", ["Palermo", "Catania", "NonExisting"]);
      * // When added via GEOADD, the geospatial coordinates are converted into a 52 bit geohash, so the coordinates
      * // returned might not be exactly the same as the input values
-     * console.log(result); // Output:
+     * console.log(result);
+     * // Output:
      * // [
-     * //     [13.36138933897018433, 38.11555639549629859],
-     * //     [15.08726745843887329, 37.50266842333162032],
-     * //     null
+     * //     [13.36138933897018433, 38.11555639549629859], // Returns the position of member `Palermo`
+     * //     [15.08726745843887329, 37.50266842333162032], // Returns the position of member `Catania`
+     * //     null                                          // Returns null for non existent key.
      * // ]
      * ```
      */
@@ -5283,11 +5722,11 @@ class BaseClient {
      * await client.zadd("zSet2", { four: 4.0 });
      * console.log(await client.zmpop(["zSet1", "zSet2"], ScoreFilter.MAX, 2));
      * // Output:
-     * // "three" with score 3 and "two" with score 2 were popped from "zSet1"
      * // [ "zSet1", [
      * //     { element: 'three', score: 3 },
      * //     { element: 'two', score: 2 }
      * // ] ]
+     * // `three` with score 3 and `two` with score 2 were popped from `zSet1`.
      * ```
      */
     async zmpop(keys, modifier, options) {
@@ -5323,11 +5762,11 @@ class BaseClient {
      * await client.zadd("zSet2", { four: 4.0 });
      * console.log(await client.bzmpop(["zSet1", "zSet2"], ScoreFilter.MAX, 0.1, 2));
      * // Output:
-     * // "three" with score 3 and "two" with score 2 were popped from "zSet1"
      * // [ "zSet1", [
      * //     { element: 'three', score: 3 },
      * //     { element: 'two', score: 2 }
      * // ] ]
+     * // `three` with score 3 and `two` with score 2 were popped from `zSet1`
      * ```
      */
     async bzmpop(keys, modifier, timeout, options) {
@@ -5352,12 +5791,18 @@ class BaseClient {
      * ```typescript
      * // Example usage of zincrBy method to increment the value of a member's score
      * await client.zadd("my_sorted_set", {"member": 10.5, "member2": 8.2});
+     *
      * console.log(await client.zincrby("my_sorted_set", 1.2, "member"));
-     * // Output: 11.7 - The member existed in the set before score was altered, the new score is 11.7.
+     * // Output: 11.7
+     * // The member existed in the set before score was altered, the new score is 11.7.
+     *
      * console.log(await client.zincrby("my_sorted_set", -1.7, "member"));
-     * // Output: 10.0 - Negative increment, decrements the score.
+     * // Output: 10.0
+     * // Negative increment, decrements the score.
+     *
      * console.log(await client.zincrby("my_sorted_set", 5.5, "non_existing_member"));
-     * // Output: 5.5 - A new member is added to the sorted set with the score of 5.5.
+     * // Output: 5.5
+     * // A new member is added to the sorted set with the score of 5.5.
      * ```
      */
     async zincrby(key, increment, member) {
@@ -5446,7 +5891,8 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.geodist("mySortedSet", "Place1", "Place2", { unit: GeoUnit.KILOMETERS });
-     * console.log(num); // Output: the distance between Place1 and Place2.
+     * console.log(num);
+     * // Output: the distance between Place1 and Place2.
      * ```
      */
     async geodist(key, member1, member2, options) {
@@ -5465,7 +5911,9 @@ class BaseClient {
      * @example
      * ```typescript
      * const result = await client.geohash("mySortedSet", ["Palermo", "Catania", "NonExisting"]);
-     * console.log(result); // Output: ["sqc8b49rny0", "sqdtr74hyu0", null]
+     * console.log(result);
+     * // Output: ["sqc8b49rny0", "sqdtr74hyu0", null]
+     * // An array of GeoHash string.
      * ```
      */
     async geohash(key, members) {
@@ -5490,7 +5938,9 @@ class BaseClient {
      * ```typescript
      * await client.mset({"testKey1": "abcd", "testKey2": "axcd"});
      * const result = await client.lcs("testKey1", "testKey2");
-     * console.log(result); // Output: 'acd'
+     * console.log(result);
+     * // Output: 'acd'
+     * // Returned the longest common subsequence of strings stored at `testKey1` and `testKey2`.
      * ```
      */
     async lcs(key1, key2, options) {
@@ -5512,7 +5962,9 @@ class BaseClient {
      * ```typescript
      * await client.mset({"testKey1": "abcd", "testKey2": "axcd"});
      * const result = await client.lcsLen("testKey1", "testKey2");
-     * console.log(result); // Output: 3
+     * console.log(result);
+     * // Output: 3
+     * // The total length of all the longest common subsequences between the strings stored at `testKey1` and `testKey2`.
      * ```
      */
     async lcsLen(key1, key2, options) {
@@ -5546,7 +5998,8 @@ class BaseClient {
      * ```typescript
      * await client.mset({"key1": "ohmytext", "key2": "mynewtext"});
      * const result = await client.lcsIdx("key1", "key2");
-     * console.log(result); // Output:
+     * console.log(result);
+     * // Output:
      * {
      *     "matches" :
      *     [
@@ -5589,7 +6042,9 @@ class BaseClient {
      * await client.set("key1", "value1");
      * await client.set("key2", "value2");
      * const result = await client.touch(["key1", "key2", "nonExistingKey"]);
-     * console.log(result); // Output: 2 - The last access time of 2 keys has been updated.
+     * console.log(result);
+     * // Output: 2
+     * // The last access time of 2 keys has been updated.
      * ```
      */
     async touch(keys) {
@@ -5616,18 +6071,27 @@ class BaseClient {
      * @example
      * ```typescript
      * const response = await client.watch(["sampleKey"]);
-     * console.log(response); // Output: "OK"
+     * console.log(response);
+     * // Output: "OK"
+     *
      * const transaction = new Batch(true).set("SampleKey", "foobar");
      * const result = await client.exec(transaction);
-     * console.log(result); // Output: "OK" - Executes successfully and keys are unwatched.
+     * console.log(result);
+     *
+     * // Output: "OK"
+     * // Executes successfully and keys are unwatched.
      * ```
      * ```typescript
      * const response = await client.watch(["sampleKey"]);
-     * console.log(response); // Output: "OK"
+     * console.log(response);
+     * // Output: "OK"
+     *
      * const transaction = new Batch(true).set("SampleKey", "foobar");
      * await client.set("sampleKey", "hello world");
      * const result = await client.exec(transaction);
-     * console.log(result); // Output: null - null is returned when the watched key is modified before transaction execution.
+     * console.log(result);
+     * // Output: null
+     * // null is returned when the watched key is modified before transaction execution.
      * ```
      */
     async watch(keys) {
@@ -5650,7 +6114,8 @@ class BaseClient {
      * ```typescript
      * await client.set(key, value);
      * let response = await client.wait(1, 1000);
-     * console.log(response); // Output: return 1 when a replica is reached or 0 if 1000ms is reached.
+     * console.log(response);
+     * // Output: return 1 when a replica is reached or 0 if 1000ms is reached.
      * ```
      */
     async wait(numreplicas, timeout) {
@@ -5671,9 +6136,14 @@ class BaseClient {
      * @example
      * ```typescript
      * const len = await client.setrange("key", 6, "GLIDE");
-     * console.log(len); // Output: 11 - New key was created with length of 11 symbols
+     * console.log(len);
+     * // Output: 11
+     * // New key was created with length of 11 symbols
+     *
      * const value = await client.get("key");
-     * console.log(result); // Output: "\0\0\0\0\0\0GLIDE" - The string was padded with zero bytes
+     * console.log(result);
+     * // Output: "\0\0\0\0\0\0GLIDE"
+     * // The string was padded with zero bytes
      * ```
      */
     async setrange(key, offset, value) {
@@ -5693,12 +6163,15 @@ class BaseClient {
      * ```typescript
      * const len = await client.append("key", "Hello");
      * console.log(len);
-     *     // Output: 5 - Indicates that "Hello" has been appended to the value of "key", which was initially
-     *     // empty, resulting in a new value of "Hello" with a length of 5 - similar to the set operation.
+     * // Output: 5
+     * // Indicates that "Hello" has been appended to the value of "key", which was initially
+     * // empty, resulting in a new value of "Hello" with a length of 5 - similar to the set operation.
+     *
      * len = await client.append("key", " world");
      * console.log(result);
-     *     // Output: 11 - Indicates that " world" has been appended to the value of "key", resulting in a
-     *     // new value of "Hello world" with a length of 11.
+     * // Output: 11
+     * // Indicates that " world" has been appended to the value of "key", resulting in a
+     * // new value of "Hello world" with a length of 11.
      * ```
      */
     async append(key, value) {
@@ -5724,7 +6197,8 @@ class BaseClient {
      * await client.lpush("testKey", ["one", "two", "three"]);
      * await client.lpush("testKey2", ["five", "six", "seven"]);
      * const result = await client.lmpop(["testKey", "testKey2"], ListDirection.LEFT, 1L);
-     * console.log(result); // Output: { key: "testKey", elements: ["three"] }
+     * console.log(result);
+     * // Output: { key: "testKey", elements: ["three"] }
      * ```
      */
     async lmpop(keys, direction, options) {
@@ -5756,7 +6230,8 @@ class BaseClient {
      * await client.lpush("testKey", ["one", "two", "three"]);
      * await client.lpush("testKey2", ["five", "six", "seven"]);
      * const result = await client.blmpop(["testKey", "testKey2"], ListDirection.LEFT, 0.1, 1);
-     * console.log(result"testKey"); // Output: { key: "testKey", elements: ["three"] }
+     * console.log(result"testKey");
+     * // Output: { key: "testKey", elements: ["three"] }
      * ```
      */
     async blmpop(keys, direction, timeout, options) {
@@ -5782,10 +6257,12 @@ class BaseClient {
      * @example
      * ```typescript
      * const channels = await client.pubsubChannels();
-     * console.log(channels); // Output: ["channel1", "channel2"]
+     * console.log(channels);
+     * // Output: ["channel1", "channel2"]
      *
      * const newsChannels = await client.pubsubChannels("news.*");
-     * console.log(newsChannels); // Output: ["news.sports", "news.weather"]
+     * console.log(newsChannels);
+     * // Output: ["news.sports", "news.weather"]
      * ```
      */
     async pubsubChannels(options) {
@@ -5805,7 +6282,8 @@ class BaseClient {
      * @example
      * ```typescript
      * const patternCount = await client.pubsubNumpat();
-     * console.log(patternCount); // Output: 3
+     * console.log(patternCount);
+     * // Output: 3
      * ```
      */
     async pubsubNumPat() {
@@ -5824,11 +6302,12 @@ class BaseClient {
      * @example
      * ```typescript
      * const result1 = await client.pubsubNumsub(["channel1", "channel2"]);
-     * console.log(result1); // Output:
-     * // [{ channel: "channel1", numSub: 3}, { channel: "channel2", numSub: 5 }]
+     * console.log(result1);
+     * // Output: [{ channel: "channel1", numSub: 3}, { channel: "channel2", numSub: 5 }]
      *
      * const result2 = await client.pubsubNumsub([]);
-     * console.log(result2); // Output: []
+     * console.log(result2);
+     * // Output: []
      * ```
      */
     async pubsubNumSub(channels, options) {
@@ -5859,7 +6338,9 @@ class BaseClient {
      * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
      * await client.lpush("user_ids", ["2", "1"]);
      * const result = await client.sort("user_ids", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
-     * console.log(result); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age
+     * console.log(result);
+     * // Output: [ 'Bob', 'Alice' ]
+     * // Returns a list of the names sorted by age
      * ```
      */
     async sort(key, options) {
@@ -5888,7 +6369,9 @@ class BaseClient {
      * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
      * await client.lpush("user_ids", ["2", "1"]);
      * const result = await client.sortReadOnly("user_ids", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
-     * console.log(result); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age
+     * console.log(result);
+     * // Output: [ 'Bob', 'Alice' ]
+     * // Returns a list of the names sorted by age
      * ```
      */
     async sortReadOnly(key, options) {
@@ -5919,8 +6402,13 @@ class BaseClient {
      * await client.hset("user:2", new Map([["name", "Bob"], ["age", "25"]]));
      * await client.lpush("user_ids", ["2", "1"]);
      * const sortedElements = await client.sortStore("user_ids", "sortedList", { byPattern: "user:*->age", getPattern: ["user:*->name"] });
-     * console.log(sortedElements); // Output: 2 - number of elements sorted and stored
-     * console.log(await client.lrange("sortedList", 0, -1)); // Output: [ 'Bob', 'Alice' ] - Returns a list of the names sorted by age stored in `sortedList`
+     * console.log(sortedElements);
+     * // Output: 2
+     * // number of elements sorted and stored
+     *
+     * console.log(await client.lrange("sortedList", 0, -1));
+     * // Output: [ 'Bob', 'Alice' ]
+     * // Returns a list of the names sorted by age stored in `sortedList`
      * ```
      */
     async sortStore(key, destination, options) {
@@ -5955,6 +6443,7 @@ class BaseClient {
             inflightRequestsLimit: options.inflightRequestsLimit,
             clientAz: options.clientAz ?? null,
             connectionRetryStrategy: options.connectionBackoff,
+            lazyConnect: options.lazyConnect ?? false,
         };
     }
     /**
@@ -6059,7 +6548,8 @@ class BaseClient {
      *
      * @example
      * ```typescript
-     * await client.updateConnectionPassword("newPassword", true) // "OK"
+     * await client.updateConnectionPassword("newPassword", true)
+     * // Output: "OK"
      * ```
      */
     async updateConnectionPassword(password, immediateAuth = false) {