diff --git a/bin/overrides.js b/bin/overrides.js
index 96a8606ff..ee4ca5f54 100644
--- a/bin/overrides.js
+++ b/bin/overrides.js
@@ -2,6 +2,7 @@ const msetOverrides = {
   overwrite: false,
   defs: [
     "$1(object: object, callback?: Callback<'OK'>): Result<'OK', Context>",
+    "$1(map: Map<string | Buffer | number, string | Buffer | number>, callback?: Callback<'OK'>): Result<'OK', Context>",
   ],
 };
 
@@ -19,12 +20,14 @@ module.exports = {
     overwrite: false,
     defs: [
       "$1(key: RedisKey, object: object, callback?: Callback<number>): Result<number, Context>",
+      "$1(key: RedisKey, map: Map<string | Buffer | number, string | Buffer | number>, callback?: Callback<'OK'>): Result<'OK', Context>",
     ],
   },
   hmset: {
     overwrite: false,
     defs: [
       "$1(key: RedisKey, object: object, callback?: Callback<'OK'>): Result<'OK', Context>",
+      "$1(key: RedisKey, map: Map<string | Buffer | number, string | Buffer | number>, callback?: Callback<'OK'>): Result<'OK', Context>",
     ],
   },
   exec: {
diff --git a/lib/utils/RedisCommander.ts b/lib/utils/RedisCommander.ts
index 8d26741c3..ef9fa3030 100644
--- a/lib/utils/RedisCommander.ts
+++ b/lib/utils/RedisCommander.ts
@@ -4283,6 +4283,11 @@ interface RedisCommander<Context extends ClientContext = { type: "default" }> {
     object: object,
     callback?: Callback<"OK">
   ): Result<"OK", Context>;
+  hmset(
+    key: RedisKey,
+    map: Map<string | Buffer | number, string | Buffer | number>,
+    callback?: Callback<"OK">
+  ): Result<"OK", Context>;
   hmset(
     ...args: [
       key: RedisKey,
@@ -4405,6 +4410,11 @@ interface RedisCommander<Context extends ClientContext = { type: "default" }> {
     object: object,
     callback?: Callback<number>
   ): Result<number, Context>;
+  hset(
+    key: RedisKey,
+    map: Map<string | Buffer | number, string | Buffer | number>,
+    callback?: Callback<"OK">
+  ): Result<"OK", Context>;
   hset(
     ...args: [
       key: RedisKey,
@@ -5504,6 +5514,10 @@ interface RedisCommander<Context extends ClientContext = { type: "default" }> {
    * - _since_: 1.0.1
    */
   mset(object: object, callback?: Callback<"OK">): Result<"OK", Context>;
+  mset(
+    map: Map<string | Buffer | number, string | Buffer | number>,
+    callback?: Callback<"OK">
+  ): Result<"OK", Context>;
   mset(
     ...args: [
       ...keyValues: (RedisKey | string | Buffer | number)[],
@@ -5521,6 +5535,10 @@ interface RedisCommander<Context extends ClientContext = { type: "default" }> {
    * - _since_: 1.0.1
    */
   msetnx(object: object, callback?: Callback<"OK">): Result<"OK", Context>;
+  msetnx(
+    map: Map<string | Buffer | number, string | Buffer | number>,
+    callback?: Callback<"OK">
+  ): Result<"OK", Context>;
   msetnx(
     ...args: [
       ...keyValues: (RedisKey | string | Buffer | number)[],
diff --git a/test/functional/transformer.ts b/test/functional/transformer.ts
index d54b8da5e..5685f75a4 100644
--- a/test/functional/transformer.ts
+++ b/test/functional/transformer.ts
@@ -11,13 +11,20 @@ describe("transformer", () => {
         expect(await redis.hget("foo", "b")).to.eql("2");
       });
 
-      it("should support Map", async () => {
+      it("should support Map with string keys", async () => {
         const redis = new Redis();
         const map = new Map();
         map.set("a", 1);
         map.set("b", "2");
+        map.set(42, true);
+        map.set(Buffer.from("buffer"), "utf8");
+        map.set(Buffer.from([0xff]), "binary");
         expect(await redis.hmset("foo", map)).to.eql("OK");
+        expect(await redis.hget("foo", "a")).to.eql("1");
         expect(await redis.hget("foo", "b")).to.eql("2");
+        expect(await redis.hget("foo", "42")).to.eql("true");
+        expect(await redis.hget("foo", "buffer")).to.eql("utf8");
+        expect(await redis.hget("foo", Buffer.from([0xff]))).to.eql("binary");
       });
 
       it("should not affect the old way", async () => {
diff --git a/test/typing/transformers.test-d.ts b/test/typing/transformers.test-d.ts
index ab80580af..a65b4ac0e 100644
--- a/test/typing/transformers.test-d.ts
+++ b/test/typing/transformers.test-d.ts
@@ -7,25 +7,45 @@ interface User {
 }
 
 const user: User = { name: "Bob", title: "Engineer" };
-const map = new Map([["key", "value"]]);
+const stringMap = new Map([["key", "value"]]);
+const numberMap = new Map([[42, "value"]]);
+const bufferMap = new Map([[Buffer.from([0xff]), "value"]]);
+const mixedMap = new Map<string | Buffer | number, string>([
+  [Buffer.from([0xff]), "value"],
+  [42, "value"],
+  ["field", "value"],
+]);
 
 const redis = new Redis();
 
 // mset
+expectType<Promise<"OK">>(redis.mset("key1", "value1", "key2", "value2"));
 expectType<Promise<"OK">>(redis.mset(user));
-expectType<Promise<"OK">>(redis.mset(map));
+expectType<Promise<"OK">>(redis.mset(stringMap));
+expectType<Promise<"OK">>(redis.mset(numberMap));
+expectType<Promise<"OK">>(redis.mset(bufferMap));
+expectType<Promise<"OK">>(redis.mset(mixedMap));
 
 // msetnx
 expectType<Promise<"OK">>(redis.msetnx(user));
-expectType<Promise<"OK">>(redis.msetnx(map));
+expectType<Promise<"OK">>(redis.msetnx(stringMap));
+expectType<Promise<"OK">>(redis.msetnx(numberMap));
+expectType<Promise<"OK">>(redis.msetnx(bufferMap));
+expectType<Promise<"OK">>(redis.msetnx(mixedMap));
 
 // hmset
 expectType<Promise<"OK">>(redis.hmset("key", user));
-expectType<Promise<"OK">>(redis.hmset("key", map));
+expectType<Promise<"OK">>(redis.hmset("key", stringMap));
+expectType<Promise<"OK">>(redis.hmset("key", numberMap));
+expectType<Promise<"OK">>(redis.hmset("key", bufferMap));
+expectType<Promise<"OK">>(redis.hmset("key", mixedMap));
 
 // hset
 expectType<Promise<number>>(redis.hset("key", user));
-expectType<Promise<number>>(redis.hset("key", map));
+expectType<Promise<number>>(redis.hset("key", stringMap));
+expectType<Promise<number>>(redis.hset("key", numberMap));
+expectType<Promise<number>>(redis.hset("key", bufferMap));
+expectType<Promise<number>>(redis.hset("key", mixedMap));
 
 // hgetall
 expectType<Promise<Record<string, string>>>(redis.hgetall("key"));