add buffer support to a bunch of commands

packages/client/lib/commands/APPEND.ts

@@ -1,7 +1,12 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 1;
 
-export function transformArguments(key: string, value: string): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    value: RedisCommandArgument
+): RedisCommandArguments {
     return ['APPEND', key, value];
 }
 
-export declare function transformReply(): string;
+export declare function transformReply(): number;

packages/client/lib/commands/BLMOVE.ts

@@ -1,14 +1,15 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 import { LMoveSide } from './LMOVE';
 
 export const FIRST_KEY_INDEX = 1;
 
 export function transformArguments(
-    source: string,
-    destination: string,
+    source: RedisCommandArgument,
+    destination: RedisCommandArgument,
     sourceDirection: LMoveSide,
     destinationDirection: LMoveSide,
     timeout: number
-): Array<string> {
+): RedisCommandArguments {
     return [
         'BLMOVE',
         source,

packages/client/lib/commands/BLMOVE_BUFFER.ts

@@ -0,0 +1,5 @@
+export { FIRST_KEY_INDEX, transformArguments } from './BLMOVE';
+
+export const BUFFER_MODE = true;
+
+export declare function transformReply(): Buffer | null;

packages/client/lib/commands/BLPOP.ts

@@ -1,9 +1,12 @@
-import { RedisCommandArguments } from '.';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 import { pushVerdictArguments } from './generic-transformers';
 
 export const FIRST_KEY_INDEX = 1;
 
-export function transformArguments(keys: string | Buffer | Array<string | Buffer>, timeout: number): RedisCommandArguments {
+export function transformArguments(
+    keys: RedisCommandArgument | Array<RedisCommandArgument>,
+    timeout: number
+): RedisCommandArguments {
     const args = pushVerdictArguments(['BLPOP'], keys);
 
     args.push(timeout.toString());
@@ -11,12 +14,12 @@ export function transformArguments(keys: string | Buffer | Array<string | Buffer
     return args;
 }
 
-type BLPOPReply = null | {
+type BLPopReply = null | {
     key: string;
     element: string;
 };
 
-export function transformReply(reply: null | [string, string]): BLPOPReply {
+export function transformReply(reply: null | [string, string]): BLPopReply {
     if (reply === null) return null;
 
     return {

packages/client/lib/commands/BLPOP_BUFFER.ts

@@ -0,0 +1,17 @@
+export { FIRST_KEY_INDEX, transformArguments } from './BLPOP';
+
+export const BUFFER_MODE = true;
+
+type BLPopBufferReply = null | {
+    key: Buffer;
+    element: Buffer;
+};
+
+export function transformReply(reply: null | [Buffer, Buffer]): BLPopBufferReply {
+    if (reply === null) return null;
+
+    return {
+        key: reply[0],
+        element: reply[1]
+    };
+}

packages/client/lib/commands/BRPOP.ts

@@ -11,16 +11,4 @@ export function transformArguments(key: string | Array<string>, timeout: number)
     return args;
 }
 
-type BRPOPReply = null | {
-    key: string;
-    element: string;
-};
-
-export function transformReply(reply: null | [string, string]): BRPOPReply {
-    if (reply === null) return null;
-
-    return {
-        key: reply[0],
-        element: reply[1]
-    };
-}
+export { transformReply } from './BLPOP';

packages/client/lib/commands/BRPOPLPUSH.ts

@@ -1,7 +1,13 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 1;
 
-export function transformArguments(source: string, destination: string, timeout: number): Array<string> {
+export function transformArguments(
+    source: RedisCommandArgument,
+    destination: RedisCommandArgument,
+    timeout: number
+): RedisCommandArguments {
     return ['BRPOPLPUSH', source, destination, timeout.toString()];
 }
 
-export declare function transformReply(): number | null;
+export declare function transformReply(): string | null;

packages/client/lib/commands/BRPOPLPUSH_BUFFER.ts

@@ -0,0 +1,5 @@
+export { FIRST_KEY_INDEX, transformArguments } from './BRPOPLPUSH';
+
+export const BUFFER_MODE = true;
+
+export declare function transformReply(): Buffer | null;

packages/client/lib/commands/BRPOP_BUFFER.ts

@@ -0,0 +1,3 @@
+export { FIRST_KEY_INDEX, transformArguments } from './BRPOP';
+
+export { BUFFER_MODE, transformReply } from './BLPOP_BUFFER';

packages/client/lib/commands/BZPOPMAX.ts

@@ -1,9 +1,12 @@
-import { RedisCommandArguments } from '.';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 import { pushVerdictArguments, transformReplyNumberInfinity, ZMember } from './generic-transformers';
 
 export const FIRST_KEY_INDEX = 1;
 
-export function transformArguments(key: string | Array<string>, timeout: number): RedisCommandArguments {
+export function transformArguments(
+    key: RedisCommandArgument | Array<RedisCommandArgument>,
+    timeout: number
+): RedisCommandArguments {
     const args = pushVerdictArguments(['BZPOPMAX'], key);
 
     args.push(timeout.toString());
@@ -11,7 +14,7 @@ export function transformArguments(key: string | Array<string>, timeout: number)
     return args;
 }
 
-interface ZMemberWithKey extends ZMember {
+interface ZMemberWithKey extends ZMember<string> {
     key: string;
 }
 

packages/client/lib/commands/BZPOPMIN.ts

@@ -11,7 +11,7 @@ export function transformArguments(key: string | Array<string>, timeout: number)
     return args;
 }
 
-interface ZMemberWithKey extends ZMember {
+interface ZMemberWithKey extends ZMember<string> {
     key: string;
 }
 

packages/client/lib/commands/CONFIG_GET.ts

@@ -2,4 +2,4 @@ export function transformArguments(parameter: string): Array<string> {
     return ['CONFIG', 'GET', parameter];
 }
 
-export { transformReplyTuples as transformReply } from './generic-transformers';
+export { transformReplyStringTuples as transformReply } from './generic-transformers';

packages/client/lib/commands/GET.ts

@@ -1,10 +1,10 @@
-import { RedisCommandArguments } from '.';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 
 export const FIRST_KEY_INDEX = 1;
 
 export const IS_READ_ONLY = true;
 
-export function transformArguments(key: string | Buffer): RedisCommandArguments {
+export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
     return ['GET', key];
 }
 

packages/client/lib/commands/HGET.ts

@@ -1,9 +1,14 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 1;
 
-export function transformArguments(key: string, field: string): Array<string> {
+export const IS_READ_ONLY = true;
+
+export function transformArguments(
+    key: RedisCommandArgument,
+    field: RedisCommandArgument
+): RedisCommandArguments {
     return ['HGET', key, field];
 }
 
-export function transformReply(reply?: string): string | undefined {
-    return reply;
-}
+export declare function transformReply(): string | undefined;

packages/client/lib/commands/HGETALL.ts

@@ -1,7 +1,9 @@
 export const FIRST_KEY_INDEX = 1;
 
+export const IS_READ_ONLY = true;
+
 export function transformArguments(key: string): Array<string> {
     return ['HGETALL', key];
 }
 
-export { transformReplyTuples as transformReply } from './generic-transformers';
+export { transformReplyStringTuples as transformReply } from './generic-transformers';

packages/client/lib/commands/HGETALL_BUFFER.ts

@@ -0,0 +1,5 @@
+export { FIRST_KEY_INDEX, IS_READ_ONLY, transformArguments } from './HGETALL';
+
+export const BUFFER_MODE = true;
+
+export { transformReplyBufferTuples as transformReply } from './generic-transformers';

packages/client/lib/commands/HGET_BUFFER.ts

@@ -0,0 +1,5 @@
+export { FIRST_KEY_INDEX, IS_READ_ONLY, transformArguments } from './HGET';
+
+export const BUFFER_MODE = true;
+
+export declare function transformReply(): Buffer | undefined;

packages/client/lib/commands/HRANDFIELD.ts

@@ -1,5 +1,7 @@
 export const FIRST_KEY_INDEX = 1;
 
+export const IS_READ_ONLY = true;
+
 export function transformArguments(key: string): Array<string> {
     return ['HRANDFIELD', key];
 }

packages/client/lib/commands/HRANDFIELD_COUNT.ts

@@ -1,6 +1,6 @@
 import { transformArguments as transformHRandFieldArguments } from './HRANDFIELD';
 
-export { FIRST_KEY_INDEX } from './HRANDFIELD';
+export { FIRST_KEY_INDEX, IS_READ_ONLY } from './HRANDFIELD';
 
 export function transformArguments(key: string, count: number): Array<string> {
     return [

packages/client/lib/commands/HRANDFIELD_COUNT_WITHVALUES.ts

@@ -1,6 +1,6 @@
 import { transformArguments as transformHRandFieldCountArguments } from './HRANDFIELD_COUNT';
 
-export { FIRST_KEY_INDEX } from './HRANDFIELD_COUNT';
+export { FIRST_KEY_INDEX, IS_READ_ONLY } from './HRANDFIELD_COUNT';
 
 export function transformArguments(key: string, count: number): Array<string> {
     return [
@@ -9,4 +9,4 @@ export function transformArguments(key: string, count: number): Array<string> {
     ];
 }
 
-export { transformReplyTuples as transformReply } from './generic-transformers';
+export { transformReplyStringTuples as transformReply } from './generic-transformers';

packages/client/lib/commands/HRANDFIELD_COUNT_WITHVALUES_BUFFER.ts

@@ -0,0 +1,5 @@
+export { FIRST_KEY_INDEX, IS_READ_ONLY, transformArguments } from './HRANDFIELD_COUNT';
+
+export const BUFFER_MODE = true;
+
+export { transformReplyBufferTuples as transformReply } from './generic-transformers';

packages/client/lib/commands/HSET.ts

@@ -1,4 +1,4 @@
-import { RedisCommandArguments } from '.';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 
 type Types = string | number | Buffer;
 
@@ -10,7 +10,7 @@ type HSETTuples = Array<[Types, Types]> | Array<Types>;
 
 export const FIRST_KEY_INDEX = 1;
 
-type GenericArguments = [key: string | Buffer];
+type GenericArguments = [key: RedisCommandArgument];
 
 type SingleFieldArguments = [...generic: GenericArguments, field: Types, value: Types];
 

packages/client/lib/commands/PUBLISH.ts

@@ -1,6 +1,9 @@
-import { RedisCommandArguments } from '.';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 
-export function transformArguments(channel: string | Buffer, message: string | Buffer): RedisCommandArguments {
+export function transformArguments(
+    channel: RedisCommandArgument,
+    message: RedisCommandArgument
+): RedisCommandArguments {
     return ['PUBLISH', channel, message];
 }
 

packages/client/lib/commands/SET.ts

@@ -1,4 +1,4 @@
-import { RedisCommandArguments } from '.';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 
 export const FIRST_KEY_INDEX = 1;
 
@@ -24,7 +24,11 @@ interface SetCommonOptions {
 
 type SetOptions = SetTTL & SetGuards & SetCommonOptions;
 
-export function transformArguments(key: string | Buffer, value: string | number | Buffer, options?: SetOptions): RedisCommandArguments {
+export function transformArguments(
+    key: RedisCommandArgument,
+    value: RedisCommandArgument | number,
+    options?: SetOptions
+): RedisCommandArguments {
     const args = [
         'SET',
         key,

packages/client/lib/commands/SETEX.ts

@@ -1,8 +1,12 @@
-import { RedisCommandArguments } from '.';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 
 export const FIRST_KEY_INDEX = 1;
 
-export function transformArguments(key: string | Buffer, seconds: number, value: string): RedisCommandArguments {
+export function transformArguments(
+    key: RedisCommandArgument,
+    seconds: number,
+    value: string
+): RedisCommandArguments {
     return [
         'SETEX',
         key,

packages/client/lib/commands/XACK.ts

@@ -1,9 +1,13 @@
-import { RedisCommandArguments } from '.';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 import { pushVerdictArguments } from './generic-transformers';
 
 export const FIRST_KEY_INDEX = 1;
 
-export function transformArguments(key: string, group: string, id: string | Array<string>): RedisCommandArguments {
+export function transformArguments(
+    key: RedisCommandArgument,
+    group: RedisCommandArgument,
+    id: RedisCommandArgument | Array<RedisCommandArgument>
+): RedisCommandArguments {
     return pushVerdictArguments(['XACK', key, group], id);
 }
 

packages/client/lib/commands/XADD.ts

@@ -1,4 +1,4 @@
-import { TuplesObject } from './generic-transformers';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 
 export const FIRST_KEY_INDEX = 1;
 
@@ -9,10 +9,15 @@ interface XAddOptions {
         strategyModifier?: '=' | '~';
         threshold: number;
         limit?: number;
-    }
+    };
 }
 
-export function transformArguments(key: string, id: string, message: TuplesObject, options?: XAddOptions): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    id: RedisCommandArgument,
+    message: Record<string, RedisCommandArgument>,
+    options?: XAddOptions
+): RedisCommandArguments {
     const args = ['XADD', key];
 
     if (options?.NOMKSTREAM) {

packages/client/lib/commands/XAUTOCLAIM.ts

@@ -1,4 +1,5 @@
-import { StreamMessagesReply, transformReplyStreamMessages } from './generic-transformers';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+import { StreamStringsMessagesReply, transformReplyStreamStringMessages } from './generic-transformers';
 
 export const FIRST_KEY_INDEX = 1;
 
@@ -7,13 +8,13 @@ export interface XAutoClaimOptions {
 }
 
 export function transformArguments(
-    key: string,
-    group: string,
-    consumer: string,
+    key: RedisCommandArgument,
+    group: RedisCommandArgument,
+    consumer: RedisCommandArgument,
     minIdleTime: number,
     start: string,
     options?: XAutoClaimOptions
-): Array<string> {
+): RedisCommandArguments {
     const args = ['XAUTOCLAIM', key, group, consumer, minIdleTime.toString(), start];
 
     if (options?.COUNT) {
@@ -25,12 +26,12 @@ export function transformArguments(
 
 interface XAutoClaimReply {
     nextId: string;
-    messages: StreamMessagesReply;
+    messages: StreamStringsMessagesReply;
 }
 
 export function transformReply(reply: [string, Array<any>]): XAutoClaimReply {
     return {
         nextId: reply[0],
-        messages: transformReplyStreamMessages(reply[1])
+        messages: transformReplyStreamStringMessages(reply[1])
     };
 }

packages/client/lib/commands/XAUTOCLAIM_BUFFER.ts

@@ -0,0 +1,17 @@
+import { StreamBufferMessagesReply, transformReplyStreamBufferMessages } from './generic-transformers';
+
+export { FIRST_KEY_INDEX, transformArguments } from './XAUTOCLAIM';
+
+export const BUFFER_MODE = true;
+
+interface XAutoClaimReply {
+    nextId: Buffer;
+    messages: StreamBufferMessagesReply;
+}
+
+export function transformReply(reply: [Buffer, Array<any>]): XAutoClaimReply {
+    return {
+        nextId: reply[0],
+        messages: transformReplyStreamBufferMessages(reply[1])
+    };
+}

packages/client/lib/commands/XAUTOCLAIM_JUSTID.ts

@@ -1,8 +1,9 @@
+import { RedisCommandArguments } from '.';
 import { transformArguments as transformXAutoClaimArguments } from './XAUTOCLAIM';
 
 export { FIRST_KEY_INDEX } from './XAUTOCLAIM';
 
-export function transformArguments(...args: Parameters<typeof transformXAutoClaimArguments>): Array<string> {
+export function transformArguments(...args: Parameters<typeof transformXAutoClaimArguments>): RedisCommandArguments {
     return [
         ...transformXAutoClaimArguments(...args),
         'JUSTID'

packages/client/lib/commands/XAUTOCLAIM_JUSTID_BUFFER.ts

@@ -0,0 +1,13 @@
+export { FIRST_KEY_INDEX, transformArguments } from './XAUTOCLAIM_JUSTID';
+
+interface XAutoClaimJustIdBufferReply {
+    nextId: Buffer;
+    messages: Array<Buffer>;
+}
+
+export function transformReply(reply: [Buffer, Array<Buffer>]): XAutoClaimJustIdBufferReply {
+    return {
+        nextId: reply[0],
+        messages: reply[1]
+    };
+}

packages/client/lib/commands/XCLAIM.ts

@@ -1,3 +1,4 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 import { pushVerdictArguments } from './generic-transformers';
 
 export const FIRST_KEY_INDEX = 1;
@@ -10,13 +11,13 @@ export interface XClaimOptions {
 }
 
 export function transformArguments(
-    key: string,
-    group: string,
-    consumer: string,
+    key: RedisCommandArgument,
+    group: RedisCommandArgument,
+    consumer: RedisCommandArgument,
     minIdleTime: number,
-    id: string | Array<string>,
+    id: RedisCommandArgument | Array<RedisCommandArgument>,
     options?: XClaimOptions
-): Array<string> {
+): RedisCommandArguments {
     const args = ['XCLAIM', key, group, consumer, minIdleTime.toString()];
 
     pushVerdictArguments(args, id);
@@ -43,4 +44,4 @@ export function transformArguments(
     return args;
 }
 
-export { transformReplyStreamMessages as transformReply } from './generic-transformers';
+export { transformReplyStreamStringMessages as transformReply } from './generic-transformers';

packages/client/lib/commands/XCLAIM_BUFFER.ts

@@ -0,0 +1,5 @@
+export { FIRST_KEY_INDEX, transformArguments } from './XCLAIM';
+
+export const BUFFER_MODE = true;
+
+export { transformReplyStreamBufferMessages as transformReply } from './generic-transformers';

packages/client/lib/commands/XCLAIM_JUSTID.ts

@@ -1,10 +1,11 @@
-import { transformArguments as transformArgumentsXClaim } from './XCLAIM';
+import { RedisCommandArguments } from '.';
+import { transformArguments as transformXClaimArguments } from './XCLAIM';
 
 export { FIRST_KEY_INDEX } from './XCLAIM';
 
-export function transformArguments(...args: Parameters<typeof transformArgumentsXClaim>): Array<string> {
+export function transformArguments(...args: Parameters<typeof transformXClaimArguments>): RedisCommandArguments {
     return [
-        ...transformArgumentsXClaim(...args),
+        ...transformXClaimArguments(...args),
         'JUSTID'
     ];
 }

packages/client/lib/commands/XCLAIM_JUSTID_BUFFER.ts

@@ -0,0 +1,5 @@
+export { FIRST_KEY_INDEX, transformArguments } from './XCLAIM_JUSTID';
+
+export const BUFFER_MODE = true;
+
+export declare function transformReply(): Array<Buffer>;

packages/client/lib/commands/XDEL.ts

@@ -1,9 +1,12 @@
-import { RedisCommandArguments } from '.';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 import { pushVerdictArguments } from './generic-transformers';
 
 export const FIRST_KEY_INDEX = 1;
 
-export function transformArguments(key: string, id: string | Array<string>): RedisCommandArguments {
+export function transformArguments(
+    key: RedisCommandArgument,
+    id: RedisCommandArgument | Array<RedisCommandArgument>
+): RedisCommandArguments {
     return pushVerdictArguments(['XDEL', key], id);
 }
 

packages/client/lib/commands/XGROUP_CREATE.ts

@@ -1,10 +1,17 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 2;
 
 interface XGroupCreateOptions {
     MKSTREAM?: true;
 }
 
-export function transformArguments(key: string, group: string, id: string, options?: XGroupCreateOptions): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    group: RedisCommandArgument,
+    id: RedisCommandArgument,
+    options?: XGroupCreateOptions
+): RedisCommandArguments {
     const args = ['XGROUP', 'CREATE', key, group, id];
 
     if (options?.MKSTREAM) {
@@ -14,4 +21,4 @@ export function transformArguments(key: string, group: string, id: string, optio
     return args;
 }
 
-export declare function transformReply(): string;
+export declare function transformReply(): 'OK';

packages/client/lib/commands/XGROUP_CREATECONSUMER.ts

@@ -1,6 +1,12 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 2;
 
-export function transformArguments(key: string, group: string, consumer: string): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    group: RedisCommandArgument,
+    consumer: RedisCommandArgument
+): RedisCommandArguments {
     return ['XGROUP', 'CREATECONSUMER', key, group, consumer];
 }
 

packages/client/lib/commands/XGROUP_DELCONSUMER.ts

@@ -1,6 +1,12 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 2;
 
-export function transformArguments(key: string, group: string, consumer: string): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    group: RedisCommandArgument,
+    consumer: RedisCommandArgument
+): RedisCommandArguments {
     return ['XGROUP', 'DELCONSUMER', key, group, consumer];
 }
 

packages/client/lib/commands/XGROUP_DESTROY.ts

@@ -1,6 +1,11 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 2;
 
-export function transformArguments(key: string, group: string): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    group: RedisCommandArgument
+): RedisCommandArguments {
     return ['XGROUP', 'DESTROY', key, group];
 }
 

packages/client/lib/commands/XGROUP_SETID.ts

@@ -1,7 +1,13 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 2;
 
-export function transformArguments(key: string, group: string, id: string): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    group: RedisCommandArgument,
+    id: RedisCommandArgument
+): RedisCommandArguments {
     return ['XGROUP', 'SETID', key, group, id];
 }
 
-export declare function transformReply(): string;
+export declare function transformReply(): 'OK';

packages/client/lib/commands/XINFO_CONSUMERS.ts

@@ -1,8 +1,13 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 2;
 
 export const IS_READ_ONLY = true;
 
-export function transformArguments(key: string, group: string): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    group: RedisCommandArgument
+): RedisCommandArguments {
     return ['XINFO', 'CONSUMERS', key, group];
 }
 

packages/client/lib/commands/XINFO_GROUPS.ts

@@ -1,8 +1,10 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 2;
 
 export const IS_READ_ONLY = true;
 
-export function transformArguments(key: string): Array<string> {
+export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
     return ['XINFO', 'GROUPS', key];
 }
 

packages/client/lib/commands/XINFO_STREAM.ts

@@ -1,10 +1,11 @@
-import { StreamMessageReply, transformReplyTuples } from './generic-transformers';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+import { StreamStringsMessageReply, transformReplyStringTuples } from './generic-transformers';
 
 export const FIRST_KEY_INDEX = 2;
 
 export const IS_READ_ONLY = true;
 
-export function transformArguments(key: string): Array<string> {
+export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
     return ['XINFO', 'STREAM', key];
 }
 
@@ -14,8 +15,8 @@ interface XInfoStreamReply {
     radixTreeNodes: number;
     groups: number;
     lastGeneratedId: string;
-    firstEntry: StreamMessageReply | null;
-    lastEntry: StreamMessageReply | null;
+    firstEntry: StreamStringsMessageReply | null;
+    lastEntry: StreamStringsMessageReply | null;
 }
 
 export function transformReply(rawReply: Array<any>): XInfoStreamReply {
@@ -46,14 +47,14 @@ export function transformReply(rawReply: Array<any>): XInfoStreamReply {
             case 'first-entry':
                 parsedReply.firstEntry = rawReply[i + 1] ? {
                     id: rawReply[i + 1][0],
-                    message: transformReplyTuples(rawReply[i + 1][1])
+                    message: transformReplyStringTuples(rawReply[i + 1][1])
                 } : null;
                 break;
 
             case 'last-entry':
                 parsedReply.lastEntry = rawReply[i + 1] ? {
                     id: rawReply[i + 1][0],
-                    message: transformReplyTuples(rawReply[i + 1][1])
+                    message: transformReplyStringTuples(rawReply[i + 1][1])
                 } : null;
                 break;
         }

packages/client/lib/commands/XLEN.ts

@@ -1,8 +1,10 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 1;
 
 export const IS_READ_ONLY = true;
 
-export function transformArguments(key: string): Array<string> {
+export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
     return ['XLEN', key];
 }
 

packages/client/lib/commands/XPENDING.ts

@@ -1,23 +1,44 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 1;
 
 export const IS_READ_ONLY = true;
 
-export function transformArguments(key: string, group: string): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    group: RedisCommandArgument
+): RedisCommandArguments {
     return ['XPENDING', key, group];
 }
 
+type XPendingRawReply = [
+    pending: number,
+    firstId: string | null,
+    lastId: string | null,
+    consumers: Array<[
+        name: string,
+        deliveriesCounter: number
+    ]> | null
+]
+
 interface XPendingReply {
     pending: number;
     firstId: string | null;
-    lastId: number | null
-    consumers: Array<string> | null;
+    lastId: string | null
+    consumers: Array<{
+        name: string,
+        deliveriesCounter: number
+    }> | null;
 }
 
-export function transformReply(reply: [number, string | null, number | null, Array<string> | null]): XPendingReply {
+export function transformReply(reply: XPendingRawReply): XPendingReply {
     return {
         pending: reply[0],
         firstId: reply[1],
         lastId: reply[2],
-        consumers: reply[3]
+        consumers: reply[3] === null ? null : reply[3].map(([name, deliveriesCounter]) => ({
+            name,
+            deliveriesCounter
+        }))
     };
 }

packages/client/lib/commands/XPENDING_RANGE.ts

@@ -1,3 +1,5 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 1;
 
 export const IS_READ_ONLY = true;
@@ -8,13 +10,13 @@ interface XPendingRangeOptions {
 }
 
 export function transformArguments(
-    key: string,
-    group: string,
+    key: RedisCommandArgument,
+    group: RedisCommandArgument,
     start: string,
     end: string,
     count: number,
     options?: XPendingRangeOptions
-): Array<string> {
+): RedisCommandArguments {
     const args = ['XPENDING', key, group];
 
     if (options?.IDLE) {
@@ -30,4 +32,25 @@ export function transformArguments(
     return args;
 }
 
-export { transformReplyStreamMessages as transformReply } from './generic-transformers';
+type XPendingRangeRawReply = Array<[
+    id: number,
+    consumer: string,
+    millisecondsSinceLastDelivery: number,
+    deliveriesCounter: number
+]>;
+
+type XPendingRangeReply = Array<{
+    id: number;
+    owner: string;
+    millisecondsSinceLastDelivery: number;
+    deliveriesCounter: number;
+}>;
+
+export function transformReply(reply: XPendingRangeRawReply): XPendingRangeReply {
+    return reply.map(([id, owner, millisecondsSinceLastDelivery, deliveriesCounter]) => ({
+        id,
+        owner,
+        millisecondsSinceLastDelivery,
+        deliveriesCounter
+    }));
+}

packages/client/lib/commands/XRANGE.ts

@@ -1,3 +1,5 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 1;
 
 export const IS_READ_ONLY = true;
@@ -6,7 +8,12 @@ interface XRangeOptions {
     COUNT?: number;
 }
 
-export function transformArguments(key: string, start: string, end: string, options?: XRangeOptions): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    start: RedisCommandArgument,
+    end: RedisCommandArgument,
+    options?: XRangeOptions
+): RedisCommandArguments {
     const args = ['XRANGE', key, start, end];
 
     if (options?.COUNT) {
@@ -16,4 +23,4 @@ export function transformArguments(key: string, start: string, end: string, opti
     return args;
 }
 
-export { transformReplyStreamMessages as transformReply } from './generic-transformers';
+export { transformReplyStreamStringMessages as transformReply } from './generic-transformers';

packages/client/lib/commands/XRANGE_BUFFER.ts

@@ -0,0 +1,5 @@
+export { FIRST_KEY_INDEX, IS_READ_ONLY, transformArguments } from './XRANGE';
+
+export const BUFFER_MODE = true;
+
+export { transformReplyStreamBufferMessages as transformReply } from './generic-transformers';

packages/client/lib/commands/XREAD.ts

@@ -1,12 +1,14 @@
-export const FIRST_KEY_INDEX = (streams: Array<XReadStream> | XReadStream): string => {
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
+export const FIRST_KEY_INDEX = (streams: Array<XReadStream> | XReadStream): RedisCommandArgument => {
     return Array.isArray(streams) ? streams[0].key : streams.key;
 };
 
 export const IS_READ_ONLY = true;
 
 interface XReadStream {
-    key: string;
-    id: string;
+    key: RedisCommandArgument;
+    id: RedisCommandArgument;
 }
 
 interface XReadOptions {
@@ -14,8 +16,11 @@ interface XReadOptions {
     BLOCK?: number;
 }
 
-export function transformArguments(streams: Array<XReadStream> | XReadStream, options?: XReadOptions): Array<string> {
-    const args = ['XREAD'];
+export function transformArguments(
+    streams: Array<XReadStream> | XReadStream,
+    options?: XReadOptions
+): RedisCommandArguments {
+    const args: RedisCommandArguments = ['XREAD'];
 
     if (options?.COUNT) {
         args.push('COUNT', options.COUNT.toString());
@@ -38,4 +43,4 @@ export function transformArguments(streams: Array<XReadStream> | XReadStream, op
     return args;
 }
 
-export { transformReplyStreamsMessages as transformReply } from './generic-transformers';
+export { transformReplyStreamsStringMessages as transformReply } from './generic-transformers';

packages/client/lib/commands/XREADGROUP.ts

@@ -1,6 +1,8 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export interface XReadGroupStream {
-    key: string;
-    id: string;
+    key: RedisCommandArgument;
+    id: RedisCommandArgument;
 }
 
 export interface XReadGroupOptions {
@@ -10,21 +12,21 @@ export interface XReadGroupOptions {
 }
 
 export const FIRST_KEY_INDEX = (
-    _group: string,
-    _consumer: string,
+    _group: RedisCommandArgument,
+    _consumer: RedisCommandArgument,
     streams: Array<XReadGroupStream> | XReadGroupStream
-): string => {
+): RedisCommandArgument => {
     return Array.isArray(streams) ? streams[0].key : streams.key;
 };
 
 export const IS_READ_ONLY = true;
 
 export function transformArguments(
-    group: string,
-    consumer: string,
+    group: RedisCommandArgument,
+    consumer: RedisCommandArgument,
     streams: Array<XReadGroupStream> | XReadGroupStream,
     options?: XReadGroupOptions
-): Array<string> {
+): RedisCommandArguments {
     const args = ['XREADGROUP', 'GROUP', group, consumer];
 
     if (options?.COUNT) {
@@ -52,4 +54,4 @@ export function transformArguments(
     return args;
 }
 
-export { transformReplyStreamsMessages as transformReply } from './generic-transformers';
+export { transformReplyStreamsStringMessages as transformReply } from './generic-transformers';

packages/client/lib/commands/XREADGROUP_BUFFER.ts

@@ -0,0 +1,6 @@
+
+export { FIRST_KEY_INDEX, IS_READ_ONLY, transformArguments } from './XREADGROUP';
+
+export const BUFFER_MODE = true;
+
+export { transformReplyStreamsBufferMessages as transformReply } from './generic-transformers';

packages/client/lib/commands/XREAD_BUFFER.ts

@@ -0,0 +1,5 @@
+export { FIRST_KEY_INDEX, IS_READ_ONLY, transformArguments } from './XREAD';
+
+export const BUFFER_MODE = true;
+
+export { transformReplyStreamsBufferMessages as transformReply } from './generic-transformers';

packages/client/lib/commands/XREVRANGE.ts

@@ -2,6 +2,10 @@ interface XRangeRevOptions {
     COUNT?: number;
 }
 
+export const FIRST_KEY_INDEX = 1;
+
+export const IS_READ_ONLY = true;
+
 export function transformArguments(key: string, start: string, end: string, options?: XRangeRevOptions): Array<string> {
     const args = ['XREVRANGE', key, start, end];
 
@@ -12,4 +16,4 @@ export function transformArguments(key: string, start: string, end: string, opti
     return args;
 }
 
-export { transformReplyStreamMessages as transformReply } from './generic-transformers';
+export { transformReplyStreamStringMessages as transformReply } from './generic-transformers';

packages/client/lib/commands/XREVRANGE_BUFFER.ts

@@ -0,0 +1,5 @@
+export { FIRST_KEY_INDEX, IS_READ_ONLY, transformArguments } from './XREVRANGE';
+
+export const BUFFER_MODE = true;
+
+export { transformReplyStreamBufferMessages as transformReply } from './generic-transformers';

packages/client/lib/commands/XTRIM.ts

@@ -1,3 +1,5 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+
 export const FIRST_KEY_INDEX = 1;
 
 interface XTrimOptions {
@@ -5,7 +7,12 @@ interface XTrimOptions {
     LIMIT?: number;
 }
 
-export function transformArguments(key: string, strategy: 'MAXLEN' | 'MINID', threshold: number, options?: XTrimOptions): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    strategy: 'MAXLEN' | 'MINID',
+    threshold: number,
+    options?: XTrimOptions
+): RedisCommandArguments {
     const args = ['XTRIM', key, strategy];
 
     if (options?.strategyModifier) {

packages/client/lib/commands/ZADD.ts

@@ -1,3 +1,4 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 import { transformArgumentNumberInfinity, ZMember } from './generic-transformers';
 
 export const FIRST_KEY_INDEX = 1;
@@ -28,7 +29,11 @@ interface INCR {
 
 type ZAddOptions = (NX | (XX & LT & GT)) & CH & INCR;
 
-export function transformArguments(key: string, members: ZMember | Array<ZMember>, options?: ZAddOptions): Array<string> {
+export function transformArguments(
+    key: RedisCommandArgument,
+    members: ZMember | Array<ZMember>,
+    options?: ZAddOptions
+): RedisCommandArguments {
     const args = ['ZADD', key];
 
     if ((<NX>options)?.NX) {

packages/client/lib/commands/ZDIFF_WITHSCORES.ts

@@ -10,4 +10,4 @@ export function transformArguments(...args: Parameters<typeof transformZDiffArgu
     ];
 }
 
-export { transformReplySortedSetWithScores as transformReply } from './generic-transformers';
+export { transformReplySortedStringsSetWithScores as transformReply } from './generic-transformers';

packages/client/lib/commands/ZINTER_WITHSCORES.ts

@@ -10,4 +10,4 @@ export function transformArguments(...args: Parameters<typeof transformZInterArg
     ];
 }
 
-export { transformReplySortedSetWithScores as transformReply } from './generic-transformers';
+export { transformReplySortedStringsSetWithScores as transformReply } from './generic-transformers';

packages/client/lib/commands/ZPOPMAX.ts

@@ -9,9 +9,9 @@ export function transformArguments(key: string): Array<string> {
     ];
 }
 
-export function transformReply(reply: [string, string] | []): ZMember | null {
+export function transformReply(reply: [string, string] | []): ZMember<string> | null {
     if (!reply.length) return null;
-    
+
     return {
         value: reply[0],
         score: transformReplyNumberInfinity(reply[1])

packages/client/lib/commands/ZPOPMAX_COUNT.ts

@@ -9,4 +9,4 @@ export function transformArguments(key: string, count: number): Array<string> {
     ];
 }
 
-export { transformReplySortedSetWithScores as transformReply } from './generic-transformers';
+export { transformReplySortedStringsSetWithScores as transformReply } from './generic-transformers';

packages/client/lib/commands/ZPOPMIN.ts

@@ -9,9 +9,9 @@ export function transformArguments(key: string): Array<string> {
     ];
 }
 
-export function transformReply(reply: [string, string] | []): ZMember | null {
+export function transformReply(reply: [string, string] | []): ZMember<string> | null {
     if (!reply.length) return null;
-    
+
     return {
         value: reply[0],
         score: transformReplyNumberInfinity(reply[1])

packages/client/lib/commands/ZPOPMIN_COUNT.ts

@@ -9,4 +9,4 @@ export function transformArguments(key: string, count: number): Array<string> {
     ];
 }
 
-export { transformReplySortedSetWithScores as transformReply } from './generic-transformers';
+export { transformReplySortedStringsSetWithScores as transformReply } from './generic-transformers';

packages/client/lib/commands/ZRANDMEMBER_COUNT_WITHSCORES.ts

@@ -9,4 +9,4 @@ export function transformArguments(...args: Parameters<typeof transformZRandMemb
     ];
 }
 
-export { transformReplySortedSetWithScores as transformReply } from './generic-transformers';
+export { transformReplySortedStringsSetWithScores as transformReply } from './generic-transformers';

packages/client/lib/commands/ZRANGEBYSCORE_WITHSCORES.ts

@@ -15,4 +15,4 @@ export function transformArguments(
     ];
 }
 
-export { transformReplySortedSetWithScores as transformReply } from './generic-transformers';
+export { transformReplySortedStringsSetWithScores as transformReply } from './generic-transformers';

packages/client/lib/commands/ZRANGE_WITHSCORES.ts

@@ -9,4 +9,4 @@ export function transformArguments(...args: Parameters<typeof transformZRangeArg
     ];
 }
 
-export { transformReplySortedSetWithScores as transformReply } from './generic-transformers';
+export { transformReplySortedStringsSetWithScores as transformReply } from './generic-transformers';

packages/client/lib/commands/ZSCAN.ts

@@ -13,11 +13,11 @@ export function transformArguments(key: string, cursor: number, options?: ScanOp
 
 interface ZScanReply {
     cursor: number;
-    members: Array<ZMember>;
+    members: Array<ZMember<string>>;
 }
 
 export function transformReply([cursor, rawMembers]: [string, Array<string>]): ZScanReply {
-    const parsedMembers: Array<ZMember> = [];
+    const parsedMembers: Array<ZMember<string>> = [];
     for (let i = 0; i < rawMembers.length; i += 2) {
         parsedMembers.push({
             value: rawMembers[i],

packages/client/lib/commands/ZUNION_WITHSCORES.ts

@@ -10,4 +10,4 @@ export function transformArguments(...args: Parameters<typeof transformZUnionArg
     ];
 }
 
-export { transformReplySortedSetWithScores as transformReply } from './generic-transformers';
+export { transformReplySortedStringsSetWithScores as transformReply } from './generic-transformers';

packages/client/lib/commands/generic-transformers.spec.ts

@@ -8,10 +8,14 @@ import {
     transformReplyNumberInfinityNull,
     transformArgumentNumberInfinity,
     transformArgumentStringNumberInfinity,
-    transformReplyTuples,
-    transformReplyStreamMessages,
-    transformReplyStreamsMessages,
-    transformReplySortedSetWithScores,
+    transformReplyStringTuples,
+    transformReplyBufferTuples,
+    transformReplyStreamStringMessages,
+    transformReplyStreamBufferMessages,
+    transformReplyStreamsStringMessages,
+    transformReplyStreamsBufferMessages,
+    transformReplySortedStringsSetWithScores,
+    transformReplySortedBuffersSetWithScores,
     pushGeoCountArgument,
     pushGeoSearchArguments,
     GeoReplyWith,
@@ -192,9 +196,9 @@ describe('Generic Transformers', () => {
         });
     });
 
-    it('transformReplyTuples', () => {
+    it('transformReplyStringTuples', () => {
         assert.deepEqual(
-            transformReplyTuples(['key1', 'value1', 'key2', 'value2']),
+            transformReplyStringTuples(['key1', 'value1', 'key2', 'value2']),
             Object.create(null, {
                 key1: {
                     value: 'value1',
@@ -210,9 +214,27 @@ describe('Generic Transformers', () => {
         );
     });
 
-    it('transformReplyStreamMessages', () => {
+    it('transformReplyBufferTuples', () => {
         assert.deepEqual(
-            transformReplyStreamMessages([['0-0', ['0key', '0value']], ['1-0', ['1key', '1value']]]),
+            transformReplyBufferTuples([Buffer.from('key1'), Buffer.from('value1'), Buffer.from('key2'), Buffer.from('value2')]),
+            Object.create(null, {
+                key1: {
+                    value: Buffer.from('value1'),
+                    configurable: true,
+                    enumerable: true
+                },
+                key2: {
+                    value: Buffer.from('value2'),
+                    configurable: true,
+                    enumerable: true
+                }
+            })
+        );
+    });
+
+    it('transformReplyStreamStringMessages', () => {
+        assert.deepEqual(
+            transformReplyStreamStringMessages([['0-0', ['0key', '0value']], ['1-0', ['1key', '1value']]]),
             [{
                 id: '0-0',
                 message: Object.create(null, {
@@ -235,17 +257,45 @@ describe('Generic Transformers', () => {
         );
     });
 
-    describe('transformReplyStreamsMessages', () => {
+    it('transformReplyStreamBufferMessages', () => {
+        assert.deepEqual(
+            transformReplyStreamBufferMessages([
+                [Buffer.from('0-0'), [Buffer.from('0key'), Buffer.from('0value')]],
+                [Buffer.from('1-0'), [Buffer.from('1key'), Buffer.from('1value')]]
+            ]),
+            [{
+                id: Buffer.from('0-0'),
+                message: Object.create(null, {
+                    '0key': {
+                        value: Buffer.from('0value'),
+                        configurable: true,
+                        enumerable: true
+                    }
+                })
+            }, {
+                id: Buffer.from('1-0'),
+                message: Object.create(null, {
+                    '1key': {
+                        value: Buffer.from('1value'),
+                        configurable: true,
+                        enumerable: true
+                    }
+                })
+            }]
+        );
+    });
+
+    describe('transformReplyStreamsStringMessages', () => {
         it('null', () => {
             assert.equal(
-                transformReplyStreamsMessages(null),
+                transformReplyStreamsStringMessages(null),
                 null
             );
         });
 
         it('with messages', () => {
             assert.deepEqual(
-                transformReplyStreamsMessages([['stream1', [['0-1', ['11key', '11value']], ['1-1', ['12key', '12value']]]], ['stream2', [['0-2', ['2key1', '2value1', '2key2', '2value2']]]]]),
+                transformReplyStreamsStringMessages([['stream1', [['0-1', ['11key', '11value']], ['1-1', ['12key', '12value']]]], ['stream2', [['0-2', ['2key1', '2value1', '2key2', '2value2']]]]]),
                 [{
                     name: 'stream1',
                     messages: [{
@@ -289,9 +339,77 @@ describe('Generic Transformers', () => {
         });
     });
 
-    it('transformReplySortedSetWithScores', () => {
+    describe('transformReplyStreamsBufferMessages', () => {
+        it('null', () => {
+            assert.equal(
+                transformReplyStreamsBufferMessages(null),
+                null
+            );
+        });
+
+        it('with messages', () => {
+            assert.deepEqual(
+                transformReplyStreamsBufferMessages([
+                    [
+                        Buffer.from('stream1'),
+                        [
+                            [Buffer.from('0-1'), [Buffer.from('11key'), Buffer.from('11value')]],
+                            [Buffer.from('1-1'), [Buffer.from('12key'), Buffer.from('12value')]]
+                        ]
+                    ],
+                    [
+                        Buffer.from('stream2'),
+                        [
+                            [Buffer.from('0-2'), [Buffer.from('2key1'), Buffer.from('2value1'), Buffer.from('2key2'), Buffer.from('2value2')]]
+                        ]
+                    ]
+                ]),
+                [{
+                    name: Buffer.from('stream1'),
+                    messages: [{
+                        id: Buffer.from('0-1'),
+                        message: Object.create(null, {
+                            '11key': {
+                                value: Buffer.from('11value'),
+                                configurable: true,
+                                enumerable: true
+                            }
+                        })
+                    }, {
+                        id: Buffer.from('1-1'),
+                        message: Object.create(null, {
+                            '12key': {
+                                value: Buffer.from('12value'),
+                                configurable: true,
+                                enumerable: true
+                            }
+                        })
+                    }]
+                }, {
+                    name: Buffer.from('stream2'),
+                    messages: [{
+                        id: Buffer.from('0-2'),
+                        message: Object.create(null, {
+                            '2key1': {
+                                value: Buffer.from('2value1'),
+                                configurable: true,
+                                enumerable: true
+                            },
+                            '2key2': {
+                                value: Buffer.from('2value2'),
+                                configurable: true,
+                                enumerable: true
+                            }
+                        })
+                    }]
+                }]
+            );
+        });
+    });
+
+    it('transformReplySortedStringsSetWithScores', () => {
         assert.deepEqual(
-            transformReplySortedSetWithScores(['member1', '0.5', 'member2', '+inf', 'member3', '-inf']),
+            transformReplySortedStringsSetWithScores(['member1', '0.5', 'member2', '+inf', 'member3', '-inf']),
             [{
                 value: 'member1',
                 score: 0.5
@@ -305,6 +423,29 @@ describe('Generic Transformers', () => {
         );
     });
 
+    it('transformReplySortedBuffersSetWithScores', () => {
+        assert.deepEqual(
+            transformReplySortedBuffersSetWithScores([
+                Buffer.from('member1'),
+                Buffer.from('0.5'),
+                Buffer.from('member2'),
+                Buffer.from('+inf'),
+                Buffer.from('member3'),
+                Buffer.from('-inf')
+            ]),
+            [{
+                value: Buffer.from('member1'),
+                score: 0.5
+            }, {
+                value: Buffer.from('member2'),
+                score: Infinity
+            }, {
+                value: Buffer.from('member3'),
+                score: -Infinity
+            }]
+        );
+    });
+
     describe('pushGeoCountArgument', () => {
         it('undefined', () => {
             assert.deepEqual(

packages/client/lib/commands/generic-transformers.ts

@@ -1,4 +1,4 @@
-import { RedisCommandArguments } from '.';
+import { RedisCommandArgument, RedisCommandArguments } from '.';
 
 export function transformReplyBoolean(reply: number): boolean {
     return reply === 1;
@@ -75,11 +75,7 @@ export function transformArgumentStringNumberInfinity(num: string | number): str
     return transformArgumentNumberInfinity(num);
 }
 
-export interface TuplesObject {
-    [field: string]: string;
-}
-
-export function transformReplyTuples(reply: Array<string>): TuplesObject {
+export function transformReplyStringTuples(reply: Array<string>): Record<string, string> {
     const message = Object.create(null);
 
     for (let i = 0; i < reply.length; i += 2) {
@@ -89,46 +85,91 @@ export function transformReplyTuples(reply: Array<string>): TuplesObject {
     return message;
 }
 
-export interface StreamMessageReply {
-    id: string;
-    message: TuplesObject;
+
+export function transformReplyBufferTuples(reply: Array<Buffer>): Record<string, Buffer> {
+    const message = Object.create(null);
+
+    for (let i = 0; i < reply.length; i += 2) {
+        message[reply[i].toString()] = reply[i + 1];
+    }
+
+    return message;
 }
 
-export type StreamMessagesReply = Array<StreamMessageReply>;
+export interface StreamStringsMessageReply {
+    id: string;
+    message: Record<string, string>;
+}
 
-export function transformReplyStreamMessages(reply: Array<any>): StreamMessagesReply {
+export type StreamStringsMessagesReply = Array<StreamStringsMessageReply>;
+
+export function transformReplyStreamStringMessages(reply: Array<any>): StreamStringsMessagesReply {
     const messages = [];
 
     for (const [id, message] of reply) {
         messages.push({
             id,
-            message: transformReplyTuples(message)
+            message: transformReplyStringTuples(message)
         });
     }
 
     return messages;
 }
 
-export type StreamsMessagesReply = Array<{
+interface StreamBufferMessageReply {
+    id: Buffer;
+    message: Record<string, Buffer>;
+}
+
+export type StreamBufferMessagesReply = Array<StreamBufferMessageReply>;
+
+export function transformReplyStreamBufferMessages(reply: Array<any>): StreamBufferMessagesReply {
+    const messages = [];
+
+    for (const [id, message] of reply) {
+        messages.push({
+            id,
+            message: transformReplyBufferTuples(message)
+        });
+    }
+
+    return messages;
+}
+
+export type StreamsStringMessagesReply = Array<{
     name: string;
-    messages: StreamMessagesReply;
+    messages: StreamStringsMessagesReply;
 }> | null;
 
-export function transformReplyStreamsMessages(reply: Array<any> | null): StreamsMessagesReply | null {
+export function transformReplyStreamsStringMessages(reply: Array<any> | null): StreamsStringMessagesReply | null {
     if (reply === null) return null;
 
     return reply.map(([name, rawMessages]) => ({
         name,
-        messages: transformReplyStreamMessages(rawMessages)
+        messages: transformReplyStreamStringMessages(rawMessages)
     }));
 }
 
-export interface ZMember {
-    score: number;
-    value: string;
+export type StreamsBufferMessagesReply = Array<{
+    name: Buffer;
+    messages: StreamBufferMessagesReply;
+}> | null;
+
+export function transformReplyStreamsBufferMessages(reply: Array<any> | null): StreamsBufferMessagesReply | null {
+    if (reply === null) return null;
+
+    return reply.map(([name, rawMessages]) => ({
+        name,
+        messages: transformReplyStreamBufferMessages(rawMessages)
+    }));
 }
 
-export function transformReplySortedSetWithScores(reply: Array<string>): Array<ZMember> {
+export interface ZMember<T = RedisCommandArgument> {
+    score: number;
+    value: T;
+}
+
+export function transformReplySortedStringsSetWithScores(reply: Array<string>): Array<ZMember<string>> {
     const members = [];
 
     for (let i = 0; i < reply.length; i += 2) {
@@ -141,6 +182,19 @@ export function transformReplySortedSetWithScores(reply: Array<string>): Array<Z
     return members;
 }
 
+export function transformReplySortedBuffersSetWithScores(reply: Array<Buffer>): Array<ZMember<Buffer>> {
+    const members = [];
+
+    for (let i = 0; i < reply.length; i += 2) {
+        members.push({
+            value: reply[i],
+            score: transformReplyNumberInfinity(reply[i + 1].toString())
+        });
+    }
+
+    return members;
+}
+
 type GeoCountArgument = number | {
     value: number;
     ANY?: true
@@ -314,7 +368,7 @@ export function pushStringTuplesArguments(args: Array<string>, tuples: StringTup
     return args;
 }
 
-export function pushVerdictArguments(args: RedisCommandArguments, value: string | Buffer | Array<string | Buffer>): RedisCommandArguments  {
+export function pushVerdictArguments(args: RedisCommandArguments, value: RedisCommandArgument | Array<RedisCommandArgument>): RedisCommandArguments  {
     if (Array.isArray(value)) {
         args.push(...value);
     } else {

packages/client/lib/commands/index.ts

@@ -2,10 +2,12 @@ import { RedisScriptConfig, SHA1 } from '../lua-script';
 
 export type RedisCommandRawReply = string | number | Buffer | Array<RedisCommandRawReply> | null | undefined;
 
-export type RedisCommandArguments = Array<string | Buffer> & { preserve?: unknown };
+export type RedisCommandArgument = string | Buffer;
+
+export type RedisCommandArguments = Array<RedisCommandArgument> & { preserve?: unknown };
 
 export interface RedisCommand {
-    FIRST_KEY_INDEX?: number | ((...args: Array<any>) => string);
+    FIRST_KEY_INDEX?: number | ((...args: Array<any>) => RedisCommandArgument);
     IS_READ_ONLY?: boolean;
     transformArguments(this: void, ...args: Array<any>): RedisCommandArguments;
     BUFFER_MODE?: boolean;