(docs) add jsdoc comments to command parsers (#2984)

* (docs) bloom: add jsdocs for all commands

* (docs) json: add jsdocs

* (docs) search: add jsdocs for all commands

* (docs) jsdocs for std commands

* (docs) jsdoc comments to time series commands

packages/client/lib/commands/ACL_CAT.ts

@@ -4,6 +4,11 @@ import { RedisArgument, ArrayReply, BlobStringReply, Command } from '../RESP/typ
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Lists ACL categories or commands in a category
+   * @param parser - The Redis command parser
+   * @param categoryName - Optional category name to filter commands
+   */
   parseCommand(parser: CommandParser, categoryName?: RedisArgument) {
     parser.push('ACL', 'CAT');
     if (categoryName) {

packages/client/lib/commands/ACL_DELUSER.ts

@@ -5,6 +5,11 @@ import { RedisVariadicArgument } from './generic-transformers';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Deletes one or more users from the ACL
+   * @param parser - The Redis command parser
+   * @param username - Username(s) to delete
+   */
   parseCommand(parser: CommandParser, username: RedisVariadicArgument) {
     parser.push('ACL', 'DELUSER');
     parser.pushVariadic(username);

packages/client/lib/commands/ACL_DRYRUN.ts

@@ -4,6 +4,12 @@ import { RedisArgument, SimpleStringReply, BlobStringReply, Command } from '../R
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Simulates ACL operations without executing them
+   * @param parser - The Redis command parser
+   * @param username - Username to simulate ACL operations for
+   * @param command - Command arguments to simulate
+   */
   parseCommand(parser: CommandParser, username: RedisArgument, command: Array<RedisArgument>) {
     parser.push('ACL', 'DRYRUN', username, ...command);
   },

packages/client/lib/commands/ACL_GENPASS.ts

@@ -4,6 +4,11 @@ import { BlobStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Generates a secure password for ACL users
+   * @param parser - The Redis command parser
+   * @param bits - Optional number of bits for password entropy
+   */
   parseCommand(parser: CommandParser, bits?: number) {
     parser.push('ACL', 'GENPASS');
     if (bits) {

packages/client/lib/commands/ACL_GETUSER.ts

@@ -20,6 +20,11 @@ type AclUser = TuplesToMapReply<[
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns ACL information about a specific user
+   * @param parser - The Redis command parser
+   * @param username - Username to get information for
+   */
   parseCommand(parser: CommandParser, username: RedisArgument) {
     parser.push('ACL', 'GETUSER', username);
   },

packages/client/lib/commands/ACL_LIST.ts

@@ -4,6 +4,10 @@ import { ArrayReply, BlobStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns all configured ACL users and their permissions
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('ACL', 'LIST');
   },

packages/client/lib/commands/ACL_LOAD.ts

@@ -4,6 +4,10 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Reloads ACL configuration from the ACL file
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('ACL', 'LOAD');
   },

packages/client/lib/commands/ACL_LOG.ts

@@ -21,6 +21,11 @@ export type AclLogReply = ArrayReply<TuplesToMapReply<[
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns ACL security events log entries
+   * @param parser - The Redis command parser
+   * @param count - Optional maximum number of entries to return
+   */
   parseCommand(parser: CommandParser, count?: number) {
     parser.push('ACL', 'LOG');
     if (count != undefined) {

packages/client/lib/commands/ACL_LOG_RESET.ts

@@ -5,6 +5,10 @@ import ACL_LOG from './ACL_LOG';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: ACL_LOG.IS_READ_ONLY,
+  /**
+   * Clears the ACL security events log
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('ACL', 'LOG', 'RESET');
   },

packages/client/lib/commands/ACL_SAVE.ts

@@ -4,6 +4,10 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Saves the current ACL configuration to the ACL file
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('ACL', 'SAVE');
   },

packages/client/lib/commands/ACL_SETUSER.ts

@@ -5,6 +5,12 @@ import { RedisVariadicArgument } from './generic-transformers';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Creates or modifies ACL user with specified rules
+   * @param parser - The Redis command parser
+   * @param username - Username to create or modify
+   * @param rule - ACL rule(s) to apply to the user
+   */
   parseCommand(parser: CommandParser, username: RedisArgument, rule: RedisVariadicArgument) {
     parser.push('ACL', 'SETUSER', username);
     parser.pushVariadic(rule);

packages/client/lib/commands/ACL_USERS.ts

@@ -4,6 +4,10 @@ import { ArrayReply, BlobStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns a list of all configured ACL usernames
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('ACL', 'USERS');
   },

packages/client/lib/commands/ACL_WHOAMI.ts

@@ -4,6 +4,10 @@ import { BlobStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the username of the current connection
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('ACL', 'WHOAMI');
   },

packages/client/lib/commands/APPEND.ts

@@ -3,6 +3,12 @@ import { RedisArgument, NumberReply, Command } from '../RESP/types';
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Appends a value to a string key
+   * @param parser - The Redis command parser
+   * @param key - The key to append to
+   * @param value - The value to append
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, value: RedisArgument) {
     parser.push('APPEND', key, value);
   },

packages/client/lib/commands/ASKING.ts

@@ -6,6 +6,10 @@ export const ASKING_CMD = 'ASKING';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Tells a Redis cluster node that the client is ok receiving such redirects
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push(ASKING_CMD);
   },

packages/client/lib/commands/AUTH.ts

@@ -9,6 +9,13 @@ export interface AuthOptions {
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Authenticates the connection using a password or username and password
+   * @param parser - The Redis command parser
+   * @param options - Authentication options containing username and/or password
+   * @param options.username - Optional username for authentication
+   * @param options.password - Password for authentication
+   */
   parseCommand(parser: CommandParser, { username, password }: AuthOptions) {
     parser.push('AUTH');
     if (username !== undefined) {

packages/client/lib/commands/BGREWRITEAOF.ts

@@ -4,6 +4,10 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Asynchronously rewrites the append-only file
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('BGREWRITEAOF');
   },

packages/client/lib/commands/BGSAVE.ts

@@ -8,6 +8,12 @@ export interface BgSaveOptions {
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Asynchronously saves the dataset to disk
+   * @param parser - The Redis command parser
+   * @param options - Optional configuration
+   * @param options.SCHEDULE - Schedule a BGSAVE operation when no BGSAVE is already in progress
+   */
   parseCommand(parser: CommandParser, options?: BgSaveOptions) {
     parser.push('BGSAVE');
     if (options?.SCHEDULE) {

packages/client/lib/commands/BITCOUNT.ts

@@ -10,6 +10,15 @@ export interface BitCountRange {
 export default {
   CACHEABLE: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the count of set bits in a string key
+   * @param parser - The Redis command parser
+   * @param key - The key to count bits in
+   * @param range - Optional range specification
+   * @param range.start - Start offset in bytes/bits
+   * @param range.end - End offset in bytes/bits
+   * @param range.mode - Optional counting mode: BYTE or BIT
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, range?: BitCountRange) {
     parser.push('BITCOUNT');
     parser.pushKey(key);

packages/client/lib/commands/BITFIELD.ts

@@ -41,6 +41,12 @@ export type BitFieldRoOperations = Array<
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Performs arbitrary bitfield integer operations on strings
+   * @param parser - The Redis command parser
+   * @param key - The key holding the string
+   * @param operations - Array of bitfield operations to perform: GET, SET, INCRBY or OVERFLOW
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, operations: BitFieldOperations) {
     parser.push('BITFIELD');
     parser.pushKey(key);

packages/client/lib/commands/BITFIELD_RO.ts

@@ -9,6 +9,12 @@ export type BitFieldRoOperations = Array<
 export default {
   CACHEABLE: true,
   IS_READ_ONLY: true,
+  /**
+   * Performs read-only bitfield integer operations on strings
+   * @param parser - The Redis command parser
+   * @param key - The key holding the string
+   * @param operations - Array of GET operations to perform on the bitfield
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, operations: BitFieldRoOperations) {
     parser.push('BITFIELD_RO');
     parser.pushKey(key);

packages/client/lib/commands/BITOP.ts

@@ -6,6 +6,13 @@ export type BitOperations = 'AND' | 'OR' | 'XOR' | 'NOT';
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Performs bitwise operations between strings
+   * @param parser - The Redis command parser
+   * @param operation - Bitwise operation to perform: AND, OR, XOR, NOT
+   * @param destKey - Destination key to store the result
+   * @param key - Source key(s) to perform operation on
+   */
   parseCommand(
     parser: CommandParser,
     operation: BitOperations,

packages/client/lib/commands/BITPOS.ts

@@ -5,6 +5,15 @@ import { BitValue } from './generic-transformers';
 export default {
   CACHEABLE: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the position of first bit set to 0 or 1 in a string
+   * @param parser - The Redis command parser
+   * @param key - The key holding the string
+   * @param bit - The bit value to look for (0 or 1)
+   * @param start - Optional starting position in bytes/bits
+   * @param end - Optional ending position in bytes/bits
+   * @param mode - Optional counting mode: BYTE or BIT
+   */
   parseCommand(parser: CommandParser,
     key: RedisArgument,
     bit: BitValue,

packages/client/lib/commands/BLMOVE.ts

@@ -4,6 +4,15 @@ import { ListSide } from './generic-transformers';
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Pop an element from a list, push it to another list and return it; or block until one is available
+   * @param parser - The Redis command parser
+   * @param source - Key of the source list
+   * @param destination - Key of the destination list
+   * @param sourceSide - Side of source list to pop from (LEFT or RIGHT)
+   * @param destinationSide - Side of destination list to push to (LEFT or RIGHT)
+   * @param timeout - Timeout in seconds, 0 to block indefinitely
+   */
   parseCommand(
     parser: CommandParser,
     source: RedisArgument,

packages/client/lib/commands/BLMPOP.ts

@@ -4,6 +4,12 @@ import LMPOP, { LMPopArguments, parseLMPopArguments } from './LMPOP';
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Pops elements from multiple lists; blocks until elements are available
+   * @param parser - The Redis command parser
+   * @param timeout - Timeout in seconds, 0 to block indefinitely
+   * @param args - Additional arguments for LMPOP command
+   */
   parseCommand(parser: CommandParser, timeout: number, ...args: LMPopArguments) {
     parser.push('BLMPOP', timeout.toString());
     parseLMPopArguments(parser, ...args);

packages/client/lib/commands/BLPOP.ts

@@ -4,6 +4,12 @@ import { RedisVariadicArgument } from './generic-transformers';
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Removes and returns the first element in a list, or blocks until one is available
+   * @param parser - The Redis command parser
+   * @param key - Key of the list to pop from, or array of keys to try sequentially
+   * @param timeout - Maximum seconds to block, 0 to block indefinitely
+   */
   parseCommand(parser: CommandParser, key: RedisVariadicArgument, timeout: number) {
     parser.push('BLPOP');
     parser.pushKeys(key);

packages/client/lib/commands/BRPOP.ts

@@ -5,6 +5,12 @@ import BLPOP from './BLPOP';
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Removes and returns the last element in a list, or blocks until one is available
+   * @param parser - The Redis command parser
+   * @param key - Key of the list to pop from, or array of keys to try sequentially
+   * @param timeout - Maximum seconds to block, 0 to block indefinitely
+   */
   parseCommand(parser: CommandParser, key: RedisVariadicArgument, timeout: number) {
     parser.push('BRPOP');
     parser.pushKeys(key);

packages/client/lib/commands/BRPOPLPUSH.ts

@@ -3,6 +3,13 @@ import { RedisArgument, BlobStringReply, NullReply, Command } from '../RESP/type
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Pops an element from a list, pushes it to another list and returns it; blocks until element is available
+   * @param parser - The Redis command parser
+   * @param source - Key of the source list to pop from
+   * @param destination - Key of the destination list to push to
+   * @param timeout - Maximum seconds to block, 0 to block indefinitely
+   */
   parseCommand(parser: CommandParser, source: RedisArgument, destination: RedisArgument, timeout: number) {
     parser.push('BRPOPLPUSH');
     parser.pushKeys([source, destination]);

packages/client/lib/commands/BZMPOP.ts

@@ -4,6 +4,12 @@ import ZMPOP, { parseZMPopArguments, ZMPopArguments } from './ZMPOP';
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Removes and returns members from one or more sorted sets in the specified order; blocks until elements are available
+   * @param parser - The Redis command parser
+   * @param timeout - Maximum seconds to block, 0 to block indefinitely
+   * @param args - Additional arguments specifying the keys, min/max count, and order (MIN/MAX)
+   */
   parseCommand(parser: CommandParser, timeout: number, ...args: ZMPopArguments) {
     parser.push('BZMPOP', timeout.toString());
     parseZMPopArguments(parser, ...args);

packages/client/lib/commands/BZPOPMAX.ts

@@ -4,6 +4,12 @@ import { RedisVariadicArgument, transformDoubleReply } from './generic-transform
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Removes and returns the member with the highest score in a sorted set, or blocks until one is available
+   * @param parser - The Redis command parser
+   * @param keys - Key of the sorted set, or array of keys to try sequentially
+   * @param timeout - Maximum seconds to block, 0 to block indefinitely
+   */
   parseCommand(parser: CommandParser, keys: RedisVariadicArgument, timeout: number) {
     parser.push('BZPOPMAX');
     parser.pushKeys(keys);

packages/client/lib/commands/BZPOPMIN.ts

@@ -5,6 +5,12 @@ import BZPOPMAX from './BZPOPMAX';
 
 export default {
   IS_READ_ONLY: BZPOPMAX.IS_READ_ONLY,
+  /**
+   * Removes and returns the member with the lowest score in a sorted set, or blocks until one is available
+   * @param parser - The Redis command parser
+   * @param keys - Key of the sorted set, or array of keys to try sequentially
+   * @param timeout - Maximum seconds to block, 0 to block indefinitely
+   */
   parseCommand(parser: CommandParser, keys: RedisVariadicArgument, timeout: number) {
     parser.push('BZPOPMIN');
     parser.pushKeys(keys);

packages/client/lib/commands/CLIENT_CACHING.ts

@@ -4,6 +4,11 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Instructs the server about tracking or not keys in the next request
+   * @param parser - The Redis command parser
+   * @param value - Whether to enable (true) or disable (false) tracking
+   */
   parseCommand(parser: CommandParser, value: boolean) {
     parser.push(
       'CLIENT',

packages/client/lib/commands/CLIENT_GETNAME.ts

@@ -4,6 +4,10 @@ import { BlobStringReply, NullReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the name of the current connection
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLIENT', 'GETNAME');
   },

packages/client/lib/commands/CLIENT_GETREDIR.ts

@@ -4,6 +4,10 @@ import { NumberReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the ID of the client to which the current client is redirecting tracking notifications
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLIENT', 'GETREDIR');
   },

packages/client/lib/commands/CLIENT_ID.ts

@@ -4,6 +4,10 @@ import { NumberReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the client ID for the current connection
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLIENT', 'ID');
   },

packages/client/lib/commands/CLIENT_INFO.ts

@@ -67,6 +67,10 @@ const CLIENT_INFO_REGEX = /([^\s=]+)=([^\s]*)/g;
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns information and statistics about the current client connection
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLIENT', 'INFO');
   },

packages/client/lib/commands/CLIENT_KILL.ts

@@ -50,6 +50,11 @@ export type ClientKillFilter = ClientKillAddress | ClientKillLocalAddress | Clie
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Closes client connections matching the specified filters
+   * @param parser - The Redis command parser
+   * @param filters - One or more filters to match client connections to kill
+   */
   parseCommand(parser: CommandParser, filters: ClientKillFilter | Array<ClientKillFilter>) {
     parser.push('CLIENT', 'KILL');
 

packages/client/lib/commands/CLIENT_LIST.ts

@@ -17,6 +17,11 @@ export type ListFilter = ListFilterType | ListFilterId;
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns information about all client connections. Can be filtered by type or ID
+   * @param parser - The Redis command parser
+   * @param filter - Optional filter to return only specific client types or IDs
+   */
   parseCommand(parser: CommandParser, filter?: ListFilter) {
     parser.push('CLIENT', 'LIST');
     if (filter) {

packages/client/lib/commands/CLIENT_NO-EVICT.ts

@@ -4,6 +4,11 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Controls whether to prevent the client's connections from being evicted
+   * @param parser - The Redis command parser
+   * @param value - Whether to enable (true) or disable (false) the no-evict mode
+   */
   parseCommand(parser: CommandParser, value: boolean) {
     parser.push(
       'CLIENT',

packages/client/lib/commands/CLIENT_NO-TOUCH.ts

@@ -4,6 +4,11 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Controls whether to prevent the client from touching the LRU/LFU of keys
+   * @param parser - The Redis command parser
+   * @param value - Whether to enable (true) or disable (false) the no-touch mode
+   */
   parseCommand(parser: CommandParser, value: boolean) {
     parser.push(
       'CLIENT',

packages/client/lib/commands/CLIENT_PAUSE.ts

@@ -4,6 +4,12 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Stops the server from processing client commands for the specified duration
+   * @param parser - The Redis command parser
+   * @param timeout - Time in milliseconds to pause command processing
+   * @param mode - Optional mode: 'WRITE' to pause only write commands, 'ALL' to pause all commands
+   */
   parseCommand(parser: CommandParser, timeout: number, mode?: 'WRITE' | 'ALL') {
     parser.push('CLIENT', 'PAUSE', timeout.toString());
     if (mode) {

packages/client/lib/commands/CLIENT_SETNAME.ts

@@ -4,6 +4,11 @@ import { RedisArgument, SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Assigns a name to the current connection
+   * @param parser - The Redis command parser
+   * @param name - The name to assign to the connection
+   */
   parseCommand(parser: CommandParser, name: RedisArgument) {
     parser.push('CLIENT', 'SETNAME', name);
   },

packages/client/lib/commands/CLIENT_TRACKING.ts

@@ -29,6 +29,12 @@ export type ClientTrackingOptions = CommonOptions & (
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Controls server-assisted client side caching for the current connection
+   * @param parser - The Redis command parser
+   * @param mode - Whether to enable (true) or disable (false) tracking
+   * @param options - Optional configuration including REDIRECT, BCAST, PREFIX, OPTIN, OPTOUT, and NOLOOP options
+   */
   parseCommand<M extends boolean>(
     parser: CommandParser,
     mode: M,

packages/client/lib/commands/CLIENT_TRACKINGINFO.ts

@@ -10,6 +10,10 @@ type TrackingInfo = TuplesToMapReply<[
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns information about the current connection's key tracking state
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLIENT', 'TRACKINGINFO');
   },

packages/client/lib/commands/CLIENT_UNPAUSE.ts

@@ -4,6 +4,10 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Resumes processing of client commands after a CLIENT PAUSE
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLIENT', 'UNPAUSE');
   },

packages/client/lib/commands/CLUSTER_ADDSLOTS.ts

@@ -4,6 +4,11 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Assigns hash slots to the current node in a Redis Cluster
+   * @param parser - The Redis command parser
+   * @param slots - One or more hash slots to be assigned
+   */
   parseCommand(parser: CommandParser, slots: number | Array<number>) {
     parser.push('CLUSTER', 'ADDSLOTS');
     parser.pushVariadicNumber(slots);

packages/client/lib/commands/CLUSTER_ADDSLOTSRANGE.ts

@@ -5,6 +5,11 @@ import { parseSlotRangesArguments, SlotRange } from './generic-transformers';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Assigns hash slot ranges to the current node in a Redis Cluster
+   * @param parser - The Redis command parser
+   * @param ranges - One or more slot ranges to be assigned, each specified as [start, end]
+   */
   parseCommand(parser: CommandParser, ranges: SlotRange | Array<SlotRange>) {
     parser.push('CLUSTER', 'ADDSLOTSRANGE');
     parseSlotRangesArguments(parser, ranges);

packages/client/lib/commands/CLUSTER_BUMPEPOCH.ts

@@ -4,6 +4,10 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Advances the cluster config epoch
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLUSTER', 'BUMPEPOCH');
   },

packages/client/lib/commands/CLUSTER_COUNT-FAILURE-REPORTS.ts

@@ -4,6 +4,11 @@ import { RedisArgument, NumberReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the number of failure reports for a given node
+   * @param parser - The Redis command parser
+   * @param nodeId - The ID of the node to check
+   */
   parseCommand(parser: CommandParser, nodeId: RedisArgument) {
     parser.push('CLUSTER', 'COUNT-FAILURE-REPORTS', nodeId);
   },

packages/client/lib/commands/CLUSTER_COUNTKEYSINSLOT.ts

@@ -4,6 +4,11 @@ import { NumberReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the number of keys in the specified hash slot
+   * @param parser - The Redis command parser
+   * @param slot - The hash slot to check
+   */
   parseCommand(parser: CommandParser, slot: number) {
     parser.push('CLUSTER', 'COUNTKEYSINSLOT', slot.toString());
   },

packages/client/lib/commands/CLUSTER_DELSLOTS.ts

@@ -4,6 +4,11 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Removes hash slots from the current node in a Redis Cluster
+   * @param parser - The Redis command parser
+   * @param slots - One or more hash slots to be removed
+   */
   parseCommand(parser: CommandParser, slots: number | Array<number>) {
     parser.push('CLUSTER', 'DELSLOTS');
     parser.pushVariadicNumber(slots);

packages/client/lib/commands/CLUSTER_DELSLOTSRANGE.ts

@@ -5,6 +5,11 @@ import { parseSlotRangesArguments, SlotRange } from './generic-transformers';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Removes hash slot ranges from the current node in a Redis Cluster
+   * @param parser - The Redis command parser
+   * @param ranges - One or more slot ranges to be removed, each specified as [start, end]
+   */
   parseCommand(parser:CommandParser, ranges: SlotRange | Array<SlotRange>) {
     parser.push('CLUSTER', 'DELSLOTSRANGE');
     parseSlotRangesArguments(parser, ranges);

packages/client/lib/commands/CLUSTER_FAILOVER.ts

@@ -15,6 +15,11 @@ export interface ClusterFailoverOptions {
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Forces a replica to perform a manual failover of its master
+   * @param parser - The Redis command parser
+   * @param options - Optional configuration with FORCE or TAKEOVER mode
+   */
   parseCommand(parser:CommandParser, options?: ClusterFailoverOptions) {
     parser.push('CLUSTER', 'FAILOVER');
 

packages/client/lib/commands/CLUSTER_FLUSHSLOTS.ts

@@ -4,6 +4,10 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Deletes all hash slots from the current node in a Redis Cluster
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLUSTER', 'FLUSHSLOTS');
   },

packages/client/lib/commands/CLUSTER_FORGET.ts

@@ -4,6 +4,11 @@ import { RedisArgument, SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Removes a node from the cluster
+   * @param parser - The Redis command parser
+   * @param nodeId - The ID of the node to remove
+   */
   parseCommand(parser: CommandParser, nodeId: RedisArgument) {
     parser.push('CLUSTER', 'FORGET', nodeId);
   },

packages/client/lib/commands/CLUSTER_GETKEYSINSLOT.ts

@@ -4,6 +4,12 @@ import { ArrayReply, BlobStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns a number of keys from the specified hash slot
+   * @param parser - The Redis command parser
+   * @param slot - The hash slot to get keys from
+   * @param count - Maximum number of keys to return
+   */
   parseCommand(parser: CommandParser, slot: number, count: number) {
     parser.push('CLUSTER', 'GETKEYSINSLOT', slot.toString(), count.toString());
   },

packages/client/lib/commands/CLUSTER_INFO.ts

@@ -4,6 +4,10 @@ import { VerbatimStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns information about the state of a Redis Cluster
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLUSTER', 'INFO');
   },

packages/client/lib/commands/CLUSTER_KEYSLOT.ts

@@ -4,6 +4,11 @@ import { Command, NumberReply, RedisArgument } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the hash slot number for a given key
+   * @param parser - The Redis command parser
+   * @param key - The key to get the hash slot for
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('CLUSTER', 'KEYSLOT', key);
   },

packages/client/lib/commands/CLUSTER_LINKS.ts

@@ -13,6 +13,10 @@ type ClusterLinksReply = ArrayReply<TuplesToMapReply<[
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns information about all cluster links (lower level connections to other nodes)
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLUSTER', 'LINKS');
   },

packages/client/lib/commands/CLUSTER_MEET.ts

@@ -4,6 +4,12 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Initiates a handshake with another node in the cluster
+   * @param parser - The Redis command parser
+   * @param host - Host name or IP address of the node
+   * @param port - TCP port of the node
+   */
   parseCommand(parser: CommandParser, host: string, port: number) {
     parser.push('CLUSTER', 'MEET', host, port.toString());
   },

packages/client/lib/commands/CLUSTER_MYID.ts

@@ -4,6 +4,10 @@ import { BlobStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the node ID of the current Redis Cluster node
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLUSTER', 'MYID');
   },

packages/client/lib/commands/CLUSTER_MYSHARDID.ts

@@ -4,6 +4,10 @@ import { BlobStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the shard ID of the current Redis Cluster node
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLUSTER', 'MYSHARDID');
   },

packages/client/lib/commands/CLUSTER_NODES.ts

@@ -4,6 +4,10 @@ import { VerbatimStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns serialized information about the nodes in a Redis Cluster
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLUSTER', 'NODES');
   },

packages/client/lib/commands/CLUSTER_REPLICAS.ts

@@ -4,6 +4,11 @@ import { RedisArgument, ArrayReply, BlobStringReply, Command } from '../RESP/typ
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the replica nodes replicating from the specified primary node
+   * @param parser - The Redis command parser
+   * @param nodeId - Node ID of the primary node
+   */
   parseCommand(parser: CommandParser, nodeId: RedisArgument) {
     parser.push('CLUSTER', 'REPLICAS', nodeId);
   },

packages/client/lib/commands/CLUSTER_REPLICATE.ts

@@ -4,6 +4,11 @@ import { RedisArgument, SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Reconfigures a node as a replica of the specified primary node
+   * @param parser - The Redis command parser
+   * @param nodeId - Node ID of the primary node to replicate
+   */
   parseCommand(parser: CommandParser, nodeId: RedisArgument) {
     parser.push('CLUSTER', 'REPLICATE', nodeId);
   },

packages/client/lib/commands/CLUSTER_RESET.ts

@@ -8,6 +8,11 @@ export interface ClusterResetOptions {
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Resets a Redis Cluster node, clearing all information and returning it to a brand new state
+   * @param parser - The Redis command parser
+   * @param options - Options for the reset operation
+   */
   parseCommand(parser: CommandParser, options?: ClusterResetOptions) {
     parser.push('CLUSTER', 'RESET');
 

packages/client/lib/commands/CLUSTER_SAVECONFIG.ts

@@ -4,6 +4,10 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Forces a Redis Cluster node to save the cluster configuration to disk
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLUSTER', 'SAVECONFIG');
   },

packages/client/lib/commands/CLUSTER_SET-CONFIG-EPOCH.ts

@@ -4,6 +4,11 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Sets the configuration epoch for a Redis Cluster node
+   * @param parser - The Redis command parser
+   * @param configEpoch - The configuration epoch to set
+   */
   parseCommand(parser: CommandParser, configEpoch: number) {
     parser.push('CLUSTER', 'SET-CONFIG-EPOCH', configEpoch.toString());
   },

packages/client/lib/commands/CLUSTER_SETSLOT.ts

@@ -13,6 +13,13 @@ export type ClusterSlotState = typeof CLUSTER_SLOT_STATES[keyof typeof CLUSTER_S
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Assigns a hash slot to a specific Redis Cluster node
+   * @param parser - The Redis command parser
+   * @param slot - The slot number to assign
+   * @param state - The state to set for the slot (IMPORTING, MIGRATING, STABLE, NODE)
+   * @param nodeId - Node ID (required for IMPORTING, MIGRATING, and NODE states)
+   */
   parseCommand(parser: CommandParser, slot: number, state: ClusterSlotState, nodeId?: RedisArgument) {
     parser.push('CLUSTER', 'SETSLOT', slot.toString(), state);
 

packages/client/lib/commands/CLUSTER_SLOTS.ts

@@ -19,6 +19,10 @@ export type ClusterSlotsNode = ReturnType<typeof transformNode>;
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns information about which Redis Cluster node handles which hash slots
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CLUSTER', 'SLOTS');
   },

packages/client/lib/commands/COMMAND.ts

@@ -5,6 +5,10 @@ import { CommandRawReply, CommandReply, transformCommandReply } from './generic-
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns an array with details about all Redis commands
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('COMMAND');
   },

packages/client/lib/commands/COMMAND_COUNT.ts

@@ -4,6 +4,10 @@ import { NumberReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the total number of commands available in the Redis server
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('COMMAND', 'COUNT');
   },

packages/client/lib/commands/COMMAND_GETKEYS.ts

@@ -4,6 +4,11 @@ import { RedisArgument, ArrayReply, BlobStringReply, Command } from '../RESP/typ
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Extracts the key names from a Redis command
+   * @param parser - The Redis command parser
+   * @param args - Command arguments to analyze
+   */
   parseCommand(parser: CommandParser, args: Array<RedisArgument>) {
     parser.push('COMMAND', 'GETKEYS');
     parser.push(...args);

packages/client/lib/commands/COMMAND_GETKEYSANDFLAGS.ts

@@ -9,6 +9,11 @@ export type CommandGetKeysAndFlagsRawReply = ArrayReply<TuplesReply<[
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Extracts the key names and access flags from a Redis command
+   * @param parser - The Redis command parser
+   * @param args - Command arguments to analyze
+   */
   parseCommand(parser: CommandParser, args: Array<RedisArgument>) {
     parser.push('COMMAND', 'GETKEYSANDFLAGS');
     parser.push(...args);

packages/client/lib/commands/COMMAND_INFO.ts

@@ -5,6 +5,11 @@ import { CommandRawReply, CommandReply, transformCommandReply } from './generic-
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns details about specific Redis commands
+   * @param parser - The Redis command parser
+   * @param commands - Array of command names to get information about
+   */
   parseCommand(parser: CommandParser, commands: Array<string>) {
     parser.push('COMMAND', 'INFO', ...commands);
   },

packages/client/lib/commands/COMMAND_LIST.ts

@@ -19,6 +19,11 @@ export interface CommandListOptions {
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns a list of all commands supported by the Redis server
+   * @param parser - The Redis command parser
+   * @param options - Options for filtering the command list
+   */
   parseCommand(parser: CommandParser, options?: CommandListOptions) {
     parser.push('COMMAND', 'LIST');
 

packages/client/lib/commands/CONFIG_GET.ts

@@ -5,6 +5,11 @@ import { RedisVariadicArgument, transformTuplesReply } from './generic-transform
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Gets the values of configuration parameters
+   * @param parser - The Redis command parser
+   * @param parameters - Pattern or specific configuration parameter names
+   */
   parseCommand(parser: CommandParser, parameters: RedisVariadicArgument) {
     parser.push('CONFIG', 'GET');
     parser.pushVariadic(parameters);

packages/client/lib/commands/CONFIG_RESETSTAT.ts

@@ -4,6 +4,10 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Resets the statistics reported by Redis using the INFO command
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CONFIG', 'RESETSTAT');
   },

packages/client/lib/commands/CONFIG_REWRITE.ts

@@ -4,6 +4,10 @@ import { SimpleStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Rewrites the Redis configuration file with the current configuration
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('CONFIG', 'REWRITE');
   },

packages/client/lib/commands/CONFIG_SET.ts

@@ -8,6 +8,12 @@ type MultipleParameters = [config: Record<string, RedisArgument>];
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Sets configuration parameters to the specified values
+   * @param parser - The Redis command parser
+   * @param parameterOrConfig - Either a single parameter name or a configuration object
+   * @param value - Value for the parameter (when using single parameter format)
+   */
   parseCommand(
     parser: CommandParser,
     ...[parameterOrConfig, value]: SingleParameter | MultipleParameters

packages/client/lib/commands/COPY.ts

@@ -8,6 +8,13 @@ export interface CopyCommandOptions {
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Copies the value stored at the source key to the destination key
+   * @param parser - The Redis command parser
+   * @param source - Source key
+   * @param destination - Destination key
+   * @param options - Options for the copy operation
+   */
   parseCommand(parser: CommandParser, source: RedisArgument, destination: RedisArgument, options?: CopyCommandOptions) {
     parser.push('COPY');
     parser.pushKeys([source, destination]);

packages/client/lib/commands/DBSIZE.ts

@@ -4,6 +4,10 @@ import { NumberReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the number of keys in the current database
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('DBSIZE');
   },

packages/client/lib/commands/DECR.ts

@@ -2,6 +2,11 @@ import { CommandParser } from '../client/parser';
 import { RedisArgument, NumberReply, Command } from '../RESP/types';
 
 export default {
+  /**
+   * Decrements the integer value of a key by one
+   * @param parser - The Redis command parser
+   * @param key - Key to decrement
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('DECR');
     parser.pushKey(key);

packages/client/lib/commands/DECRBY.ts

@@ -2,6 +2,12 @@ import { CommandParser } from '../client/parser';
 import { RedisArgument, NumberReply, Command } from '../RESP/types';
 
 export default {
+  /**
+   * Decrements the integer value of a key by the given number
+   * @param parser - The Redis command parser
+   * @param key - Key to decrement
+   * @param decrement - Decrement amount
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, decrement: number) {
     parser.push('DECRBY');
     parser.pushKey(key);

packages/client/lib/commands/DEL.ts

@@ -4,6 +4,11 @@ import { RedisVariadicArgument } from './generic-transformers';
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Removes the specified keys. A key is ignored if it does not exist
+   * @param parser - The Redis command parser
+   * @param keys - One or more keys to delete
+   */
   parseCommand(parser: CommandParser, keys: RedisVariadicArgument) {
     parser.push('DEL');
     parser.pushKeys(keys);

packages/client/lib/commands/DISCARD.ts

@@ -2,6 +2,10 @@ import { CommandParser } from '../client/parser';
 import { SimpleStringReply, Command } from '../RESP/types';
 
 export default {
+  /**
+   * Discards a transaction, forgetting all queued commands
+   * @param parser - The Redis command parser
+   */
   parseCommand(parser: CommandParser) {
     parser.push('DISCARD');
   },

packages/client/lib/commands/DUMP.ts

@@ -3,6 +3,11 @@ import { RedisArgument, BlobStringReply, Command } from '../RESP/types';
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns a serialized version of the value stored at the key
+   * @param parser - The Redis command parser
+   * @param key - Key to dump
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('DUMP');
     parser.pushKey(key);

packages/client/lib/commands/ECHO.ts

@@ -4,6 +4,11 @@ import { RedisArgument, BlobStringReply, Command } from '../RESP/types';
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: true,
+  /**
+   * Returns the given string
+   * @param parser - The Redis command parser
+   * @param message - Message to echo back
+   */
   parseCommand(parser: CommandParser, message: RedisArgument) {
     parser.push('ECHO', message);
   },

packages/client/lib/commands/EVAL.ts

@@ -25,6 +25,12 @@ export function parseEvalArguments(
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Executes a Lua script server side
+   * @param parser - The Redis command parser
+   * @param script - Lua script to execute
+   * @param options - Script execution options including keys and arguments
+   */
   parseCommand(...args: Parameters<typeof parseEvalArguments>) {
     args[0].push('EVAL');
     parseEvalArguments(...args);

packages/client/lib/commands/EVALSHA.ts

@@ -3,6 +3,12 @@ import EVAL, { parseEvalArguments } from './EVAL';
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Executes a Lua script server side using the script's SHA1 digest
+   * @param parser - The Redis command parser
+   * @param sha1 - SHA1 digest of the script
+   * @param options - Script execution options including keys and arguments
+   */
   parseCommand(...args: Parameters<typeof parseEvalArguments>) {
     args[0].push('EVALSHA');
     parseEvalArguments(...args);

packages/client/lib/commands/EVALSHA_RO.ts

@@ -3,6 +3,12 @@ import EVAL, { parseEvalArguments } from './EVAL';
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Executes a read-only Lua script server side using the script's SHA1 digest
+   * @param parser - The Redis command parser
+   * @param sha1 - SHA1 digest of the script
+   * @param options - Script execution options including keys and arguments
+   */
   parseCommand(...args: Parameters<typeof parseEvalArguments>) {
     args[0].push('EVALSHA_RO');
     parseEvalArguments(...args);

packages/client/lib/commands/EVAL_RO.ts

@@ -3,6 +3,12 @@ import EVAL, { parseEvalArguments } from './EVAL';
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Executes a read-only Lua script server side
+   * @param parser - The Redis command parser
+   * @param script - Lua script to execute
+   * @param options - Script execution options including keys and arguments
+   */
   parseCommand(...args: Parameters<typeof parseEvalArguments>) {
     args[0].push('EVAL_RO');
     parseEvalArguments(...args);

packages/client/lib/commands/EXISTS.ts

@@ -5,6 +5,11 @@ import { RedisVariadicArgument } from './generic-transformers';
 export default {
   CACHEABLE: true,
   IS_READ_ONLY: true,
+  /**
+   * Determines if the specified keys exist
+   * @param parser - The Redis command parser
+   * @param keys - One or more keys to check
+   */
   parseCommand(parser: CommandParser, keys: RedisVariadicArgument) {
     parser.push('EXISTS');
     parser.pushKeys(keys);

packages/client/lib/commands/EXPIRE.ts

@@ -3,6 +3,13 @@ import { RedisArgument, NumberReply, Command } from '../RESP/types';
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Sets a timeout on key. After the timeout has expired, the key will be automatically deleted
+   * @param parser - The Redis command parser
+   * @param key - Key to set expiration on
+   * @param seconds - Number of seconds until key expiration
+   * @param mode - Expiration mode: NX (only if key has no expiry), XX (only if key has existing expiry), GT (only if new expiry is greater than current), LT (only if new expiry is less than current)
+   */
   parseCommand(
     parser: CommandParser,
     key: RedisArgument,

packages/client/lib/commands/EXPIREAT.ts

@@ -4,6 +4,13 @@ import { transformEXAT } from './generic-transformers';
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Sets the expiration for a key at a specific Unix timestamp
+   * @param parser - The Redis command parser
+   * @param key - Key to set expiration on
+   * @param timestamp - Unix timestamp (seconds since January 1, 1970) or Date object
+   * @param mode - Expiration mode: NX (only if key has no expiry), XX (only if key has existing expiry), GT (only if new expiry is greater than current), LT (only if new expiry is less than current)
+   */
   parseCommand(
     parser: CommandParser,
     key: RedisArgument,

packages/client/lib/commands/EXPIRETIME.ts

@@ -3,6 +3,11 @@ import { RedisArgument, NumberReply, Command } from '../RESP/types';
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns the absolute Unix timestamp (since January 1, 1970) at which the given key will expire
+   * @param parser - The Redis command parser
+   * @param key - Key to check expiration time
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('EXPIRETIME');
     parser.pushKey(key);

packages/client/lib/commands/FAILOVER.ts

@@ -12,6 +12,11 @@ interface FailoverOptions {
 }
 
 export default {
+  /**
+   * Starts a coordinated failover between the primary and a replica
+   * @param parser - The Redis command parser
+   * @param options - Failover options including target host, abort flag, and timeout
+   */
   parseCommand(parser: CommandParser, options?: FailoverOptions) {
     parser.push('FAILOVER');
 

packages/client/lib/commands/FCALL.ts

@@ -3,6 +3,12 @@ import EVAL, { parseEvalArguments } from './EVAL';
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Invokes a Redis function
+   * @param parser - The Redis command parser
+   * @param functionName - Name of the function to call
+   * @param options - Function execution options including keys and arguments
+   */
   parseCommand(...args: Parameters<typeof parseEvalArguments>) {
     args[0].push('FCALL');
     parseEvalArguments(...args);

packages/client/lib/commands/FCALL_RO.ts

@@ -3,6 +3,12 @@ import EVAL, { parseEvalArguments } from './EVAL';
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Invokes a read-only Redis function
+   * @param parser - The Redis command parser
+   * @param functionName - Name of the function to call
+   * @param options - Function execution options including keys and arguments
+   */
   parseCommand(...args: Parameters<typeof parseEvalArguments>) {
     args[0].push('FCALL_RO');
     parseEvalArguments(...args);

packages/client/lib/commands/FLUSHALL.ts

@@ -11,6 +11,11 @@ export type RedisFlushMode = typeof REDIS_FLUSH_MODES[keyof typeof REDIS_FLUSH_M
 export default {
   NOT_KEYED_COMMAND: true,
   IS_READ_ONLY: false,
+  /**
+   * Removes all keys from all databases
+   * @param parser - The Redis command parser
+   * @param mode - Optional flush mode (ASYNC or SYNC)
+   */
   parseCommand(parser: CommandParser, mode?: RedisFlushMode) {
     parser.push('FLUSHALL');
     if (mode) {