(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/bloom/lib/commands/bloom/ADD.ts

@@ -4,6 +4,12 @@ import { transformBooleanReply } from '@redis/client/dist/lib/commands/generic-t
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Adds an item to a Bloom Filter
+   * @param parser - The command parser
+   * @param key - The name of the Bloom filter
+   * @param item - The item to add to the filter
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, item: RedisArgument) {
     parser.push('BF.ADD');
     parser.pushKey(key);

packages/bloom/lib/commands/bloom/CARD.ts

@@ -3,6 +3,11 @@ import { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns the cardinality (number of items) in a Bloom Filter
+   * @param parser - The command parser
+   * @param key - The name of the Bloom filter to query
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('BF.CARD');
     parser.pushKey(key);

packages/bloom/lib/commands/bloom/EXISTS.ts

@@ -4,6 +4,12 @@ import { transformBooleanReply } from '@redis/client/dist/lib/commands/generic-t
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Checks if an item exists in a Bloom Filter
+   * @param parser - The command parser
+   * @param key - The name of the Bloom filter
+   * @param item - The item to check for existence
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, item: RedisArgument) {
     parser.push('BF.EXISTS');
     parser.pushKey(key);

packages/bloom/lib/commands/bloom/INFO.ts

@@ -12,6 +12,11 @@ export type BfInfoReplyMap = TuplesToMapReply<[
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns information about a Bloom Filter, including capacity, size, number of filters, items inserted, and expansion rate
+   * @param parser - The command parser
+   * @param key - The name of the Bloom filter to get information about
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('BF.INFO');
     parser.pushKey(key);

packages/bloom/lib/commands/bloom/INSERT.ts

@@ -13,6 +13,18 @@ export interface BfInsertOptions {
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Adds one or more items to a Bloom Filter, creating it if it does not exist
+   * @param parser - The command parser
+   * @param key - The name of the Bloom filter
+   * @param items - One or more items to add to the filter
+   * @param options - Optional parameters for filter creation
+   * @param options.CAPACITY - Desired capacity for a new filter
+   * @param options.ERROR - Desired error rate for a new filter
+   * @param options.EXPANSION - Expansion rate for a new filter
+   * @param options.NOCREATE - If true, prevents automatic filter creation
+   * @param options.NONSCALING - Prevents the filter from creating additional sub-filters
+   */
   parseCommand(
     parser: CommandParser,
     key: RedisArgument,

packages/bloom/lib/commands/bloom/LOADCHUNK.ts

@@ -3,6 +3,13 @@ import { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/li
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Restores a Bloom Filter chunk previously saved using SCANDUMP
+   * @param parser - The command parser
+   * @param key - The name of the Bloom filter to restore
+   * @param iterator - Iterator value from the SCANDUMP command
+   * @param chunk - Data chunk from the SCANDUMP command
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, iterator: number, chunk: RedisArgument) {
     parser.push('BF.LOADCHUNK');
     parser.pushKey(key);

packages/bloom/lib/commands/bloom/MADD.ts

@@ -5,6 +5,12 @@ import { transformBooleanArrayReply } from '@redis/client/dist/lib/commands/gene
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Adds multiple items to a Bloom Filter in a single call
+   * @param parser - The command parser
+   * @param key - The name of the Bloom filter
+   * @param items - One or more items to add to the filter
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, items: RedisVariadicArgument) {
     parser.push('BF.MADD');
     parser.pushKey(key);

packages/bloom/lib/commands/bloom/MEXISTS.ts

@@ -5,6 +5,12 @@ import { transformBooleanArrayReply } from '@redis/client/dist/lib/commands/gene
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Checks if multiple items exist in a Bloom Filter in a single call
+   * @param parser - The command parser
+   * @param key - The name of the Bloom filter
+   * @param items - One or more items to check for existence
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, items: RedisVariadicArgument) {
     parser.push('BF.MEXISTS');
     parser.pushKey(key);

packages/bloom/lib/commands/bloom/RESERVE.ts

@@ -8,6 +8,16 @@ export interface BfReserveOptions {
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Creates an empty Bloom Filter with a given desired error ratio and initial capacity
+   * @param parser - The command parser
+   * @param key - The name of the Bloom filter to create
+   * @param errorRate - The desired probability for false positives (between 0 and 1)
+   * @param capacity - The number of entries intended to be added to the filter
+   * @param options - Optional parameters to tune the filter
+   * @param options.EXPANSION - Expansion rate for the filter
+   * @param options.NONSCALING - Prevents the filter from creating additional sub-filters
+   */
   parseCommand(
     parser: CommandParser,
     key: RedisArgument,

packages/bloom/lib/commands/bloom/SCANDUMP.ts

@@ -3,6 +3,12 @@ import { RedisArgument, TuplesReply, NumberReply, BlobStringReply, UnwrapReply,
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Begins an incremental save of a Bloom Filter. This is useful for large filters that can't be saved at once
+   * @param parser - The command parser
+   * @param key - The name of the Bloom filter to save
+   * @param iterator - Iterator value; Start at 0, and use the iterator from the response for the next chunk
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, iterator: number) {
     parser.push('BF.SCANDUMP');
     parser.pushKey(key);

packages/bloom/lib/commands/count-min-sketch/INCRBY.ts

@@ -8,6 +8,12 @@ export interface BfIncrByItem {
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Increases the count of one or more items in a Count-Min Sketch
+   * @param parser - The command parser
+   * @param key - The name of the sketch
+   * @param items - A single item or array of items to increment, each with an item and increment value
+   */
   parseCommand(
     parser: CommandParser,
     key: RedisArgument,

packages/bloom/lib/commands/count-min-sketch/INFO.ts

@@ -16,6 +16,11 @@ export interface CmsInfoReply {
  
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns width, depth, and total count of items in a Count-Min Sketch
+   * @param parser - The command parser
+   * @param key - The name of the sketch to get information about
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('CMS.INFO');
     parser.pushKey(key);

packages/bloom/lib/commands/count-min-sketch/INITBYDIM.ts

@@ -3,6 +3,13 @@ import { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/li
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Initialize a Count-Min Sketch using width and depth parameters
+   * @param parser - The command parser
+   * @param key - The name of the sketch
+   * @param width - Number of counters in each array (must be a multiple of 2)
+   * @param depth - Number of counter arrays (determines accuracy of estimates)
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, width: number, depth: number) {
     parser.push('CMS.INITBYDIM');
     parser.pushKey(key);

packages/bloom/lib/commands/count-min-sketch/INITBYPROB.ts

@@ -3,6 +3,13 @@ import { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/li
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Initialize a Count-Min Sketch using error rate and probability parameters
+   * @param parser - The command parser
+   * @param key - The name of the sketch
+   * @param error - Estimate error, as a decimal between 0 and 1
+   * @param probability - The desired probability for inflated count, as a decimal between 0 and 1
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, error: number, probability: number) {
     parser.push('CMS.INITBYPROB');
     parser.pushKey(key);

packages/bloom/lib/commands/count-min-sketch/MERGE.ts

@@ -10,6 +10,12 @@ export type BfMergeSketches = Array<RedisArgument> | Array<BfMergeSketch>;
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Merges multiple Count-Min Sketches into a single sketch, with optional weights
+   * @param parser - The command parser
+   * @param destination - The name of the destination sketch
+   * @param source - Array of sketch names or array of sketches with weights
+   */
   parseCommand(
     parser: CommandParser,
     destination: RedisArgument,

packages/bloom/lib/commands/count-min-sketch/QUERY.ts

@@ -4,6 +4,12 @@ import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-t
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns the count for one or more items in a Count-Min Sketch
+   * @param parser - The command parser
+   * @param key - The name of the sketch
+   * @param items - One or more items to get counts for
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, items: RedisVariadicArgument) {
     parser.push('CMS.QUERY');
     parser.pushKey(key);

packages/bloom/lib/commands/cuckoo/ADD.ts

@@ -4,6 +4,12 @@ import { transformBooleanReply } from '@redis/client/dist/lib/commands/generic-t
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Adds an item to a Cuckoo Filter, creating the filter if it does not exist
+   * @param parser - The command parser
+   * @param key - The name of the Cuckoo filter
+   * @param item - The item to add to the filter
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, item: RedisArgument) {
     parser.push('CF.ADD');
     parser.pushKey(key);

packages/bloom/lib/commands/cuckoo/ADDNX.ts

@@ -4,6 +4,12 @@ import { transformBooleanReply } from '@redis/client/dist/lib/commands/generic-t
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Adds an item to a Cuckoo Filter only if it does not exist
+   * @param parser - The command parser
+   * @param key - The name of the Cuckoo filter
+   * @param item - The item to add to the filter if it doesn't exist
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, item: RedisArgument) {
     parser.push('CF.ADDNX');
     parser.pushKey(key);

packages/bloom/lib/commands/cuckoo/COUNT.ts

@@ -3,6 +3,12 @@ import { RedisArgument, NumberReply, Command } from '@redis/client/dist/lib/RESP
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns the number of times an item appears in a Cuckoo Filter
+   * @param parser - The command parser
+   * @param key - The name of the Cuckoo filter
+   * @param item - The item to count occurrences of
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, item: RedisArgument) {
     parser.push('CF.COUNT');
     parser.pushKey(key);

packages/bloom/lib/commands/cuckoo/DEL.ts

@@ -4,6 +4,12 @@ import { transformBooleanReply } from '@redis/client/dist/lib/commands/generic-t
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Removes an item from a Cuckoo Filter if it exists
+   * @param parser - The command parser
+   * @param key - The name of the Cuckoo filter
+   * @param item - The item to remove from the filter
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, item: RedisArgument) {
     parser.push('CF.DEL');
     parser.pushKey(key);

packages/bloom/lib/commands/cuckoo/EXISTS.ts

@@ -4,6 +4,12 @@ import { transformBooleanReply } from '@redis/client/dist/lib/commands/generic-t
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Checks if an item exists in a Cuckoo Filter
+   * @param parser - The command parser
+   * @param key - The name of the Cuckoo filter
+   * @param item - The item to check for existence
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, item: RedisArgument) {
     parser.push('CF.EXISTS');
     parser.pushKey(key);

packages/bloom/lib/commands/cuckoo/INFO.ts

@@ -15,6 +15,11 @@ export type CfInfoReplyMap = TuplesToMapReply<[
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns detailed information about a Cuckoo Filter including size, buckets, filters count, items statistics and configuration
+   * @param parser - The command parser
+   * @param key - The name of the Cuckoo filter to get information about
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('CF.INFO');
     parser.pushKey(key);

packages/bloom/lib/commands/cuckoo/INSERT.ts

@@ -29,6 +29,15 @@ export function parseCfInsertArguments(
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Adds one or more items to a Cuckoo Filter, creating it if it does not exist
+   * @param parser - The command parser
+   * @param key - The name of the Cuckoo filter
+   * @param items - One or more items to add to the filter
+   * @param options - Optional parameters for filter creation
+   * @param options.CAPACITY - The number of entries intended to be added to the filter
+   * @param options.NOCREATE - If true, prevents automatic filter creation
+   */
   parseCommand(...args: Parameters<typeof parseCfInsertArguments>) {
     args[0].push('CF.INSERT');
     parseCfInsertArguments(...args);

packages/bloom/lib/commands/cuckoo/INSERTNX.ts

@@ -1,6 +1,15 @@
 import { Command } from '@redis/client/dist/lib/RESP/types';
 import INSERT, { parseCfInsertArguments } from './INSERT';
 
+/**
+ * Adds one or more items to a Cuckoo Filter only if they do not exist yet, creating the filter if needed
+ * @param parser - The command parser
+ * @param key - The name of the Cuckoo filter
+ * @param items - One or more items to add to the filter
+ * @param options - Optional parameters for filter creation
+ * @param options.CAPACITY - The number of entries intended to be added to the filter
+ * @param options.NOCREATE - If true, prevents automatic filter creation
+ */
 export default {
   IS_READ_ONLY: INSERT.IS_READ_ONLY,
   parseCommand(...args: Parameters<typeof parseCfInsertArguments>) {

packages/bloom/lib/commands/cuckoo/LOADCHUNK.ts

@@ -3,6 +3,13 @@ import { SimpleStringReply, Command, RedisArgument } from '@redis/client/dist/li
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Restores a Cuckoo Filter chunk previously saved using SCANDUMP
+   * @param parser - The command parser
+   * @param key - The name of the Cuckoo filter to restore
+   * @param iterator - Iterator value from the SCANDUMP command
+   * @param chunk - Data chunk from the SCANDUMP command
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, iterator: number, chunk: RedisArgument) {
     parser.push('CF.LOADCHUNK');
     parser.pushKey(key);

packages/bloom/lib/commands/cuckoo/RESERVE.ts

@@ -9,6 +9,16 @@ export interface CfReserveOptions {
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Creates an empty Cuckoo Filter with specified capacity and parameters
+   * @param parser - The command parser
+   * @param key - The name of the Cuckoo filter to create
+   * @param capacity - The number of entries intended to be added to the filter
+   * @param options - Optional parameters to tune the filter
+   * @param options.BUCKETSIZE - Number of items in each bucket
+   * @param options.MAXITERATIONS - Maximum number of iterations before declaring filter full
+   * @param options.EXPANSION - Number of additional buckets per expansion
+   */
   parseCommand(
     parser: CommandParser,
     key: RedisArgument,

packages/bloom/lib/commands/cuckoo/SCANDUMP.ts

@@ -3,6 +3,12 @@ import { RedisArgument, TuplesReply, NumberReply, BlobStringReply, NullReply, Un
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Begins an incremental save of a Cuckoo Filter. This is useful for large filters that can't be saved at once
+   * @param parser - The command parser
+   * @param key - The name of the Cuckoo filter to save
+   * @param iterator - Iterator value; Start at 0, and use the iterator from the response for the next chunk
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, iterator: number) {
     parser.push('CF.SCANDUMP');
     parser.pushKey(key);

packages/bloom/lib/commands/t-digest/ADD.ts

@@ -3,6 +3,12 @@ import { SimpleStringReply, Command, RedisArgument } from '@redis/client/dist/li
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Adds one or more observations to a t-digest sketch
+   * @param parser - The command parser
+   * @param key - The name of the t-digest sketch
+   * @param values - Array of numeric values to add to the sketch
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, values: Array<number>) {
     parser.push('TDIGEST.ADD');
     parser.pushKey(key);

packages/bloom/lib/commands/t-digest/BYRANK.ts

@@ -16,6 +16,12 @@ export function transformByRankArguments(
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns value estimates for one or more ranks in a t-digest sketch
+   * @param parser - The command parser
+   * @param key - The name of the t-digest sketch
+   * @param ranks - Array of ranks to get value estimates for (ascending order)
+   */
   parseCommand(...args: Parameters<typeof transformByRankArguments>) {
     args[0].push('TDIGEST.BYRANK');
     transformByRankArguments(...args);

packages/bloom/lib/commands/t-digest/BYREVRANK.ts

@@ -1,6 +1,12 @@
 import { Command } from '@redis/client/dist/lib/RESP/types';
 import BYRANK, { transformByRankArguments } from './BYRANK';
 
+/**
+ * Returns value estimates for one or more ranks in a t-digest sketch, starting from highest rank
+ * @param parser - The command parser
+ * @param key - The name of the t-digest sketch
+ * @param ranks - Array of ranks to get value estimates for (descending order)
+ */
 export default {
   IS_READ_ONLY: BYRANK.IS_READ_ONLY,
   parseCommand(...args: Parameters<typeof transformByRankArguments>) {

packages/bloom/lib/commands/t-digest/CDF.ts

@@ -4,6 +4,12 @@ import { transformDoubleArrayReply } from '@redis/client/dist/lib/commands/gener
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Estimates the cumulative distribution function for values in a t-digest sketch
+   * @param parser - The command parser
+   * @param key - The name of the t-digest sketch
+   * @param values - Array of values to get CDF estimates for
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, values: Array<number>) {
     parser.push('TDIGEST.CDF');
     parser.pushKey(key);

packages/bloom/lib/commands/t-digest/CREATE.ts

@@ -7,6 +7,13 @@ export interface TDigestCreateOptions {
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Creates a new t-digest sketch for storing distributions
+   * @param parser - The command parser
+   * @param key - The name of the t-digest sketch
+   * @param options - Optional parameters for sketch creation
+   * @param options.COMPRESSION - Compression parameter that affects performance and accuracy
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, options?: TDigestCreateOptions) {
     parser.push('TDIGEST.CREATE');
     parser.pushKey(key);

packages/bloom/lib/commands/t-digest/INFO.ts

@@ -16,6 +16,11 @@ export type TdInfoReplyMap = TuplesToMapReply<[
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns information about a t-digest sketch including compression, capacity, nodes, weights, observations and memory usage
+   * @param parser - The command parser
+   * @param key - The name of the t-digest sketch to get information about
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('TDIGEST.INFO');
     parser.pushKey(key);

packages/bloom/lib/commands/t-digest/MAX.ts

@@ -4,6 +4,11 @@ import { transformDoubleReply } from '@redis/client/dist/lib/commands/generic-tr
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns the maximum value from a t-digest sketch
+   * @param parser - The command parser
+   * @param key - The name of the t-digest sketch
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('TDIGEST.MAX');
     parser.pushKey(key);

packages/bloom/lib/commands/t-digest/MERGE.ts

@@ -9,6 +9,15 @@ export interface TDigestMergeOptions {
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Merges multiple t-digest sketches into one, with optional compression and override settings
+   * @param parser - The command parser
+   * @param destination - The name of the destination t-digest sketch
+   * @param source - One or more source sketch names to merge from
+   * @param options - Optional parameters for merge operation
+   * @param options.COMPRESSION - New compression value for merged sketch
+   * @param options.OVERRIDE - If true, override destination sketch if it exists
+   */
   parseCommand(
     parser: CommandParser,
     destination: RedisArgument,

packages/bloom/lib/commands/t-digest/MIN.ts

@@ -4,6 +4,11 @@ import { transformDoubleReply } from '@redis/client/dist/lib/commands/generic-tr
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns the minimum value from a t-digest sketch
+   * @param parser - The command parser
+   * @param key - The name of the t-digest sketch
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('TDIGEST.MIN');
     parser.pushKey(key);

packages/bloom/lib/commands/t-digest/QUANTILE.ts

@@ -4,6 +4,12 @@ import { transformDoubleArrayReply } from '@redis/client/dist/lib/commands/gener
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns value estimates at requested quantiles from a t-digest sketch
+   * @param parser - The command parser
+   * @param key - The name of the t-digest sketch
+   * @param quantiles - Array of quantiles (between 0 and 1) to get value estimates for
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, quantiles: Array<number>) {
     parser.push('TDIGEST.QUANTILE');
     parser.pushKey(key);

packages/bloom/lib/commands/t-digest/RANK.ts

@@ -15,6 +15,12 @@ export function transformRankArguments(
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns the rank of one or more values in a t-digest sketch (number of values that are lower than each value)
+   * @param parser - The command parser
+   * @param key - The name of the t-digest sketch
+   * @param values - Array of values to get ranks for
+   */
   parseCommand(...args: Parameters<typeof transformRankArguments>) {
     args[0].push('TDIGEST.RANK');
     transformRankArguments(...args);

packages/bloom/lib/commands/t-digest/RESET.ts

@@ -3,6 +3,11 @@ import { RedisArgument, SimpleStringReply, Command } from '@redis/client/dist/li
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Resets a t-digest sketch, clearing all previously added observations
+   * @param parser - The command parser
+   * @param key - The name of the t-digest sketch to reset
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('TDIGEST.RESET');
     parser.pushKey(key);

packages/bloom/lib/commands/t-digest/REVRANK.ts

@@ -1,6 +1,12 @@
 import { Command } from '@redis/client/dist/lib/RESP/types';
 import RANK, { transformRankArguments } from './RANK';
 
+/**
+ * Returns the reverse rank of one or more values in a t-digest sketch (number of values that are higher than each value)
+ * @param parser - The command parser
+ * @param key - The name of the t-digest sketch
+ * @param values - Array of values to get reverse ranks for
+ */
 export default {
   IS_READ_ONLY: RANK.IS_READ_ONLY,
   parseCommand(...args: Parameters<typeof transformRankArguments>) {

packages/bloom/lib/commands/t-digest/TRIMMED_MEAN.ts

@@ -4,6 +4,13 @@ import { transformDoubleReply } from '@redis/client/dist/lib/commands/generic-tr
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns the mean value from a t-digest sketch after trimming values at specified percentiles
+   * @param parser - The command parser
+   * @param key - The name of the t-digest sketch
+   * @param lowCutPercentile - Lower percentile cutoff (between 0 and 100)
+   * @param highCutPercentile - Higher percentile cutoff (between 0 and 100)
+   */
   parseCommand(
     parser: CommandParser,
     key: RedisArgument,

packages/bloom/lib/commands/top-k/ADD.ts

@@ -4,6 +4,12 @@ import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-t
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Adds one or more items to a Top-K filter and returns items dropped from the top-K list
+   * @param parser - The command parser
+   * @param key - The name of the Top-K filter
+   * @param items - One or more items to add to the filter
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, items: RedisVariadicArgument) {
     parser.push('TOPK.ADD');
     parser.pushKey(key);

packages/bloom/lib/commands/top-k/COUNT.ts

@@ -4,6 +4,12 @@ import { RedisVariadicArgument } from '@redis/client/dist/lib/commands/generic-t
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns the count of occurrences for one or more items in a Top-K filter
+   * @param parser - The command parser
+   * @param key - The name of the Top-K filter
+   * @param items - One or more items to get counts for
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, items: RedisVariadicArgument) {
     parser.push('TOPK.COUNT');
     parser.pushKey(key);

packages/bloom/lib/commands/top-k/INCRBY.ts

@@ -12,6 +12,12 @@ function pushIncrByItem(parser: CommandParser, { item, incrementBy }: TopKIncrBy
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Increases the score of one or more items in a Top-K filter by specified increments
+   * @param parser - The command parser
+   * @param key - The name of the Top-K filter
+   * @param items - A single item or array of items to increment, each with an item name and increment value
+   */
   parseCommand(
     parser: CommandParser,
     key: RedisArgument,

packages/bloom/lib/commands/top-k/INFO.ts

@@ -12,6 +12,11 @@ export type TopKInfoReplyMap = TuplesToMapReply<[
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns configuration and statistics of a Top-K filter, including k, width, depth, and decay parameters
+   * @param parser - The command parser
+   * @param key - The name of the Top-K filter to get information about
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('TOPK.INFO');
     parser.pushKey(key);

packages/bloom/lib/commands/top-k/LIST.ts

@@ -3,6 +3,11 @@ import { RedisArgument, ArrayReply, BlobStringReply, Command } from '@redis/clie
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns all items in a Top-K filter
+   * @param parser - The command parser
+   * @param key - The name of the Top-K filter
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('TOPK.LIST');
     parser.pushKey(key);

packages/bloom/lib/commands/top-k/LIST_WITHCOUNT.ts

@@ -3,6 +3,11 @@ import { RedisArgument, ArrayReply, BlobStringReply, NumberReply, UnwrapReply, C
 
 export default {
   IS_READ_ONLY: true,
+  /**
+   * Returns all items in a Top-K filter with their respective counts
+   * @param parser - The command parser
+   * @param key - The name of the Top-K filter
+   */
   parseCommand(parser: CommandParser, key: RedisArgument) {
     parser.push('TOPK.LIST');
     parser.pushKey(key);

packages/bloom/lib/commands/top-k/QUERY.ts

@@ -4,6 +4,12 @@ import { RedisVariadicArgument, transformBooleanArrayReply } from '@redis/client
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Checks if one or more items are in the Top-K list
+   * @param parser - The command parser
+   * @param key - The name of the Top-K filter
+   * @param items - One or more items to check in the filter
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, items: RedisVariadicArgument) {
     parser.push('TOPK.QUERY');
     parser.pushKey(key);

packages/bloom/lib/commands/top-k/RESERVE.ts

@@ -9,6 +9,16 @@ export interface TopKReserveOptions {
 
 export default {
   IS_READ_ONLY: false,
+  /**
+   * Creates a new Top-K filter with specified parameters
+   * @param parser - The command parser
+   * @param key - The name of the Top-K filter
+   * @param topK - Number of top occurring items to keep
+   * @param options - Optional parameters for filter configuration
+   * @param options.width - Number of counters in each array
+   * @param options.depth - Number of counter-arrays
+   * @param options.decay - Counter decay factor
+   */
   parseCommand(parser: CommandParser, key: RedisArgument, topK: number, options?: TopKReserveOptions) {
     parser.push('TOPK.RESERVE');
     parser.pushKey(key);

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);