implement .update thanks to @mbullington

type-definitions/immutable.d.ts

@@ -793,6 +793,14 @@ declare namespace Immutable {
 
     set<K extends keyof R>(key: K, value: R[K]): this;
 
+    update(updater: (value: this) => this): this;
+    update<K extends keyof R>(key: K, updater: (value: R[K]) => R[K]): this;
+    update<K extends keyof R, NSV>(
+      key: K,
+      notSetValue: NSV,
+      updater: (value: R[K]) => NSV
+    ): this;
+
     // Possible best type is MapFromObject<Omit<R, K>> but Omit seems to broke other function calls
     // and generate recursion error with other methods (update, merge, etc.) until those functions are defined in MapFromObject
     delete<K extends keyof R>(

type-definitions/ts-tests/map.ts

@@ -250,7 +250,22 @@ import { Map, List, MapFromObject } from 'immutable';
   Map<number, number>().update(1, 10, (v: number | undefined) => v + 'a');
 
   // $ExpectError
-  Map({ a: 1, b: 'b' }).update('c', (v: any) => v);
+  Map({ a: 1, b: 'b' }).update('c', (v) => v);
+
+  // $ExpectType MapFromObject<{ a: number; b: string; }>
+  Map({ a: 1, b: 'b' }).update('b', (v) => v.toUpperCase());
+
+  // $ExpectType MapFromObject<{ a: number; b: string; }>
+  Map({ a: 1, b: 'b' }).update('b', 'NSV', (v) => v.toUpperCase());
+
+  // $ExpectError
+  Map({ a: 1, b: 'b' }).update((v) => ({ a: 'a' }));
+
+  // $ExpectType MapFromObject<{ a: number; b: string; }>
+  Map({ a: 1, b: 'b' }).update((v) => v.set('a', 2).set('b', 'B'));
+
+  // $ExpectError
+  Map({ a: 1, b: 'b' }).update((v) => v.set('c', 'c'));
 }
 
 {