npm - immutable - Versions diffs - 4.0.0-rc.10 → 4.0.0-rc.15 - Mend

immutable 4.0.0-rc.10 → 4.0.0-rc.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/LICENSE +1 -1
package/README.md +174 -100
package/dist/immutable.d.ts +824 -528
package/dist/immutable.es.js +626 -509
package/dist/immutable.js +657 -531
package/dist/immutable.js.flow +937 -264
package/dist/immutable.min.js +53 -36
package/package.json +7 -11
package/contrib/cursor/README.md +0 -43
package/contrib/cursor/__tests__/Cursor.ts.skip +0 -395
package/contrib/cursor/index.d.ts +0 -287
package/contrib/cursor/index.js +0 -360
package/dist/immutable-nonambient.d.ts +0 -5333

package/dist/immutable.d.ts CHANGED Viewed

@@ -1,10 +1,3 @@
-/**
- * Copyright (c) 2014-present, Facebook, Inc.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
 /**
  * Immutable data encourages pure functions (data-in, data-out) and lends itself
  * to much simpler application development and enabling techniques from
@@ -73,7 +66,7 @@
  * `getIn` which expects an `Iterable` path:
  *
  * ```
- * getIn(path: Iterable<string | number>): any
+ * getIn(path: Iterable<string | number>): unknown
  * ```
  *
  * To use this method, we could pass an array: `data.getIn([ "key", 2 ])`.
@@ -92,13 +85,12 @@
  * ```
  *
  * [ES2015]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_6_support_in_Mozilla
- * [TypeScript]: http://www.typescriptlang.org/
+ * [TypeScript]: https://www.typescriptlang.org/
  * [Flow]: https://flowtype.org/
  * [Iterable]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols
  */
-declare module Immutable {
+declare namespace Immutable {
   /**
    * Lists are ordered indexed dense collections, much like a JavaScript
    * Array.
@@ -113,8 +105,7 @@ declare module Immutable {
    * "unset" index and an index set to `undefined`. `List#forEach` visits all
    * indices from 0 to size, regardless of whether they were explicitly defined.
    */
-  export module List {
+  namespace List {
     /**
      * True if the provided value is a List
      *
@@ -125,7 +116,7 @@ declare module Immutable {
      * List.isList(List()); // true
      * ```
      */
-    function isList(maybeList: any): maybeList is List<any>;
+    function isList(maybeList: unknown): maybeList is List<unknown>;
     /**
      * Creates a new List containing `values`.
@@ -180,12 +171,9 @@ declare module Immutable {
    * listFromPlainSet.equals(listFromPlainArray) // true
    * ```
    */
-  export function List(): List<any>;
-  export function List<T>(): List<T>;
-  export function List<T>(collection: Iterable<T>): List<T>;
-  export interface List<T> extends Collection.Indexed<T> {
+  function List<T>(collection?: Iterable<T> | ArrayLike<T>): List<T>;
+  interface List<T> extends Collection.Indexed<T> {
     /**
      * The number of items in this List.
      */
@@ -402,7 +390,7 @@ declare module Immutable {
      * @see `Map#update`
      */
     update(index: number, notSetValue: T, updater: (value: T) => T): this;
-    update(index: number, updater: (value: T) => T): this;
+    update(index: number, updater: (value: T | undefined) => T): this;
     update<R>(updater: (value: this) => R): R;
     /**
@@ -417,7 +405,6 @@ declare module Immutable {
      */
     setSize(size: number): List<T>;
     // Deep persistent changes
     /**
@@ -449,7 +436,7 @@ declare module Immutable {
      *
      * Note: `setIn` can be used in `withMutations`.
      */
-    setIn(keyPath: Iterable<any>, value: any): this;
+    setIn(keyPath: Iterable<unknown>, value: unknown): this;
     /**
      * Returns a new List having removed the value at this `keyPath`. If any
@@ -479,30 +466,40 @@ declare module Immutable {
      *
      * @alias removeIn
      */
-    deleteIn(keyPath: Iterable<any>): this;
-    removeIn(keyPath: Iterable<any>): this;
+    deleteIn(keyPath: Iterable<unknown>): this;
+    removeIn(keyPath: Iterable<unknown>): this;
     /**
      * Note: `updateIn` can be used in `withMutations`.
      *
      * @see `Map#updateIn`
      */
-    updateIn(keyPath: Iterable<any>, notSetValue: any, updater: (value: any) => any): this;
-    updateIn(keyPath: Iterable<any>, updater: (value: any) => any): this;
+    updateIn(
+      keyPath: Iterable<unknown>,
+      notSetValue: unknown,
+      updater: (value: unknown) => unknown
+    ): this;
+    updateIn(
+      keyPath: Iterable<unknown>,
+      updater: (value: unknown) => unknown
+    ): this;
     /**
      * Note: `mergeIn` can be used in `withMutations`.
      *
      * @see `Map#mergeIn`
      */
-    mergeIn(keyPath: Iterable<any>, ...collections: Array<any>): this;
+    mergeIn(keyPath: Iterable<unknown>, ...collections: Array<unknown>): this;
     /**
      * Note: `mergeDeepIn` can be used in `withMutations`.
      *
      * @see `Map#mergeDeepIn`
      */
-    mergeDeepIn(keyPath: Iterable<any>, ...collections: Array<any>): this;
+    mergeDeepIn(
+      keyPath: Iterable<unknown>,
+      ...collections: Array<unknown>
+    ): this;
     // Transient changes
@@ -513,7 +510,7 @@ declare module Immutable {
      *
      * @see `Map#withMutations`
      */
-    withMutations(mutator: (mutable: this) => any): this;
+    withMutations(mutator: (mutable: this) => unknown): this;
     /**
      * An alternative API for withMutations()
@@ -562,7 +559,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: T, key: number, iter: this) => M,
-      context?: any
+      context?: unknown
     ): List<M>;
     /**
@@ -572,7 +569,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: T, key: number, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): List<M>;
     /**
@@ -584,11 +581,11 @@ declare module Immutable {
      */
     filter<F extends T>(
       predicate: (value: T, index: number, iter: this) => value is F,
-      context?: any
+      context?: unknown
     ): List<F>;
     filter(
-      predicate: (value: T, index: number, iter: this) => any,
-      context?: any
+      predicate: (value: T, index: number, iter: this) => unknown,
+      context?: unknown
     ): this;
     /**
@@ -605,9 +602,12 @@ declare module Immutable {
      * const c = a.zip(b); // List [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]
      * ```
      */
-    zip<U>(other: Collection<any, U>): List<[T,U]>;
-    zip<U,V>(other: Collection<any, U>, other2: Collection<any,V>): List<[T,U,V]>;
-    zip(...collections: Array<Collection<any, any>>): List<any>;
+    zip<U>(other: Collection<unknown, U>): List<[T, U]>;
+    zip<U, V>(
+      other: Collection<unknown, U>,
+      other2: Collection<unknown, V>
+    ): List<[T, U, V]>;
+    zip(...collections: Array<Collection<unknown, unknown>>): List<unknown>;
     /**
      * Returns a List "zipped" with the provided collections.
@@ -628,9 +628,12 @@ declare module Immutable {
      * input, some results may contain undefined values. TypeScript cannot
      * account for these without cases (as of v2.5).
      */
-    zipAll<U>(other: Collection<any, U>): List<[T,U]>;
-    zipAll<U,V>(other: Collection<any, U>, other2: Collection<any,V>): List<[T,U,V]>;
-    zipAll(...collections: Array<Collection<any, any>>): List<any>;
+    zipAll<U>(other: Collection<unknown, U>): List<[T, U]>;
+    zipAll<U, V>(
+      other: Collection<unknown, U>,
+      other2: Collection<unknown, V>
+    ): List<[T, U, V]>;
+    zipAll(...collections: Array<Collection<unknown, unknown>>): List<unknown>;
     /**
      * Returns a List "zipped" with the provided collections by using a
@@ -648,20 +651,19 @@ declare module Immutable {
      */
     zipWith<U, Z>(
       zipper: (value: T, otherValue: U) => Z,
-      otherCollection: Collection<any, U>
+      otherCollection: Collection<unknown, U>
     ): List<Z>;
     zipWith<U, V, Z>(
       zipper: (value: T, otherValue: U, thirdValue: V) => Z,
-      otherCollection: Collection<any, U>,
-      thirdCollection: Collection<any, V>
+      otherCollection: Collection<unknown, U>,
+      thirdCollection: Collection<unknown, V>
     ): List<Z>;
     zipWith<Z>(
-      zipper: (...any: Array<any>) => Z,
-      ...collections: Array<Collection<any, any>>
+      zipper: (...values: Array<unknown>) => Z,
+      ...collections: Array<Collection<unknown, unknown>>
     ): List<Z>;
   }
   /**
    * Immutable Map is an unordered Collection.Keyed of (key, value) pairs with
    * `O(log32 N)` gets and `O(log32 N)` persistent sets.
@@ -689,8 +691,7 @@ declare module Immutable {
    *
    * Implemented by a hash-array mapped trie.
    */
-  export module Map {
+  namespace Map {
     /**
      * True if the provided value is a Map
      *
@@ -701,7 +702,7 @@ declare module Immutable {
      * Map.isMap(Map()) // true
      * ```
      */
-    function isMap(maybeMap: any): maybeMap is Map<any, any>;
+    function isMap(maybeMap: unknown): maybeMap is Map<unknown, unknown>;
     /**
      * Creates a new Map from alternating keys and values
@@ -719,7 +720,7 @@ declare module Immutable {
      *
      * @deprecated Use Map([ [ 'k', 'v' ] ]) or Map({ k: 'v' })
      */
-    function of(...keyValues: Array<any>): Map<any, any>;
+    function of(...keyValues: Array<unknown>): Map<unknown, unknown>;
   }
   /**
@@ -758,14 +759,11 @@ declare module Immutable {
    * but since Immutable Map keys can be of any type the argument to `get()` is
    * not altered.
    */
-  export function Map<K, V>(collection: Iterable<[K, V]>): Map<K, V>;
-  export function Map<T>(collection: Iterable<Iterable<T>>): Map<T, T>;
-  export function Map<V>(obj: {[key: string]: V}): Map<string, V>;
-  export function Map<K, V>(): Map<K, V>;
-  export function Map(): Map<any, any>;
-  export interface Map<K, V> extends Collection.Keyed<K, V> {
+  function Map<K, V>(collection?: Iterable<[K, V]>): Map<K, V>;
+  function Map<V>(obj: { [key: string]: V }): Map<string, V>;
+  function Map<K extends string, V>(obj: { [P in K]?: V }): Map<K, V>;
+  interface Map<K, V> extends Collection.Keyed<K, V> {
     /**
      * The number of entries in this Map.
      */
@@ -956,7 +954,7 @@ declare module Immutable {
      * Note: `update(key)` can be used in `withMutations`.
      */
     update(key: K, notSetValue: V, updater: (value: V) => V): this;
-    update(key: K, updater: (value: V) => V): this;
+    update(key: K, updater: (value: V | undefined) => V): this;
     update<R>(updater: (value: this) => R): R;
     /**
@@ -980,10 +978,18 @@ declare module Immutable {
      *
      * @alias concat
      */
-    merge<KC, VC>(...collections: Array<Iterable<[KC, VC]>>): Map<K | KC, V | VC>;
-    merge<C>(...collections: Array<{[key: string]: C}>): Map<K | string, V | C>;
-    concat<KC, VC>(...collections: Array<Iterable<[KC, VC]>>): Map<K | KC, V | VC>;
-    concat<C>(...collections: Array<{[key: string]: C}>): Map<K | string, V | C>;
+    merge<KC, VC>(
+      ...collections: Array<Iterable<[KC, VC]>>
+    ): Map<K | KC, V | VC>;
+    merge<C>(
+      ...collections: Array<{ [key: string]: C }>
+    ): Map<K | string, V | C>;
+    concat<KC, VC>(
+      ...collections: Array<Iterable<[KC, VC]>>
+    ): Map<K | KC, V | VC>;
+    concat<C>(
+      ...collections: Array<{ [key: string]: C }>
+    ): Map<K | string, V | C>;
     /**
      * Like `merge()`, `mergeWith()` returns a new Map resulting from merging
@@ -1005,16 +1011,22 @@ declare module Immutable {
      */
     mergeWith(
       merger: (oldVal: V, newVal: V, key: K) => V,
-      ...collections: Array<Iterable<[K, V]> | {[key: string]: V}>
+      ...collections: Array<Iterable<[K, V]> | { [key: string]: V }>
     ): this;
     /**
-     * Like `merge()`, but when two Collections conflict, it merges them as well,
-     * recursing deeply through the nested data.
+     * Like `merge()`, but when two compatible collections are encountered with
+     * the same key, it merges them as well, recursing deeply through the nested
+     * data. Two collections are considered to be compatible (and thus will be
+     * merged together) if they both fall into one of three categories: keyed
+     * (e.g., `Map`s, `Record`s, and objects), indexed (e.g., `List`s and
+     * arrays), or set-like (e.g., `Set`s). If they fall into separate
+     * categories, `mergeDeep` will replace the existing collection with the
+     * collection being merged in. This behavior can be customized by using
+     * `mergeDeepWith()`.
      *
-     * Note: Values provided to `merge` are shallowly converted before being
-     * merged. No nested values are altered unless they will also be merged at
-     * a deeper level.
+     * Note: Indexed and set-like collections are merged using
+     * `concat()`/`union()` and therefore do not recurse.
      *
      * <!-- runkit:activate -->
      * ```js
@@ -1031,11 +1043,16 @@ declare module Immutable {
      *
      * Note: `mergeDeep` can be used in `withMutations`.
      */
-    mergeDeep(...collections: Array<Iterable<[K, V]> | {[key: string]: V}>): this;
+    mergeDeep(
+      ...collections: Array<Iterable<[K, V]> | { [key: string]: V }>
+    ): this;
     /**
-     * Like `mergeDeep()`, but when two non-Collections conflict, it uses the
-     * `merger` function to determine the resulting value.
+     * Like `mergeDeep()`, but when two non-collections or incompatible
+     * collections are encountered at the same key, it uses the `merger`
+     * function to determine the resulting value. Collections are considered
+     * incompatible if they fall into separate categories between keyed,
+     * indexed, and set-like.
      *
      * <!-- runkit:activate -->
      * ```js
@@ -1049,15 +1066,14 @@ declare module Immutable {
      * //   "c": Map { "z": 3 }
      * // }
      * ```
+     *
      * Note: `mergeDeepWith` can be used in `withMutations`.
      */
     mergeDeepWith(
-      merger: (oldVal: any, newVal: any, key: any) => any,
-      ...collections: Array<Iterable<[K, V]> | {[key: string]: V}>
+      merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown,
+      ...collections: Array<Iterable<[K, V]> | { [key: string]: V }>
     ): this;
     // Deep persistent changes
     /**
@@ -1126,7 +1142,7 @@ declare module Immutable {
      *
      * Note: `setIn` can be used in `withMutations`.
      */
-    setIn(keyPath: Iterable<any>, value: any): this;
+    setIn(keyPath: Iterable<unknown>, value: unknown): this;
     /**
      * Returns a new Map having removed the value at this `keyPath`. If any keys
@@ -1136,8 +1152,8 @@ declare module Immutable {
      *
      * @alias removeIn
      */
-    deleteIn(keyPath: Iterable<any>): this;
-    removeIn(keyPath: Iterable<any>): this;
+    deleteIn(keyPath: Iterable<unknown>): this;
+    removeIn(keyPath: Iterable<unknown>): this;
     /**
      * Returns a new Map having applied the `updater` to the entry found at the
@@ -1215,8 +1231,15 @@ declare module Immutable {
      *
      * Note: `updateIn` can be used in `withMutations`.
      */
-    updateIn(keyPath: Iterable<any>, notSetValue: any, updater: (value: any) => any): this;
-    updateIn(keyPath: Iterable<any>, updater: (value: any) => any): this;
+    updateIn(
+      keyPath: Iterable<unknown>,
+      notSetValue: unknown,
+      updater: (value: unknown) => unknown
+    ): this;
+    updateIn(
+      keyPath: Iterable<unknown>,
+      updater: (value: unknown) => unknown
+    ): this;
     /**
      * A combination of `updateIn` and `merge`, returning a new Map, but
@@ -1230,7 +1253,7 @@ declare module Immutable {
      *
      * Note: `mergeIn` can be used in `withMutations`.
      */
-    mergeIn(keyPath: Iterable<any>, ...collections: Array<any>): this;
+    mergeIn(keyPath: Iterable<unknown>, ...collections: Array<unknown>): this;
     /**
      * A combination of `updateIn` and `mergeDeep`, returning a new Map, but
@@ -1244,7 +1267,10 @@ declare module Immutable {
      *
      * Note: `mergeDeepIn` can be used in `withMutations`.
      */
-    mergeDeepIn(keyPath: Iterable<any>, ...collections: Array<any>): this;
+    mergeDeepIn(
+      keyPath: Iterable<unknown>,
+      ...collections: Array<unknown>
+    ): this;
     // Transient changes
@@ -1276,7 +1302,7 @@ declare module Immutable {
      * `withMutations`! Read the documentation for each method to see if it
      * is safe to use in `withMutations`.
      */
-    withMutations(mutator: (mutable: this) => any): this;
+    withMutations(mutator: (mutable: this) => unknown): this;
     /**
      * Another way to avoid creation of intermediate Immutable maps is to create
@@ -1331,7 +1357,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: V, key: K, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Map<K, M>;
     /**
@@ -1339,15 +1365,19 @@ declare module Immutable {
      */
     mapKeys<M>(
       mapper: (key: K, value: V, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Map<M, V>;
     /**
      * @see Collection.Keyed.mapEntries
      */
     mapEntries<KM, VM>(
-      mapper: (entry: [K, V], index: number, iter: this) => [KM, VM],
-      context?: any
+      mapper: (
+        entry: [K, V],
+        index: number,
+        iter: this
+      ) => [KM, VM] | undefined,
+      context?: unknown
     ): Map<KM, VM>;
     /**
@@ -1357,7 +1387,7 @@ declare module Immutable {
      */
     flatMap<KM, VM>(
       mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,
-      context?: any
+      context?: unknown
     ): Map<KM, VM>;
     /**
@@ -1369,11 +1399,11 @@ declare module Immutable {
      */
     filter<F extends V>(
       predicate: (value: V, key: K, iter: this) => value is F,
-      context?: any
+      context?: unknown
     ): Map<K, F>;
     filter(
-      predicate: (value: V, key: K, iter: this) => any,
-      context?: any
+      predicate: (value: V, key: K, iter: this) => unknown,
+      context?: unknown
     ): this;
     /**
@@ -1382,7 +1412,6 @@ declare module Immutable {
     flip(): Map<V, K>;
   }
   /**
    * A type of Map that has the additional guarantee that the iteration order of
    * entries will be the order in which they were set().
@@ -1394,13 +1423,13 @@ declare module Immutable {
    * consume more memory. `OrderedMap#set` is amortized O(log32 N), but not
    * stable.
    */
-  export module OrderedMap {
+  namespace OrderedMap {
     /**
      * True if the provided value is an OrderedMap.
      */
-    function isOrderedMap(maybeOrderedMap: any): maybeOrderedMap is OrderedMap<any, any>;
+    function isOrderedMap(
+      maybeOrderedMap: unknown
+    ): maybeOrderedMap is OrderedMap<unknown, unknown>;
   }
   /**
@@ -1418,14 +1447,10 @@ declare module Immutable {
    * Note: `OrderedMap` is a factory function and not a class, and does not use
    * the `new` keyword during construction.
    */
-  export function OrderedMap<K, V>(collection: Iterable<[K, V]>): OrderedMap<K, V>;
-  export function OrderedMap<T>(collection: Iterable<Iterable<T>>): OrderedMap<T, T>;
-  export function OrderedMap<V>(obj: {[key: string]: V}): OrderedMap<string, V>;
-  export function OrderedMap<K, V>(): OrderedMap<K, V>;
-  export function OrderedMap(): OrderedMap<any, any>;
-  export interface OrderedMap<K, V> extends Map<K, V> {
+  function OrderedMap<K, V>(collection?: Iterable<[K, V]>): OrderedMap<K, V>;
+  function OrderedMap<V>(obj: { [key: string]: V }): OrderedMap<string, V>;
+  interface OrderedMap<K, V> extends Map<K, V> {
     /**
      * The number of entries in this OrderedMap.
      */
@@ -1473,10 +1498,18 @@ declare module Immutable {
      *
      * @alias concat
      */
-    merge<KC, VC>(...collections: Array<Iterable<[KC, VC]>>): OrderedMap<K | KC, V | VC>;
-    merge<C>(...collections: Array<{[key: string]: C}>): OrderedMap<K | string, V | C>;
-    concat<KC, VC>(...collections: Array<Iterable<[KC, VC]>>): OrderedMap<K | KC, V | VC>;
-    concat<C>(...collections: Array<{[key: string]: C}>): OrderedMap<K | string, V | C>;
+    merge<KC, VC>(
+      ...collections: Array<Iterable<[KC, VC]>>
+    ): OrderedMap<K | KC, V | VC>;
+    merge<C>(
+      ...collections: Array<{ [key: string]: C }>
+    ): OrderedMap<K | string, V | C>;
+    concat<KC, VC>(
+      ...collections: Array<Iterable<[KC, VC]>>
+    ): OrderedMap<K | KC, V | VC>;
+    concat<C>(
+      ...collections: Array<{ [key: string]: C }>
+    ): OrderedMap<K | string, V | C>;
     // Sequence algorithms
@@ -1492,7 +1525,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: V, key: K, iter: this) => M,
-      context?: any
+      context?: unknown
     ): OrderedMap<K, M>;
     /**
@@ -1500,15 +1533,19 @@ declare module Immutable {
      */
     mapKeys<M>(
       mapper: (key: K, value: V, iter: this) => M,
-      context?: any
+      context?: unknown
     ): OrderedMap<M, V>;
     /**
      * @see Collection.Keyed.mapEntries
      */
     mapEntries<KM, VM>(
-      mapper: (entry: [K, V], index: number, iter: this) => [KM, VM],
-      context?: any
+      mapper: (
+        entry: [K, V],
+        index: number,
+        iter: this
+      ) => [KM, VM] | undefined,
+      context?: unknown
     ): OrderedMap<KM, VM>;
     /**
@@ -1518,7 +1555,7 @@ declare module Immutable {
      */
     flatMap<KM, VM>(
       mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,
-      context?: any
+      context?: unknown
     ): OrderedMap<KM, VM>;
     /**
@@ -1530,11 +1567,11 @@ declare module Immutable {
      */
     filter<F extends V>(
       predicate: (value: V, key: K, iter: this) => value is F,
-      context?: any
+      context?: unknown
     ): OrderedMap<K, F>;
     filter(
-      predicate: (value: V, key: K, iter: this) => any,
-      context?: any
+      predicate: (value: V, key: K, iter: this) => unknown,
+      context?: unknown
     ): this;
     /**
@@ -1543,7 +1580,6 @@ declare module Immutable {
     flip(): OrderedMap<V, K>;
   }
   /**
    * A Collection of unique values with `O(log32 N)` adds and has.
    *
@@ -1555,12 +1591,11 @@ declare module Immutable {
    * `Immutable.is`, enabling Sets to uniquely include other Immutable
    * collections, custom value types, and NaN.
    */
-  export module Set {
+  namespace Set {
     /**
      * True if the provided value is a Set
      */
-    function isSet(maybeSet: any): maybeSet is Set<any>;
+    function isSet(maybeSet: unknown): maybeSet is Set<unknown>;
     /**
      * Creates a new Set containing `values`.
@@ -1571,8 +1606,8 @@ declare module Immutable {
      * `Set.fromKeys()` creates a new immutable Set containing the keys from
      * this Collection or JavaScript Object.
      */
-    function fromKeys<T>(iter: Collection<T, any>): Set<T>;
-    function fromKeys(obj: {[key: string]: any}): Set<string>;
+    function fromKeys<T>(iter: Collection<T, unknown>): Set<T>;
+    function fromKeys(obj: { [key: string]: unknown }): Set<string>;
     /**
      * `Set.intersect()` creates a new immutable Set that is the intersection of
@@ -1584,7 +1619,7 @@ declare module Immutable {
      *   Set([ 'a', 'b', 'c' ])
      *   Set([ 'c', 'a', 't' ])
      * ])
-     * // Set [ "a", "c"" ]
+     * // Set [ "a", "c" ]
      * ```
      */
     function intersect<T>(sets: Iterable<Iterable<T>>): Set<T>;
@@ -1599,7 +1634,7 @@ declare module Immutable {
      *   Set([ 'a', 'b', 'c' ])
      *   Set([ 'c', 'a', 't' ])
      * ])
-     * // Set [ "a", "b", "c", "t"" ]
+     * // Set [ "a", "b", "c", "t" ]
      * ```
      */
     function union<T>(sets: Iterable<Iterable<T>>): Set<T>;
@@ -1612,12 +1647,9 @@ declare module Immutable {
    * Note: `Set` is a factory function and not a class, and does not use the
    * `new` keyword during construction.
    */
-  export function Set(): Set<any>;
-  export function Set<T>(): Set<T>;
-  export function Set<T>(collection: Iterable<T>): Set<T>;
-  export interface Set<T> extends Collection.Set<T> {
+  function Set<T>(collection?: Iterable<T> | ArrayLike<T>): Set<T>;
+  interface Set<T> extends Collection.Set<T> {
     /**
      * The number of items in this Set.
      */
@@ -1686,7 +1718,6 @@ declare module Immutable {
      */
     subtract(...collections: Array<Iterable<T>>): this;
     // Transient changes
     /**
@@ -1696,7 +1727,7 @@ declare module Immutable {
      *
      * @see `Map#withMutations`
      */
-    withMutations(mutator: (mutable: this) => any): this;
+    withMutations(mutator: (mutable: this) => unknown): this;
     /**
      * Note: Not all methods can be used on a mutable collection or within
@@ -1728,7 +1759,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: T, key: T, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Set<M>;
     /**
@@ -1738,7 +1769,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: T, key: T, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): Set<M>;
     /**
@@ -1750,15 +1781,14 @@ declare module Immutable {
      */
     filter<F extends T>(
       predicate: (value: T, key: T, iter: this) => value is F,
-      context?: any
+      context?: unknown
     ): Set<F>;
     filter(
-      predicate: (value: T, key: T, iter: this) => any,
-      context?: any
+      predicate: (value: T, key: T, iter: this) => unknown,
+      context?: unknown
     ): this;
   }
   /**
    * A type of Set that has the additional guarantee that the iteration order of
    * values will be the order in which they were `add`ed.
@@ -1769,12 +1799,11 @@ declare module Immutable {
    * consume more memory. `OrderedSet#add` is amortized O(log32 N), but not
    * stable.
    */
-  export module OrderedSet {
+  namespace OrderedSet {
     /**
      * True if the provided value is an OrderedSet.
      */
-    function isOrderedSet(maybeOrderedSet: any): boolean;
+    function isOrderedSet(maybeOrderedSet: unknown): boolean;
     /**
      * Creates a new OrderedSet containing `values`.
@@ -1785,8 +1814,8 @@ declare module Immutable {
      * `OrderedSet.fromKeys()` creates a new immutable OrderedSet containing
      * the keys from this Collection or JavaScript Object.
      */
-    function fromKeys<T>(iter: Collection<T, any>): OrderedSet<T>;
-    function fromKeys(obj: {[key: string]: any}): OrderedSet<string>;
+    function fromKeys<T>(iter: Collection<T, unknown>): OrderedSet<T>;
+    function fromKeys(obj: { [key: string]: unknown }): OrderedSet<string>;
   }
   /**
@@ -1796,12 +1825,11 @@ declare module Immutable {
    * Note: `OrderedSet` is a factory function and not a class, and does not use
    * the `new` keyword during construction.
    */
-  export function OrderedSet(): OrderedSet<any>;
-  export function OrderedSet<T>(): OrderedSet<T>;
-  export function OrderedSet<T>(collection: Iterable<T>): OrderedSet<T>;
-  export interface OrderedSet<T> extends Set<T> {
+  function OrderedSet<T>(
+    collection?: Iterable<T> | ArrayLike<T>
+  ): OrderedSet<T>;
+  interface OrderedSet<T> extends Set<T> {
     /**
      * The number of items in this OrderedSet.
      */
@@ -1830,7 +1858,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: T, key: T, iter: this) => M,
-      context?: any
+      context?: unknown
     ): OrderedSet<M>;
     /**
@@ -1840,7 +1868,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: T, key: T, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): OrderedSet<M>;
     /**
@@ -1852,11 +1880,11 @@ declare module Immutable {
      */
     filter<F extends T>(
       predicate: (value: T, key: T, iter: this) => value is F,
-      context?: any
+      context?: unknown
     ): OrderedSet<F>;
     filter(
-      predicate: (value: T, key: T, iter: this) => any,
-      context?: any
+      predicate: (value: T, key: T, iter: this) => unknown,
+      context?: unknown
     ): this;
     /**
@@ -1872,9 +1900,14 @@ declare module Immutable {
      * // OrderedSet [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]
      * ```
      */
-    zip<U>(other: Collection<any, U>): OrderedSet<[T,U]>;
-    zip<U,V>(other1: Collection<any, U>, other2: Collection<any, V>): OrderedSet<[T,U,V]>;
-    zip(...collections: Array<Collection<any, any>>): OrderedSet<any>;
+    zip<U>(other: Collection<unknown, U>): OrderedSet<[T, U]>;
+    zip<U, V>(
+      other1: Collection<unknown, U>,
+      other2: Collection<unknown, V>
+    ): OrderedSet<[T, U, V]>;
+    zip(
+      ...collections: Array<Collection<unknown, unknown>>
+    ): OrderedSet<unknown>;
     /**
      * Returns a OrderedSet of the same type "zipped" with the provided
@@ -1893,9 +1926,14 @@ declare module Immutable {
      * input, some results may contain undefined values. TypeScript cannot
      * account for these without cases (as of v2.5).
      */
-    zipAll<U>(other: Collection<any, U>): OrderedSet<[T,U]>;
-    zipAll<U,V>(other1: Collection<any, U>, other2: Collection<any, V>): OrderedSet<[T,U,V]>;
-    zipAll(...collections: Array<Collection<any, any>>): OrderedSet<any>;
+    zipAll<U>(other: Collection<unknown, U>): OrderedSet<[T, U]>;
+    zipAll<U, V>(
+      other1: Collection<unknown, U>,
+      other2: Collection<unknown, V>
+    ): OrderedSet<[T, U, V]>;
+    zipAll(
+      ...collections: Array<Collection<unknown, unknown>>
+    ): OrderedSet<unknown>;
     /**
      * Returns an OrderedSet of the same type "zipped" with the provided
@@ -1905,21 +1943,19 @@ declare module Immutable {
      */
     zipWith<U, Z>(
       zipper: (value: T, otherValue: U) => Z,
-      otherCollection: Collection<any, U>
+      otherCollection: Collection<unknown, U>
     ): OrderedSet<Z>;
     zipWith<U, V, Z>(
       zipper: (value: T, otherValue: U, thirdValue: V) => Z,
-      otherCollection: Collection<any, U>,
-      thirdCollection: Collection<any, V>
+      otherCollection: Collection<unknown, U>,
+      thirdCollection: Collection<unknown, V>
     ): OrderedSet<Z>;
     zipWith<Z>(
-      zipper: (...any: Array<any>) => Z,
-      ...collections: Array<Collection<any, any>>
+      zipper: (...values: Array<unknown>) => Z,
+      ...collections: Array<Collection<unknown, unknown>>
     ): OrderedSet<Z>;
   }
   /**
    * Stacks are indexed collections which support very efficient O(1) addition
    * and removal from the front using `unshift(v)` and `shift()`.
@@ -1933,12 +1969,11 @@ declare module Immutable {
    *
    * Stack is implemented with a Single-Linked List.
    */
-  export module Stack {
+  namespace Stack {
     /**
      * True if the provided value is a Stack
      */
-    function isStack(maybeStack: any): maybeStack is Stack<any>;
+    function isStack(maybeStack: unknown): maybeStack is Stack<unknown>;
     /**
      * Creates a new Stack containing `values`.
@@ -1956,12 +1991,9 @@ declare module Immutable {
    * Note: `Stack` is a factory function and not a class, and does not use the
    * `new` keyword during construction.
    */
-  export function Stack(): Stack<any>;
-  export function Stack<T>(): Stack<T>;
-  export function Stack<T>(collection: Iterable<T>): Stack<T>;
-  export interface Stack<T> extends Collection.Indexed<T> {
+  function Stack<T>(collection?: Iterable<T> | ArrayLike<T>): Stack<T>;
+  interface Stack<T> extends Collection.Indexed<T> {
     /**
      * The number of items in this Stack.
      */
@@ -1974,7 +2006,6 @@ declare module Immutable {
      */
     peek(): T | undefined;
     // Persistent changes
     /**
@@ -2028,7 +2059,6 @@ declare module Immutable {
      */
     pop(): Stack<T>;
     // Transient changes
     /**
@@ -2038,7 +2068,7 @@ declare module Immutable {
      *
      * @see `Map#withMutations`
      */
-    withMutations(mutator: (mutable: this) => any): this;
+    withMutations(mutator: (mutable: this) => unknown): this;
     /**
      * Note: Not all methods can be used on a mutable collection or within
@@ -2078,7 +2108,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: T, key: number, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Stack<M>;
     /**
@@ -2088,7 +2118,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: T, key: number, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): Stack<M>;
     /**
@@ -2100,11 +2130,11 @@ declare module Immutable {
      */
     filter<F extends T>(
       predicate: (value: T, index: number, iter: this) => value is F,
-      context?: any
+      context?: unknown
     ): Set<F>;
     filter(
-      predicate: (value: T, index: number, iter: this) => any,
-      context?: any
+      predicate: (value: T, index: number, iter: this) => unknown,
+      context?: unknown
     ): this;
     /**
@@ -2118,9 +2148,12 @@ declare module Immutable {
      * const c = a.zip(b); // Stack [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]
      * ```
      */
-    zip<U>(other: Collection<any, U>): Stack<[T,U]>;
-    zip<U,V>(other: Collection<any, U>, other2: Collection<any,V>): Stack<[T,U,V]>;
-    zip(...collections: Array<Collection<any, any>>): Stack<any>;
+    zip<U>(other: Collection<unknown, U>): Stack<[T, U]>;
+    zip<U, V>(
+      other: Collection<unknown, U>,
+      other2: Collection<unknown, V>
+    ): Stack<[T, U, V]>;
+    zip(...collections: Array<Collection<unknown, unknown>>): Stack<unknown>;
     /**
      * Returns a Stack "zipped" with the provided collections.
@@ -2138,9 +2171,12 @@ declare module Immutable {
      * input, some results may contain undefined values. TypeScript cannot
      * account for these without cases (as of v2.5).
      */
-    zipAll<U>(other: Collection<any, U>): Stack<[T,U]>;
-    zipAll<U,V>(other: Collection<any, U>, other2: Collection<any,V>): Stack<[T,U,V]>;
-    zipAll(...collections: Array<Collection<any, any>>): Stack<any>;
+    zipAll<U>(other: Collection<unknown, U>): Stack<[T, U]>;
+    zipAll<U, V>(
+      other: Collection<unknown, U>,
+      other2: Collection<unknown, V>
+    ): Stack<[T, U, V]>;
+    zipAll(...collections: Array<Collection<unknown, unknown>>): Stack<unknown>;
     /**
      * Returns a Stack "zipped" with the provided collections by using a
@@ -2155,20 +2191,19 @@ declare module Immutable {
      */
     zipWith<U, Z>(
       zipper: (value: T, otherValue: U) => Z,
-      otherCollection: Collection<any, U>
+      otherCollection: Collection<unknown, U>
     ): Stack<Z>;
     zipWith<U, V, Z>(
       zipper: (value: T, otherValue: U, thirdValue: V) => Z,
-      otherCollection: Collection<any, U>,
-      thirdCollection: Collection<any, V>
+      otherCollection: Collection<unknown, U>,
+      thirdCollection: Collection<unknown, V>
     ): Stack<Z>;
     zipWith<Z>(
-      zipper: (...any: Array<any>) => Z,
-      ...collections: Array<Collection<any, any>>
+      zipper: (...values: Array<unknown>) => Z,
+      ...collections: Array<Collection<unknown, unknown>>
     ): Stack<Z>;
   }
   /**
    * Returns a Seq.Indexed of numbers from `start` (inclusive) to `end`
    * (exclusive), by `step`, where `start` defaults to 0, `step` to 1, and `end` to
@@ -2187,8 +2222,11 @@ declare module Immutable {
    * Range(30, 30, 5) // []
    * ```
    */
-  export function Range(start?: number, end?: number, step?: number): Seq.Indexed<number>;
+  function Range(
+    start?: number,
+    end?: number,
+    step?: number
+  ): Seq.Indexed<number>;
   /**
    * Returns a Seq.Indexed of `value` repeated `times` times. When `times` is
@@ -2203,8 +2241,7 @@ declare module Immutable {
    * Repeat('bar', 4) // [ 'bar', 'bar', 'bar', 'bar' ]
    * ```
    */
-  export function Repeat<T>(value: T, times?: number): Seq.Indexed<T>;
+  function Repeat<T>(value: T, times?: number): Seq.Indexed<T>;
   /**
    * A record is similar to a JS object, but enforces a specific set of allowed
@@ -2223,12 +2260,10 @@ declare module Immutable {
    * from a record simply resets it to the default value for that key.
    *
    * ```js
-   * myRecord.size // 2
    * myRecord.get('a') // 1
    * myRecord.get('b') // 3
    * const myRecordWithoutB = myRecord.remove('b')
    * myRecordWithoutB.get('b') // 2
-   * myRecordWithoutB.size // 2
    * ```
    *
    * Values provided to the constructor not found in the Record type will
@@ -2367,12 +2402,11 @@ declare module Immutable {
    *   form isn't free. If converting Records to plain objects is common,
    *   consider sticking with plain objects to begin with.
    */
-  export module Record {
+  namespace Record {
     /**
      * True if `maybeRecord` is an instance of a Record.
      */
-    export function isRecord(maybeRecord: any): maybeRecord is Record<any>;
+    function isRecord(maybeRecord: unknown): maybeRecord is Record<{}>;
     /**
      * Records allow passing a second parameter to supply a descriptive name
@@ -2391,7 +2425,7 @@ declare module Immutable {
      * Record.getDescriptiveName(me) // "Person"
      * ```
      */
-    export function getDescriptiveName(record: Record<any>): string;
+    function getDescriptiveName(record: Record<any>): string;
     /**
      * A Record.Factory is created by the `Record()` function. Record instances
@@ -2441,14 +2475,25 @@ declare module Immutable {
      * const alan: Person = makePerson({ name: 'Alan' });
      * ```
      */
-    export module Factory {}
+    namespace Factory {}
-    export interface Factory<TProps extends Object> {
-      (values?: Partial<TProps> | Iterable<[string, any]>): Record<TProps> & Readonly<TProps>;
-      new (values?: Partial<TProps> | Iterable<[string, any]>): Record<TProps> & Readonly<TProps>;
+    interface Factory<TProps extends object> {
+      (values?: Partial<TProps> | Iterable<[string, unknown]>): Record<TProps> &
+        Readonly<TProps>;
+      new (
+        values?: Partial<TProps> | Iterable<[string, unknown]>
+      ): Record<TProps> & Readonly<TProps>;
+      /**
+       * The name provided to `Record(values, name)` can be accessed with
+       * `displayName`.
+       */
+      displayName: string;
     }
-    export function Factory<TProps extends Object>(values?: Partial<TProps> | Iterable<[string, any]>): Record<TProps> & Readonly<TProps>;
+    function Factory<TProps extends object>(
+      values?: Partial<TProps> | Iterable<[string, unknown]>
+    ): Record<TProps> & Readonly<TProps>;
   }
   /**
@@ -2460,10 +2505,12 @@ declare module Immutable {
    * Note: `Record` is a factory function and not a class, and does not use the
    * `new` keyword during construction.
    */
-  export function Record<TProps>(defaultValues: TProps, name?: string): Record.Factory<TProps>;
-  export interface Record<TProps extends Object> {
+  function Record<TProps extends object>(
+    defaultValues: TProps,
+    name?: string
+  ): Record.Factory<TProps>;
+  interface Record<TProps extends object> {
     // Reading values
     has(key: string): key is keyof TProps & string;
@@ -2476,33 +2523,40 @@ declare module Immutable {
      * notSetValue will be returned if provided. Note that this scenario would
      * produce an error when using Flow or TypeScript.
      */
-    get<K extends keyof TProps>(key: K, notSetValue?: any): TProps[K];
+    get<K extends keyof TProps>(key: K, notSetValue?: unknown): TProps[K];
     get<T>(key: string, notSetValue: T): T;
     // Reading deep values
-    hasIn(keyPath: Iterable<any>): boolean;
-    getIn(keyPath: Iterable<any>): any;
+    hasIn(keyPath: Iterable<unknown>): boolean;
+    getIn(keyPath: Iterable<unknown>): unknown;
     // Value equality
-    equals(other: any): boolean;
+    equals(other: unknown): boolean;
     hashCode(): number;
     // Persistent changes
     set<K extends keyof TProps>(key: K, value: TProps[K]): this;
-    update<K extends keyof TProps>(key: K, updater: (value: TProps[K]) => TProps[K]): this;
-    merge(...collections: Array<Partial<TProps> | Iterable<[string, any]>>): this;
-    mergeDeep(...collections: Array<Partial<TProps> | Iterable<[string, any]>>): this;
+    update<K extends keyof TProps>(
+      key: K,
+      updater: (value: TProps[K]) => TProps[K]
+    ): this;
+    merge(
+      ...collections: Array<Partial<TProps> | Iterable<[string, unknown]>>
+    ): this;
+    mergeDeep(
+      ...collections: Array<Partial<TProps> | Iterable<[string, unknown]>>
+    ): this;
     mergeWith(
-      merger: (oldVal: any, newVal: any, key: keyof TProps) => any,
-      ...collections: Array<Partial<TProps> | Iterable<[string, any]>>
+      merger: (oldVal: unknown, newVal: unknown, key: keyof TProps) => unknown,
+      ...collections: Array<Partial<TProps> | Iterable<[string, unknown]>>
     ): this;
     mergeDeepWith(
-      merger: (oldVal: any, newVal: any, key: any) => any,
-      ...collections: Array<Partial<TProps> | Iterable<[string, any]>>
+      merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown,
+      ...collections: Array<Partial<TProps> | Iterable<[string, unknown]>>
     ): this;
     /**
@@ -2522,16 +2576,22 @@ declare module Immutable {
     // Deep persistent changes
-    setIn(keyPath: Iterable<any>, value: any): this;
-    updateIn(keyPath: Iterable<any>, updater: (value: any) => any): this;
-    mergeIn(keyPath: Iterable<any>, ...collections: Array<any>): this;
-    mergeDeepIn(keyPath: Iterable<any>, ...collections: Array<any>): this;
+    setIn(keyPath: Iterable<unknown>, value: unknown): this;
+    updateIn(
+      keyPath: Iterable<unknown>,
+      updater: (value: unknown) => unknown
+    ): this;
+    mergeIn(keyPath: Iterable<unknown>, ...collections: Array<unknown>): this;
+    mergeDeepIn(
+      keyPath: Iterable<unknown>,
+      ...collections: Array<unknown>
+    ): this;
     /**
      * @alias removeIn
      */
-    deleteIn(keyPath: Iterable<any>): this;
-    removeIn(keyPath: Iterable<any>): this;
+    deleteIn(keyPath: Iterable<unknown>): this;
+    removeIn(keyPath: Iterable<unknown>): this;
     // Conversion to JavaScript types
@@ -2541,7 +2601,7 @@ declare module Immutable {
      * Note: This method may not be overridden. Objects with custom
      * serialization to plain JS may override toJSON() instead.
      */
-    toJS(): { [K in keyof TProps]: any };
+    toJS(): { [K in keyof TProps]: unknown };
     /**
      * Shallowly converts this Record to equivalent native JavaScript Object.
@@ -2561,7 +2621,7 @@ declare module Immutable {
      *
      * @see `Map#withMutations`
      */
-    withMutations(mutator: (mutable: this) => any): this;
+    withMutations(mutator: (mutable: this) => unknown): this;
     /**
      * @see `Map#asMutable`
@@ -2591,8 +2651,7 @@ declare module Immutable {
    *
    * This is equivalent to an instance of a record created by a Record Factory.
    */
-  export type RecordOf<TProps extends Object> = Record<TProps> &
-    Readonly<TProps>;
+  type RecordOf<TProps extends object> = Record<TProps> & Readonly<TProps>;
   /**
    * `Seq` describes a lazy operation, allowing them to efficiently chain
@@ -2631,7 +2690,7 @@ declare module Immutable {
    * <!-- runkit:activate -->
    * ```js
    * const { Map } = require('immutable')
-   * const map = Map({ a: 1, b: 2, c: 3 }
+   * const map = Map({ a: 1, b: 2, c: 3 })
    * const lazySeq = Seq(map)
    * ```
    *
@@ -2669,18 +2728,22 @@ declare module Immutable {
    * ```
    */
-  export module Seq {
+  namespace Seq {
     /**
      * True if `maybeSeq` is a Seq, it is not backed by a concrete
      * structure such as Map, List, or Set.
      */
-    function isSeq(maybeSeq: any): maybeSeq is Seq.Indexed<any> | Seq.Keyed<any, any> | Seq.Set<any>;
+    function isSeq(
+      maybeSeq: unknown
+    ): maybeSeq is
+      | Seq.Indexed<unknown>
+      | Seq.Keyed<unknown, unknown>
+      | Seq.Set<unknown>;
     /**
      * `Seq` which represents key-value pairs.
      */
-    export module Keyed {}
+    namespace Keyed {}
     /**
      * Always returns a Seq.Keyed, if input is not keyed, expects an
@@ -2689,18 +2752,16 @@ declare module Immutable {
      * Note: `Seq.Keyed` is a conversion function and not a class, and does not
      * use the `new` keyword during construction.
      */
-    export function Keyed<K, V>(collection: Iterable<[K, V]>): Seq.Keyed<K, V>;
-    export function Keyed<V>(obj: {[key: string]: V}): Seq.Keyed<string, V>;
-    export function Keyed<K, V>(): Seq.Keyed<K, V>;
-    export function Keyed(): Seq.Keyed<any, any>;
+    function Keyed<K, V>(collection?: Iterable<[K, V]>): Seq.Keyed<K, V>;
+    function Keyed<V>(obj: { [key: string]: V }): Seq.Keyed<string, V>;
-    export interface Keyed<K, V> extends Seq<K, V>, Collection.Keyed<K, V> {
+    interface Keyed<K, V> extends Seq<K, V>, Collection.Keyed<K, V> {
       /**
        * Deeply converts this Keyed Seq to equivalent native JavaScript Object.
        *
        * Converts keys to Strings.
        */
-      toJS(): Object;
+      toJS(): { [key: string]: unknown };
       /**
        * Shallowly converts this Keyed Seq to equivalent native JavaScript Object.
@@ -2725,8 +2786,12 @@ declare module Immutable {
        * All entries will be present in the resulting Seq, even if they
        * have the same key.
        */
-      concat<KC, VC>(...collections: Array<Iterable<[KC, VC]>>): Seq.Keyed<K | KC, V | VC>;
-      concat<C>(...collections: Array<{[key: string]: C}>): Seq.Keyed<K | string, V | C>;
+      concat<KC, VC>(
+        ...collections: Array<Iterable<[KC, VC]>>
+      ): Seq.Keyed<K | KC, V | VC>;
+      concat<C>(
+        ...collections: Array<{ [key: string]: C }>
+      ): Seq.Keyed<K | string, V | C>;
       /**
        * Returns a new Seq.Keyed with values passed through a
@@ -2743,7 +2808,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: V, key: K, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Seq.Keyed<K, M>;
       /**
@@ -2751,15 +2816,19 @@ declare module Immutable {
        */
       mapKeys<M>(
         mapper: (key: K, value: V, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Seq.Keyed<M, V>;
       /**
        * @see Collection.Keyed.mapEntries
        */
       mapEntries<KM, VM>(
-        mapper: (entry: [K, V], index: number, iter: this) => [KM, VM],
-        context?: any
+        mapper: (
+          entry: [K, V],
+          index: number,
+          iter: this
+        ) => [KM, VM] | undefined,
+        context?: unknown
       ): Seq.Keyed<KM, VM>;
       /**
@@ -2769,7 +2838,7 @@ declare module Immutable {
        */
       flatMap<KM, VM>(
         mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,
-        context?: any
+        context?: unknown
       ): Seq.Keyed<KM, VM>;
       /**
@@ -2781,25 +2850,25 @@ declare module Immutable {
        */
       filter<F extends V>(
         predicate: (value: V, key: K, iter: this) => value is F,
-        context?: any
+        context?: unknown
       ): Seq.Keyed<K, F>;
       filter(
-        predicate: (value: V, key: K, iter: this) => any,
-        context?: any
+        predicate: (value: V, key: K, iter: this) => unknown,
+        context?: unknown
       ): this;
       /**
        * @see Collection.Keyed.flip
        */
       flip(): Seq.Keyed<V, K>;
-    }
+      [Symbol.iterator](): IterableIterator<[K, V]>;
+    }
     /**
      * `Seq` which represents an ordered indexed list of values.
      */
-    module Indexed {
+    namespace Indexed {
       /**
        * Provides an Seq.Indexed of the values provided.
        */
@@ -2813,15 +2882,13 @@ declare module Immutable {
      * Note: `Seq.Indexed` is a conversion function and not a class, and does
      * not use the `new` keyword during construction.
      */
-    export function Indexed(): Seq.Indexed<any>;
-    export function Indexed<T>(): Seq.Indexed<T>;
-    export function Indexed<T>(collection: Iterable<T>): Seq.Indexed<T>;
+    function Indexed<T>(collection: Iterable<T> | ArrayLike<T>): Seq.Indexed<T>;
-    export interface Indexed<T> extends Seq<number, T>, Collection.Indexed<T> {
+    interface Indexed<T> extends Seq<number, T>, Collection.Indexed<T> {
       /**
        * Deeply converts this Indexed Seq to equivalent native JavaScript Array.
        */
-      toJS(): Array<any>;
+      toJS(): Array<unknown>;
       /**
        * Shallowly converts this Indexed Seq to equivalent native JavaScript Array.
@@ -2836,12 +2903,14 @@ declare module Immutable {
       /**
        * Returns itself
        */
-      toSeq(): this
+      toSeq(): this;
       /**
        * Returns a new Seq with other collections concatenated to this one.
        */
-      concat<C>(...valuesOrCollections: Array<Iterable<C> | C>): Seq.Indexed<T | C>;
+      concat<C>(
+        ...valuesOrCollections: Array<Iterable<C> | C>
+      ): Seq.Indexed<T | C>;
       /**
        * Returns a new Seq.Indexed with values passed through a
@@ -2858,7 +2927,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: T, key: number, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Seq.Indexed<M>;
       /**
@@ -2868,7 +2937,7 @@ declare module Immutable {
        */
       flatMap<M>(
         mapper: (value: T, key: number, iter: this) => Iterable<M>,
-        context?: any
+        context?: unknown
       ): Seq.Indexed<M>;
       /**
@@ -2880,11 +2949,11 @@ declare module Immutable {
        */
       filter<F extends T>(
         predicate: (value: T, index: number, iter: this) => value is F,
-        context?: any
+        context?: unknown
       ): Seq.Indexed<F>;
       filter(
-        predicate: (value: T, index: number, iter: this) => any,
-        context?: any
+        predicate: (value: T, index: number, iter: this) => unknown,
+        context?: unknown
       ): this;
       /**
@@ -2898,9 +2967,14 @@ declare module Immutable {
        * const c = a.zip(b); // Seq [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]
        * ```
        */
-      zip<U>(other: Collection<any, U>): Seq.Indexed<[T,U]>;
-      zip<U,V>(other: Collection<any, U>, other2: Collection<any, V>): Seq.Indexed<[T,U,V]>;
-      zip(...collections: Array<Collection<any, any>>): Seq.Indexed<any>;
+      zip<U>(other: Collection<unknown, U>): Seq.Indexed<[T, U]>;
+      zip<U, V>(
+        other: Collection<unknown, U>,
+        other2: Collection<unknown, V>
+      ): Seq.Indexed<[T, U, V]>;
+      zip(
+        ...collections: Array<Collection<unknown, unknown>>
+      ): Seq.Indexed<unknown>;
       /**
        * Returns a Seq "zipped" with the provided collections.
@@ -2914,9 +2988,14 @@ declare module Immutable {
        * const c = a.zipAll(b); // Seq [ [ 1, 3 ], [ 2, 4 ], [ undefined, 5 ] ]
        * ```
        */
-      zipAll<U>(other: Collection<any, U>): Seq.Indexed<[T,U]>;
-      zipAll<U,V>(other: Collection<any, U>, other2: Collection<any, V>): Seq.Indexed<[T,U,V]>;
-      zipAll(...collections: Array<Collection<any, any>>): Seq.Indexed<any>;
+      zipAll<U>(other: Collection<unknown, U>): Seq.Indexed<[T, U]>;
+      zipAll<U, V>(
+        other: Collection<unknown, U>,
+        other2: Collection<unknown, V>
+      ): Seq.Indexed<[T, U, V]>;
+      zipAll(
+        ...collections: Array<Collection<unknown, unknown>>
+      ): Seq.Indexed<unknown>;
       /**
        * Returns a Seq "zipped" with the provided collections by using a
@@ -2931,19 +3010,20 @@ declare module Immutable {
        */
       zipWith<U, Z>(
         zipper: (value: T, otherValue: U) => Z,
-        otherCollection: Collection<any, U>
+        otherCollection: Collection<unknown, U>
       ): Seq.Indexed<Z>;
       zipWith<U, V, Z>(
         zipper: (value: T, otherValue: U, thirdValue: V) => Z,
-        otherCollection: Collection<any, U>,
-        thirdCollection: Collection<any, V>
+        otherCollection: Collection<unknown, U>,
+        thirdCollection: Collection<unknown, V>
       ): Seq.Indexed<Z>;
       zipWith<Z>(
-        zipper: (...any: Array<any>) => Z,
-        ...collections: Array<Collection<any, any>>
+        zipper: (...values: Array<unknown>) => Z,
+        ...collections: Array<Collection<unknown, unknown>>
       ): Seq.Indexed<Z>;
-    }
+      [Symbol.iterator](): IterableIterator<T>;
+    }
     /**
      * `Seq` which represents a set of values.
@@ -2951,8 +3031,7 @@ declare module Immutable {
      * Because `Seq` are often lazy, `Seq.Set` does not provide the same guarantee
      * of value uniqueness as the concrete `Set`.
      */
-    export module Set {
+    namespace Set {
       /**
        * Returns a Seq.Set of the provided values
        */
@@ -2965,15 +3044,13 @@ declare module Immutable {
      * Note: `Seq.Set` is a conversion function and not a class, and does not
      * use the `new` keyword during construction.
      */
-    export function Set(): Seq.Set<any>;
-    export function Set<T>(): Seq.Set<T>;
-    export function Set<T>(collection: Iterable<T>): Seq.Set<T>;
+    function Set<T>(collection: Iterable<T> | ArrayLike<T>): Seq.Set<T>;
-    export interface Set<T> extends Seq<T, T>, Collection.Set<T> {
+    interface Set<T> extends Seq<T, T>, Collection.Set<T> {
       /**
        * Deeply converts this Set Seq to equivalent native JavaScript Array.
        */
-      toJS(): Array<any>;
+      toJS(): Array<unknown>;
       /**
        * Shallowly converts this Set Seq to equivalent native JavaScript Array.
@@ -2988,7 +3065,7 @@ declare module Immutable {
       /**
        * Returns itself
        */
-      toSeq(): this
+      toSeq(): this;
       /**
        * Returns a new Seq with other collections concatenated to this one.
@@ -3012,7 +3089,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: T, key: T, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Seq.Set<M>;
       /**
@@ -3022,7 +3099,7 @@ declare module Immutable {
        */
       flatMap<M>(
         mapper: (value: T, key: T, iter: this) => Iterable<M>,
-        context?: any
+        context?: unknown
       ): Seq.Set<M>;
       /**
@@ -3034,14 +3111,15 @@ declare module Immutable {
        */
       filter<F extends T>(
         predicate: (value: T, key: T, iter: this) => value is F,
-        context?: any
+        context?: unknown
       ): Seq.Set<F>;
       filter(
-        predicate: (value: T, key: T, iter: this) => any,
-        context?: any
+        predicate: (value: T, key: T, iter: this) => unknown,
+        context?: unknown
       ): this;
-    }
+      [Symbol.iterator](): IterableIterator<T>;
+    }
   }
   /**
@@ -3063,16 +3141,16 @@ declare module Immutable {
    * Note: `Seq` is a conversion function and not a class, and does not use the
    * `new` keyword during construction.
    */
-  export function Seq<S extends Seq<any, any>>(seq: S): S;
-  export function Seq<K, V>(collection: Collection.Keyed<K, V>): Seq.Keyed<K, V>;
-  export function Seq<T>(collection: Collection.Indexed<T>): Seq.Indexed<T>;
-  export function Seq<T>(collection: Collection.Set<T>): Seq.Set<T>;
-  export function Seq<T>(collection: Iterable<T>): Seq.Indexed<T>;
-  export function Seq<V>(obj: {[key: string]: V}): Seq.Keyed<string, V>;
-  export function Seq(): Seq<any, any>;
-  export interface Seq<K, V> extends Collection<K, V> {
+  function Seq<S extends Seq<unknown, unknown>>(seq: S): S;
+  function Seq<K, V>(collection: Collection.Keyed<K, V>): Seq.Keyed<K, V>;
+  function Seq<T>(collection: Collection.Set<T>): Seq.Set<T>;
+  function Seq<T>(
+    collection: Collection.Indexed<T> | Iterable<T> | ArrayLike<T>
+  ): Seq.Indexed<T>;
+  function Seq<V>(obj: { [key: string]: V }): Seq.Keyed<string, V>;
+  function Seq(): Seq<unknown, unknown>;
+  interface Seq<K, V> extends Collection<K, V> {
     /**
      * Some Seqs can describe their size lazily. When this is the case,
      * size will be an integer. Otherwise it will be undefined.
@@ -3085,7 +3163,6 @@ declare module Immutable {
      */
     readonly size: number | undefined;
     // Force evaluation
     /**
@@ -3127,7 +3204,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: V, key: K, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Seq<K, M>;
     /**
@@ -3146,7 +3223,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: V, key: K, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Seq<M, M>;
     /**
@@ -3156,7 +3233,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: V, key: K, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): Seq<K, M>;
     /**
@@ -3167,7 +3244,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: V, key: K, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): Seq<M, M>;
     /**
@@ -3179,11 +3256,11 @@ declare module Immutable {
      */
     filter<F extends V>(
       predicate: (value: V, key: K, iter: this) => value is F,
-      context?: any
+      context?: unknown
     ): Seq<K, F>;
     filter(
-      predicate: (value: V, key: K, iter: this) => any,
-      context?: any
+      predicate: (value: V, key: K, iter: this) => unknown,
+      context?: unknown
     ): this;
   }
@@ -3201,28 +3278,34 @@ declare module Immutable {
    * Implementations should extend one of the subclasses, `Collection.Keyed`,
    * `Collection.Indexed`, or `Collection.Set`.
    */
-  export module Collection {
+  namespace Collection {
     /**
      * @deprecated use `const { isKeyed } = require('immutable')`
      */
-    function isKeyed(maybeKeyed: any): maybeKeyed is Collection.Keyed<any, any>;
+    function isKeyed(
+      maybeKeyed: unknown
+    ): maybeKeyed is Collection.Keyed<unknown, unknown>;
     /**
      * @deprecated use `const { isIndexed } = require('immutable')`
      */
-    function isIndexed(maybeIndexed: any): maybeIndexed is Collection.Indexed<any>;
+    function isIndexed(
+      maybeIndexed: unknown
+    ): maybeIndexed is Collection.Indexed<unknown>;
     /**
      * @deprecated use `const { isAssociative } = require('immutable')`
      */
-    function isAssociative(maybeAssociative: any): maybeAssociative is Collection.Keyed<any, any> | Collection.Indexed<any>;
+    function isAssociative(
+      maybeAssociative: unknown
+    ): maybeAssociative is
+      | Collection.Keyed<unknown, unknown>
+      | Collection.Indexed<unknown>;
     /**
      * @deprecated use `const { isOrdered } = require('immutable')`
      */
-    function isOrdered(maybeOrdered: any): boolean;
+    function isOrdered(maybeOrdered: unknown): boolean;
     /**
      * Keyed Collections have discrete keys tied to each value.
@@ -3231,7 +3314,7 @@ declare module Immutable {
      * tuple, in other words, `Collection#entries` is the default iterator for
      * Keyed Collections.
      */
-    export module Keyed {}
+    namespace Keyed {}
     /**
      * Creates a Collection.Keyed
@@ -3242,16 +3325,16 @@ declare module Immutable {
      * Note: `Collection.Keyed` is a conversion function and not a class, and
      * does not use the `new` keyword during construction.
      */
-    export function Keyed<K, V>(collection: Iterable<[K, V]>): Collection.Keyed<K, V>;
-    export function Keyed<V>(obj: {[key: string]: V}): Collection.Keyed<string, V>;
+    function Keyed<K, V>(collection: Iterable<[K, V]>): Collection.Keyed<K, V>;
+    function Keyed<V>(obj: { [key: string]: V }): Collection.Keyed<string, V>;
-    export interface Keyed<K, V> extends Collection<K, V> {
+    interface Keyed<K, V> extends Collection<K, V> {
       /**
        * Deeply converts this Keyed collection to equivalent native JavaScript Object.
        *
        * Converts keys to Strings.
        */
-      toJS(): Object;
+      toJS(): { [key: string]: unknown };
       /**
        * Shallowly converts this Keyed collection to equivalent native JavaScript Object.
@@ -3271,7 +3354,6 @@ declare module Immutable {
        */
       toSeq(): Seq.Keyed<K, V>;
       // Sequence functions
       /**
@@ -3290,8 +3372,12 @@ declare module Immutable {
       /**
        * Returns a new Collection with other collections concatenated to this one.
        */
-      concat<KC, VC>(...collections: Array<Iterable<[KC, VC]>>): Collection.Keyed<K | KC, V | VC>;
-      concat<C>(...collections: Array<{[key: string]: C}>): Collection.Keyed<K | string, V | C>;
+      concat<KC, VC>(
+        ...collections: Array<Iterable<[KC, VC]>>
+      ): Collection.Keyed<K | KC, V | VC>;
+      concat<C>(
+        ...collections: Array<{ [key: string]: C }>
+      ): Collection.Keyed<K | string, V | C>;
       /**
        * Returns a new Collection.Keyed with values passed through a
@@ -3308,7 +3394,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: V, key: K, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Collection.Keyed<K, M>;
       /**
@@ -3327,7 +3413,7 @@ declare module Immutable {
        */
       mapKeys<M>(
         mapper: (key: K, value: V, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Collection.Keyed<M, V>;
       /**
@@ -3344,10 +3430,16 @@ declare module Immutable {
        *
        * Note: `mapEntries()` always returns a new instance, even if it produced
        * the same entry at every step.
+       *
+       * If the mapper function returns `undefined`, then the entry will be filtered
        */
       mapEntries<KM, VM>(
-        mapper: (entry: [K, V], index: number, iter: this) => [KM, VM],
-        context?: any
+        mapper: (
+          entry: [K, V],
+          index: number,
+          iter: this
+        ) => [KM, VM] | undefined,
+        context?: unknown
       ): Collection.Keyed<KM, VM>;
       /**
@@ -3357,7 +3449,7 @@ declare module Immutable {
        */
       flatMap<KM, VM>(
         mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,
-        context?: any
+        context?: unknown
       ): Collection.Keyed<KM, VM>;
       /**
@@ -3369,17 +3461,16 @@ declare module Immutable {
        */
       filter<F extends V>(
         predicate: (value: V, key: K, iter: this) => value is F,
-        context?: any
+        context?: unknown
       ): Collection.Keyed<K, F>;
       filter(
-        predicate: (value: V, key: K, iter: this) => any,
-        context?: any
+        predicate: (value: V, key: K, iter: this) => unknown,
+        context?: unknown
       ): this;
       [Symbol.iterator](): IterableIterator<[K, V]>;
     }
     /**
      * Indexed Collections have incrementing numeric keys. They exhibit
      * slightly different behavior than `Collection.Keyed` for some methods in order
@@ -3395,7 +3486,7 @@ declare module Immutable {
      * preserve indices, using them as keys, convert to a Collection.Keyed by
      * calling `toKeyedSeq`.
      */
-    export module Indexed {}
+    namespace Indexed {}
     /**
      * Creates a new Collection.Indexed.
@@ -3403,13 +3494,15 @@ declare module Immutable {
      * Note: `Collection.Indexed` is a conversion function and not a class, and
      * does not use the `new` keyword during construction.
      */
-    export function Indexed<T>(collection: Iterable<T>): Collection.Indexed<T>;
+    function Indexed<T>(
+      collection: Iterable<T> | ArrayLike<T>
+    ): Collection.Indexed<T>;
-    export interface Indexed<T> extends Collection<number, T> {
+    interface Indexed<T> extends Collection<number, T> {
       /**
        * Deeply converts this Indexed collection to equivalent native JavaScript Array.
        */
-      toJS(): Array<any>;
+      toJS(): Array<unknown>;
       /**
        * Shallowly converts this Indexed collection to equivalent native JavaScript Array.
@@ -3433,7 +3526,6 @@ declare module Immutable {
       get<NSV>(index: number, notSetValue: NSV): T | NSV;
       get(index: number): T | undefined;
       // Conversion to Seq
       /**
@@ -3446,8 +3538,7 @@ declare module Immutable {
        * If this is a collection of [key, value] entry tuples, it will return a
        * Seq.Keyed of those entries.
        */
-      fromEntrySeq(): Seq.Keyed<any, any>;
+      fromEntrySeq(): Seq.Keyed<unknown, unknown>;
       // Combination
@@ -3470,7 +3561,7 @@ declare module Immutable {
        * ```js
        * const { List } = require('immutable')
        * List([ 1, 2, 3 ]).interleave(List([ 'A', 'B', 'C' ]))
-       * // List [ 1, "A", 2, "B", 3, "C"" ]
+       * // List [ 1, "A", 2, "B", 3, "C" ]
        * ```
        *
        * The shortest Collection stops interleave.
@@ -3483,7 +3574,7 @@ declare module Immutable {
        *   List([ 'A', 'B' ]),
        *   List([ 'X', 'Y', 'Z' ])
        * )
-       * // List [ 1, "A", "X", 2, "B", "Y"" ]
+       * // List [ 1, "A", "X", 2, "B", "Y" ]
        * ```
        *
        * Since `interleave()` re-indexes values, it produces a complete copy,
@@ -3491,7 +3582,7 @@ declare module Immutable {
        *
        * Note: `interleave` *cannot* be used in `withMutations`.
        */
-      interleave(...collections: Array<Collection<any, T>>): this;
+      interleave(...collections: Array<Collection<unknown, T>>): this;
       /**
        * Splice returns a new indexed Collection by replacing a region of this
@@ -3513,11 +3604,7 @@ declare module Immutable {
        *
        * Note: `splice` *cannot* be used in `withMutations`.
        */
-      splice(
-        index: number,
-        removeNum: number,
-        ...values: Array<T>
-      ): this;
+      splice(index: number, removeNum: number, ...values: Array<T>): this;
       /**
        * Returns a Collection of the same type "zipped" with the provided
@@ -3535,9 +3622,14 @@ declare module Immutable {
        * const c = a.zip(b); // List [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]
        * ```
        */
-      zip<U>(other: Collection<any, U>): Collection.Indexed<[T,U]>;
-      zip<U,V>(other: Collection<any, U>, other2: Collection<any, V>): Collection.Indexed<[T,U,V]>;
-      zip(...collections: Array<Collection<any, any>>): Collection.Indexed<any>;
+      zip<U>(other: Collection<unknown, U>): Collection.Indexed<[T, U]>;
+      zip<U, V>(
+        other: Collection<unknown, U>,
+        other2: Collection<unknown, V>
+      ): Collection.Indexed<[T, U, V]>;
+      zip(
+        ...collections: Array<Collection<unknown, unknown>>
+      ): Collection.Indexed<unknown>;
       /**
        * Returns a Collection "zipped" with the provided collections.
@@ -3551,9 +3643,14 @@ declare module Immutable {
        * const c = a.zipAll(b); // List [ [ 1, 3 ], [ 2, 4 ], [ undefined, 5 ] ]
        * ```
        */
-      zipAll<U>(other: Collection<any, U>): Collection.Indexed<[T,U]>;
-      zipAll<U,V>(other: Collection<any, U>, other2: Collection<any, V>): Collection.Indexed<[T,U,V]>;
-      zipAll(...collections: Array<Collection<any, any>>): Collection.Indexed<any>;
+      zipAll<U>(other: Collection<unknown, U>): Collection.Indexed<[T, U]>;
+      zipAll<U, V>(
+        other: Collection<unknown, U>,
+        other2: Collection<unknown, V>
+      ): Collection.Indexed<[T, U, V]>;
+      zipAll(
+        ...collections: Array<Collection<unknown, unknown>>
+      ): Collection.Indexed<unknown>;
       /**
        * Returns a Collection of the same type "zipped" with the provided
@@ -3571,19 +3668,18 @@ declare module Immutable {
        */
       zipWith<U, Z>(
         zipper: (value: T, otherValue: U) => Z,
-        otherCollection: Collection<any, U>
+        otherCollection: Collection<unknown, U>
       ): Collection.Indexed<Z>;
       zipWith<U, V, Z>(
         zipper: (value: T, otherValue: U, thirdValue: V) => Z,
-        otherCollection: Collection<any, U>,
-        thirdCollection: Collection<any, V>
+        otherCollection: Collection<unknown, U>,
+        thirdCollection: Collection<unknown, V>
       ): Collection.Indexed<Z>;
       zipWith<Z>(
-        zipper: (...any: Array<any>) => Z,
-        ...collections: Array<Collection<any, any>>
+        zipper: (...values: Array<unknown>) => Z,
+        ...collections: Array<Collection<unknown, unknown>>
       ): Collection.Indexed<Z>;
       // Search for value
       /**
@@ -3604,7 +3700,7 @@ declare module Immutable {
        */
       findIndex(
         predicate: (value: T, index: number, iter: this) => boolean,
-        context?: any
+        context?: unknown
       ): number;
       /**
@@ -3613,7 +3709,7 @@ declare module Immutable {
        */
       findLastIndex(
         predicate: (value: T, index: number, iter: this) => boolean,
-        context?: any
+        context?: unknown
       ): number;
       // Sequence algorithms
@@ -3621,7 +3717,9 @@ declare module Immutable {
       /**
        * Returns a new Collection with other collections concatenated to this one.
        */
-      concat<C>(...valuesOrCollections: Array<Iterable<C> | C>): Collection.Indexed<T | C>;
+      concat<C>(
+        ...valuesOrCollections: Array<Iterable<C> | C>
+      ): Collection.Indexed<T | C>;
       /**
        * Returns a new Collection.Indexed with values passed through a
@@ -3638,7 +3736,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: T, key: number, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Collection.Indexed<M>;
       /**
@@ -3648,7 +3746,7 @@ declare module Immutable {
        */
       flatMap<M>(
         mapper: (value: T, key: number, iter: this) => Iterable<M>,
-        context?: any
+        context?: unknown
       ): Collection.Indexed<M>;
       /**
@@ -3660,17 +3758,16 @@ declare module Immutable {
        */
       filter<F extends T>(
         predicate: (value: T, index: number, iter: this) => value is F,
-        context?: any
+        context?: unknown
       ): Collection.Indexed<F>;
       filter(
-        predicate: (value: T, index: number, iter: this) => any,
-        context?: any
+        predicate: (value: T, index: number, iter: this) => unknown,
+        context?: unknown
       ): this;
       [Symbol.iterator](): IterableIterator<T>;
     }
     /**
      * Set Collections only represent values. They have no associated keys or
      * indices. Duplicate values are possible in the lazy `Seq.Set`s, however
@@ -3688,7 +3785,7 @@ declare module Immutable {
      * )
      * ```
      */
-    export module Set {}
+    namespace Set {}
     /**
      * Similar to `Collection()`, but always returns a Collection.Set.
@@ -3696,13 +3793,13 @@ declare module Immutable {
      * Note: `Collection.Set` is a factory function and not a class, and does
      * not use the `new` keyword during construction.
      */
-    export function Set<T>(collection: Iterable<T>): Collection.Set<T>;
+    function Set<T>(collection: Iterable<T> | ArrayLike<T>): Collection.Set<T>;
-    export interface Set<T> extends Collection<T, T> {
+    interface Set<T> extends Collection<T, T> {
       /**
        * Deeply converts this Set collection to equivalent native JavaScript Array.
        */
-      toJS(): Array<any>;
+      toJS(): Array<unknown>;
       /**
        * Shallowly converts this Set collection to equivalent native JavaScript Array.
@@ -3741,7 +3838,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: T, key: T, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Collection.Set<M>;
       /**
@@ -3751,7 +3848,7 @@ declare module Immutable {
        */
       flatMap<M>(
         mapper: (value: T, key: T, iter: this) => Iterable<M>,
-        context?: any
+        context?: unknown
       ): Collection.Set<M>;
       /**
@@ -3763,16 +3860,15 @@ declare module Immutable {
        */
       filter<F extends T>(
         predicate: (value: T, key: T, iter: this) => value is F,
-        context?: any
+        context?: unknown
       ): Collection.Set<F>;
       filter(
-        predicate: (value: T, key: T, iter: this) => any,
-        context?: any
+        predicate: (value: T, key: T, iter: this) => unknown,
+        context?: unknown
       ): this;
       [Symbol.iterator](): IterableIterator<T>;
     }
   }
   /**
@@ -3797,12 +3893,15 @@ declare module Immutable {
    * Note: `Collection` is a conversion function and not a class, and does not
    * use the `new` keyword during construction.
    */
-  export function Collection<I extends Collection<any, any>>(collection: I): I;
-  export function Collection<T>(collection: Iterable<T>): Collection.Indexed<T>;
-  export function Collection<V>(obj: {[key: string]: V}): Collection.Keyed<string, V>;
-  export interface Collection<K, V> extends ValueObject {
+  function Collection<I extends Collection<unknown, unknown>>(collection: I): I;
+  function Collection<T>(
+    collection: Iterable<T> | ArrayLike<T>
+  ): Collection.Indexed<T>;
+  function Collection<V>(obj: {
+    [key: string]: V;
+  }): Collection.Keyed<string, V>;
+  interface Collection<K, V> extends ValueObject {
     // Value equality
     /**
@@ -3812,7 +3911,7 @@ declare module Immutable {
      * Note: This is equivalent to `Immutable.is(this, other)`, but provided to
      * allow for chained expressions.
      */
-    equals(other: any): boolean;
+    equals(other: unknown): boolean;
     /**
      * Computes and returns the hashed identity for this Collection.
@@ -3836,11 +3935,10 @@ declare module Immutable {
      * to be equal][Hash Collision]. If two values have different `hashCode`s,
      * they must not be equal.
      *
-     * [Hash Collision]: http://en.wikipedia.org/wiki/Collision_(computer_science)
+     * [Hash Collision]: https://en.wikipedia.org/wiki/Collision_(computer_science)
      */
     hashCode(): number;
     // Reading values
     /**
@@ -3874,7 +3972,7 @@ declare module Immutable {
      * In case the `Collection` is empty returns the optional default
      * value if provided, if no default value is provided returns undefined.
      */
-    first<NSV>(notSetValue?: NSV): V | NSV;
+    first<NSV = undefined>(notSetValue?: NSV): V | NSV;
     /**
      * In case the `Collection` is not empty returns the last element of the
@@ -3882,7 +3980,7 @@ declare module Immutable {
      * In case the `Collection` is empty returns the optional default
      * value if provided, if no default value is provided returns undefined.
      */
-    last<NSV>(notSetValue?: NSV): V | NSV;
+    last<NSV = undefined>(notSetValue?: NSV): V | NSV;
     // Reading deep values
@@ -3907,13 +4005,13 @@ declare module Immutable {
      * deepData.getIn(['x', 0, 'y']) // 123
      * ```
      */
-    getIn(searchKeyPath: Iterable<any>, notSetValue?: any): any;
+    getIn(searchKeyPath: Iterable<unknown>, notSetValue?: unknown): unknown;
     /**
      * True if the result of following a path of keys or indices through nested
      * Collections results in a set value.
      */
-    hasIn(searchKeyPath: Iterable<any>): boolean;
+    hasIn(searchKeyPath: Iterable<unknown>): boolean;
     // Persistent changes
@@ -3940,7 +4038,6 @@ declare module Immutable {
      */
     update<R>(updater: (value: this) => R): R;
     // Conversion to JavaScript types
     /**
@@ -3949,7 +4046,7 @@ declare module Immutable {
      * `Collection.Indexed`, and `Collection.Set` become `Array`, while
      * `Collection.Keyed` become `Object`, converting keys to Strings.
      */
-    toJS(): Array<any> | { [key: string]: any };
+    toJS(): Array<unknown> | { [key: string]: unknown };
     /**
      * Shallowly converts this Collection to equivalent native JavaScript Array or Object.
@@ -3974,7 +4071,6 @@ declare module Immutable {
      */
     toObject(): { [key: string]: V };
     // Conversion to Collections
     /**
@@ -4038,7 +4134,6 @@ declare module Immutable {
      */
     toStack(): Stack<V>;
     // Conversion to Seq
     /**
@@ -4081,7 +4176,6 @@ declare module Immutable {
      */
     toSetSeq(): Seq.Set<V>;
     // Iterators
     /**
@@ -4111,6 +4205,7 @@ declare module Immutable {
      */
     entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<unknown>;
     // Collections (Seq)
@@ -4130,7 +4225,6 @@ declare module Immutable {
      */
     entrySeq(): Seq.Indexed<[K, V]>;
     // Sequence algorithms
     /**
@@ -4149,7 +4243,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: V, key: K, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Collection<K, M>;
     /**
@@ -4158,7 +4252,7 @@ declare module Immutable {
      *
      * @ignore
      */
-    map<M>(...args: never[]): any;
+    map(...args: Array<never>): unknown;
     /**
      * Returns a new Collection of the same type with only the entries for which
@@ -4176,11 +4270,11 @@ declare module Immutable {
      */
     filter<F extends V>(
       predicate: (value: V, key: K, iter: this) => value is F,
-      context?: any
+      context?: unknown
     ): Collection<K, F>;
     filter(
-      predicate: (value: V, key: K, iter: this) => any,
-      context?: any
+      predicate: (value: V, key: K, iter: this) => unknown,
+      context?: unknown
     ): this;
     /**
@@ -4199,7 +4293,7 @@ declare module Immutable {
      */
     filterNot(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): this;
     /**
@@ -4246,7 +4340,17 @@ declare module Immutable {
      * Like `sort`, but also accepts a `comparatorValueMapper` which allows for
      * sorting by more sophisticated means:
      *
-     *     hitters.sortBy(hitter => hitter.avgHits)
+     * <!-- runkit:activate -->
+     * ```js
+     * const { Map } = require('immutable')
+     * const beattles = Map({
+     *   John: { name: "Lennon" },
+     *   Paul: { name: "McCartney" },
+     *   George: { name: "Harrison" },
+     *   Ringo: { name: "Starr" },
+     * });
+     * beattles.sortBy(member => member.name);
+     * ```
      *
      * Note: `sortBy()` Always returns a new instance, even if the original was
      * already sorted.
@@ -4284,9 +4388,8 @@ declare module Immutable {
      */
     groupBy<G>(
       grouper: (value: V, key: K, iter: this) => G,
-      context?: any
-    ): /*Map*/Seq.Keyed<G, /*this*/Collection<K, V>>;
+      context?: unknown
+    ): /*Map*/ Seq.Keyed<G, /*this*/ Collection<K, V>>;
     // Side effects
@@ -4298,11 +4401,10 @@ declare module Immutable {
      * (including the last iteration which returned false).
      */
     forEach(
-      sideEffect: (value: V, key: K, iter: this) => any,
-      context?: any
+      sideEffect: (value: V, key: K, iter: this) => unknown,
+      context?: unknown
     ): number;
     // Creating subsets
     /**
@@ -4356,12 +4458,12 @@ declare module Immutable {
      * const { List } = require('immutable')
      * List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
      *   .skipWhile(x => x.match(/g/))
-     * // List [ "cat", "hat", "god"" ]
+     * // List [ "cat", "hat", "god" ]
      * ```
      */
     skipWhile(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): this;
     /**
@@ -4373,12 +4475,12 @@ declare module Immutable {
      * const { List } = require('immutable')
      * List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
      *   .skipUntil(x => x.match(/hat/))
-     * // List [ "hat", "god"" ]
+     * // List [ "hat", "god" ]
      * ```
      */
     skipUntil(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): this;
     /**
@@ -4407,7 +4509,7 @@ declare module Immutable {
      */
     takeWhile(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): this;
     /**
@@ -4424,10 +4526,9 @@ declare module Immutable {
      */
     takeUntil(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): this;
     // Combination
     /**
@@ -4437,7 +4538,9 @@ declare module Immutable {
      * For Seqs, all entries will be present in the resulting Seq, even if they
      * have the same key.
      */
-    concat(...valuesOrCollections: Array<any>): Collection<any, any>;
+    concat(
+      ...valuesOrCollections: Array<unknown>
+    ): Collection<unknown, unknown>;
     /**
      * Flattens nested Collections.
@@ -4449,11 +4552,12 @@ declare module Immutable {
      *
      * Flattens only others Collection, not Arrays or Objects.
      *
-     * Note: `flatten(true)` operates on Collection<any, Collection<K, V>> and
+     * Note: `flatten(true)` operates on Collection<unknown, Collection<K, V>> and
      * returns Collection<K, V>
      */
-    flatten(depth?: number): Collection<any, any>;
-    flatten(shallow?: boolean): Collection<any, any>;
+    flatten(depth?: number): Collection<unknown, unknown>;
+    // tslint:disable-next-line unified-signatures
+    flatten(shallow?: boolean): Collection<unknown, unknown>;
     /**
      * Flat-maps the Collection, returning a Collection of the same type.
@@ -4462,7 +4566,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: V, key: K, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): Collection<K, M>;
     /**
@@ -4473,7 +4577,7 @@ declare module Immutable {
      */
     flatMap<KM, VM>(
       mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,
-      context?: any
+      context?: unknown
     ): Collection<KM, VM>;
     // Reducing a value
@@ -4490,7 +4594,7 @@ declare module Immutable {
     reduce<R>(
       reducer: (reduction: R, value: V, key: K, iter: this) => R,
       initialReduction: R,
-      context?: any
+      context?: unknown
     ): R;
     reduce<R>(
       reducer: (reduction: V | R, value: V, key: K, iter: this) => R
@@ -4505,7 +4609,7 @@ declare module Immutable {
     reduceRight<R>(
       reducer: (reduction: R, value: V, key: K, iter: this) => R,
       initialReduction: R,
-      context?: any
+      context?: unknown
     ): R;
     reduceRight<R>(
       reducer: (reduction: V | R, value: V, key: K, iter: this) => R
@@ -4516,7 +4620,7 @@ declare module Immutable {
      */
     every(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): boolean;
     /**
@@ -4524,7 +4628,7 @@ declare module Immutable {
      */
     some(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): boolean;
     /**
@@ -4554,7 +4658,7 @@ declare module Immutable {
     count(): number;
     count(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): number;
     /**
@@ -4565,10 +4669,9 @@ declare module Immutable {
      */
     countBy<G>(
       grouper: (value: V, key: K, iter: this) => G,
-      context?: any
+      context?: unknown
     ): Map<G, number>;
     // Search for value
     /**
@@ -4576,7 +4679,7 @@ declare module Immutable {
      */
     find(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any,
+      context?: unknown,
       notSetValue?: V
     ): V | undefined;
@@ -4587,7 +4690,7 @@ declare module Immutable {
      */
     findLast(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any,
+      context?: unknown,
       notSetValue?: V
     ): V | undefined;
@@ -4596,7 +4699,7 @@ declare module Immutable {
      */
     findEntry(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any,
+      context?: unknown,
       notSetValue?: V
     ): [K, V] | undefined;
@@ -4608,7 +4711,7 @@ declare module Immutable {
      */
     findLastEntry(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any,
+      context?: unknown,
       notSetValue?: V
     ): [K, V] | undefined;
@@ -4617,7 +4720,7 @@ declare module Immutable {
      */
     findKey(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): K | undefined;
     /**
@@ -4627,7 +4730,7 @@ declare module Immutable {
      */
     findLastKey(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): K | undefined;
     /**
@@ -4661,8 +4764,16 @@ declare module Immutable {
      * Like `max`, but also accepts a `comparatorValueMapper` which allows for
      * comparing by more sophisticated means:
      *
-     *     hitters.maxBy(hitter => hitter.avgHits);
-     *
+     * <!-- runkit:activate -->
+     * ```js
+     * const { List, } = require('immutable');
+     * const l = List([
+     *   { name: 'Bob', avgHit: 1 },
+     *   { name: 'Max', avgHit: 3 },
+     *   { name: 'Lili', avgHit: 2 } ,
+     * ]);
+     * l.maxBy(i => i.avgHit); // will output { name: 'Max', avgHit: 3 }
+     * ```
      */
     maxBy<C>(
       comparatorValueMapper: (value: V, key: K, iter: this) => C,
@@ -4690,15 +4801,22 @@ declare module Immutable {
      * Like `min`, but also accepts a `comparatorValueMapper` which allows for
      * comparing by more sophisticated means:
      *
-     *     hitters.minBy(hitter => hitter.avgHits);
-     *
+     * <!-- runkit:activate -->
+     * ```js
+     * const { List, } = require('immutable');
+     * const l = List([
+     *   { name: 'Bob', avgHit: 1 },
+     *   { name: 'Max', avgHit: 3 },
+     *   { name: 'Lili', avgHit: 2 } ,
+     * ]);
+     * l.minBy(i => i.avgHit); // will output { name: 'Bob', avgHit: 1 }
+     * ```
      */
     minBy<C>(
       comparatorValueMapper: (value: V, key: K, iter: this) => C,
       comparator?: (valueA: C, valueB: C) => number
     ): V | undefined;
     // Comparison
     /**
@@ -4715,7 +4833,7 @@ declare module Immutable {
   /**
    * The interface to fulfill to qualify as a Value Object.
    */
-  export interface ValueObject {
+  interface ValueObject {
     /**
      * True if this and the other Collection have value equality, as defined
      * by `Immutable.is()`.
@@ -4723,7 +4841,7 @@ declare module Immutable {
      * Note: This is equivalent to `Immutable.is(this, other)`, but provided to
      * allow for chained expressions.
      */
-    equals(other: any): boolean;
+    equals(other: unknown): boolean;
     /**
      * Computes and returns the hashed identity for this Collection.
@@ -4754,7 +4872,7 @@ declare module Immutable {
      * organize their internal data structures, while all Immutable.js
      * collections use equality during lookups.
      *
-     * [Hash Collision]: http://en.wikipedia.org/wiki/Collision_(computer_science)
+     * [Hash Collision]: https://en.wikipedia.org/wiki/Collision_(computer_science)
      */
     hashCode(): number;
   }
@@ -4762,6 +4880,10 @@ declare module Immutable {
   /**
    * Deeply converts plain JS objects and arrays to Immutable Maps and Lists.
    *
+   * `fromJS` will convert Arrays and [array-like objects][2] to a List, and
+   * plain objects (without a custom prototype) to a Map. [Iterable objects][3]
+   * may be converted to List, Map, or Set.
+   *
    * If a `reviver` is optionally provided, it will be called with every
    * collection as a Seq (beginning with the most nested collections
    * and proceeding to the top-level collection itself), along with the key
@@ -4784,10 +4906,6 @@ declare module Immutable {
    * }
    * ```
    *
-   * `fromJS` is conservative in its conversion. It will only convert
-   * arrays which pass `Array.isArray` to Lists, and only raw objects (no custom
-   * prototype) to Map.
-   *
    * Accordingly, this example converts native JS data to OrderedMap and List:
    *
    * <!-- runkit:activate -->
@@ -4824,15 +4942,19 @@ declare module Immutable {
    *
    * [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#Example.3A_Using_the_reviver_parameter
    *      "Using the reviver parameter"
+   * [2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Indexed_collections#working_with_array-like_objects
+   *      "Working with array-like objects"
+   * [3]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#the_iterable_protocol
+   *      "The iterable protocol"
    */
-  export function fromJS(
-    jsValue: any,
+  function fromJS(
+    jsValue: unknown,
     reviver?: (
       key: string | number,
-      sequence: Collection.Keyed<string, any> | Collection.Indexed<any>,
+      sequence: Collection.Keyed<string, unknown> | Collection.Indexed<unknown>,
       path?: Array<string | number>
-    ) => any
-  ): any;
+    ) => unknown
+  ): Collection<unknown, unknown>;
   /**
    * Value equality check with semantics similar to `Object.is`, but treats
@@ -4859,7 +4981,7 @@ declare module Immutable {
    * Note: Unlike `Object.is`, `Immutable.is` assumes `0` and `-0` are the same
    * value, matching the behavior of ES6 Map key equality.
    */
-  export function is(first: any, second: any): boolean;
+  function is(first: unknown, second: unknown): boolean;
   /**
    * The `hash()` function is an important part of how Immutable determines if
@@ -4883,7 +5005,7 @@ declare module Immutable {
    *
    * *New in Version 4.0*
    */
-  export function hash(value: any): number;
+  function hash(value: unknown): number;
   /**
    * True if `maybeImmutable` is an Immutable Collection or Record.
@@ -4901,7 +5023,9 @@ declare module Immutable {
    * isImmutable(Map().asMutable()); // true
    * ```
    */
-  export function isImmutable(maybeImmutable: any): maybeImmutable is Collection<any, any>;
+  function isImmutable(
+    maybeImmutable: unknown
+  ): maybeImmutable is Collection<unknown, unknown>;
   /**
    * True if `maybeCollection` is a Collection, or any of its subclasses.
@@ -4916,7 +5040,9 @@ declare module Immutable {
    * isCollection(Stack()); // true
    * ```
    */
-  export function isCollection(maybeCollection: any): maybeCollection is Collection<any, any>;
+  function isCollection(
+    maybeCollection: unknown
+  ): maybeCollection is Collection<unknown, unknown>;
   /**
    * True if `maybeKeyed` is a Collection.Keyed, or any of its subclasses.
@@ -4931,7 +5057,9 @@ declare module Immutable {
    * isKeyed(Stack()); // false
    * ```
    */
-  export function isKeyed(maybeKeyed: any): maybeKeyed is Collection.Keyed<any, any>;
+  function isKeyed(
+    maybeKeyed: unknown
+  ): maybeKeyed is Collection.Keyed<unknown, unknown>;
   /**
    * True if `maybeIndexed` is a Collection.Indexed, or any of its subclasses.
@@ -4947,7 +5075,9 @@ declare module Immutable {
    * isIndexed(Set()); // false
    * ```
    */
-  export function isIndexed(maybeIndexed: any): maybeIndexed is Collection.Indexed<any>;
+  function isIndexed(
+    maybeIndexed: unknown
+  ): maybeIndexed is Collection.Indexed<unknown>;
   /**
    * True if `maybeAssociative` is either a Keyed or Indexed Collection.
@@ -4963,7 +5093,11 @@ declare module Immutable {
    * isAssociative(Set()); // false
    * ```
    */
-  export function isAssociative(maybeAssociative: any): maybeAssociative is Collection.Keyed<any, any> | Collection.Indexed<any>;
+  function isAssociative(
+    maybeAssociative: unknown
+  ): maybeAssociative is
+    | Collection.Keyed<unknown, unknown>
+    | Collection.Indexed<unknown>;
   /**
    * True if `maybeOrdered` is a Collection where iteration order is well
@@ -4980,7 +5114,7 @@ declare module Immutable {
    * isOrdered(Set()); // false
    * ```
    */
-  export function isOrdered(maybeOrdered: any): boolean;
+  function isOrdered(maybeOrdered: unknown): boolean;
   /**
    * True if `maybeValue` is a JavaScript Object which has *both* `equals()`
@@ -4989,54 +5123,60 @@ declare module Immutable {
    * Any two instances of *value objects* can be compared for value equality with
    * `Immutable.is()` and can be used as keys in a `Map` or members in a `Set`.
    */
-  export function isValueObject(maybeValue: any): maybeValue is ValueObject;
+  function isValueObject(maybeValue: unknown): maybeValue is ValueObject;
   /**
    * True if `maybeSeq` is a Seq.
    */
-  export function isSeq(maybeSeq: any): maybeSeq is Seq.Indexed<any> | Seq.Keyed<any, any> | Seq.Set<any>;
+  function isSeq(
+    maybeSeq: unknown
+  ): maybeSeq is
+    | Seq.Indexed<unknown>
+    | Seq.Keyed<unknown, unknown>
+    | Seq.Set<unknown>;
   /**
    * True if `maybeList` is a List.
    */
-  export function isList(maybeList: any): maybeList is List<any>;
+  function isList(maybeList: unknown): maybeList is List<unknown>;
   /**
    * True if `maybeMap` is a Map.
    *
    * Also true for OrderedMaps.
    */
-  export function isMap(maybeMap: any): maybeMap is Map<any, any>;
+  function isMap(maybeMap: unknown): maybeMap is Map<unknown, unknown>;
   /**
    * True if `maybeOrderedMap` is an OrderedMap.
    */
-  export function isOrderedMap(maybeOrderedMap: any): maybeOrderedMap is OrderedMap<any, any>;
+  function isOrderedMap(
+    maybeOrderedMap: unknown
+  ): maybeOrderedMap is OrderedMap<unknown, unknown>;
   /**
    * True if `maybeStack` is a Stack.
    */
-  export function isStack(maybeStack: any): maybeStack is Stack<any>;
+  function isStack(maybeStack: unknown): maybeStack is Stack<unknown>;
   /**
    * True if `maybeSet` is a Set.
    *
    * Also true for OrderedSets.
    */
-  export function isSet(maybeSet: any): maybeSet is Set<any>;
+  function isSet(maybeSet: unknown): maybeSet is Set<unknown>;
   /**
    * True if `maybeOrderedSet` is an OrderedSet.
    */
-  export function isOrderedSet(maybeOrderedSet: any): maybeOrderedSet is OrderedSet<any>;
+  function isOrderedSet(
+    maybeOrderedSet: unknown
+  ): maybeOrderedSet is OrderedSet<unknown>;
   /**
    * True if `maybeRecord` is a Record.
    */
-  export function isRecord(maybeRecord: any): maybeRecord is Record<any>;
+  function isRecord(maybeRecord: unknown): maybeRecord is Record<{}>;
   /**
    * Returns the value within the provided collection associated with the
@@ -5053,14 +5193,34 @@ declare module Immutable {
    * get({ x: 123, y: 456 }, 'z', 'ifNotSet') // 'ifNotSet'
    * ```
    */
-  export function get<K, V>(collection: Collection<K, V>, key: K): V | undefined;
-  export function get<K, V, NSV>(collection: Collection<K, V>, key: K, notSetValue: NSV): V | NSV;
-  export function get<TProps, K extends keyof TProps>(record: Record<TProps>, key: K, notSetValue: any): TProps[K];
-  export function get<V>(collection: Array<V>, key: number): V | undefined;
-  export function get<V, NSV>(collection: Array<V>, key: number, notSetValue: NSV): V | NSV;
-  export function get<C extends Object, K extends keyof C>(object: C, key: K, notSetValue: any): C[K];
-  export function get<V>(collection: {[key: string]: V}, key: string): V | undefined;
-  export function get<V, NSV>(collection: {[key: string]: V}, key: string, notSetValue: NSV): V | NSV;
+  function get<K, V>(collection: Collection<K, V>, key: K): V | undefined;
+  function get<K, V, NSV>(
+    collection: Collection<K, V>,
+    key: K,
+    notSetValue: NSV
+  ): V | NSV;
+  function get<TProps extends object, K extends keyof TProps>(
+    record: Record<TProps>,
+    key: K,
+    notSetValue: unknown
+  ): TProps[K];
+  function get<V>(collection: Array<V>, key: number): V | undefined;
+  function get<V, NSV>(
+    collection: Array<V>,
+    key: number,
+    notSetValue: NSV
+  ): V | NSV;
+  function get<C extends object, K extends keyof C>(
+    object: C,
+    key: K,
+    notSetValue: unknown
+  ): C[K];
+  function get<V>(collection: { [key: string]: V }, key: string): V | undefined;
+  function get<V, NSV>(
+    collection: { [key: string]: V },
+    key: string,
+    notSetValue: NSV
+  ): V | NSV;
   /**
    * Returns true if the key is defined in the provided collection.
@@ -5078,7 +5238,7 @@ declare module Immutable {
    * has({ x: 123, y: 456 }, 'z') // false
    * ```
    */
-  export function has(collection: Object, key: any): boolean;
+  function has(collection: object, key: unknown): boolean;
   /**
    * Returns a copy of the collection with the value at key removed.
@@ -5098,11 +5258,21 @@ declare module Immutable {
    * console.log(originalObject) // { x: 123, y: 456 }
    * ```
    */
-  export function remove<K, C extends Collection<K, any>>(collection: C, key: K): C;
-  export function remove<TProps, C extends Record<TProps>, K extends keyof TProps>(collection: C, key: K): C;
-  export function remove<C extends Array<any>>(collection: C, key: number): C;
-  export function remove<C, K extends keyof C>(collection: C, key: K): C;
-  export function remove<C extends {[key: string]: any}, K extends keyof C>(collection: C, key: K): C;
+  function remove<K, C extends Collection<K, unknown>>(
+    collection: C,
+    key: K
+  ): C;
+  function remove<
+    TProps extends object,
+    C extends Record<TProps>,
+    K extends keyof TProps
+  >(collection: C, key: K): C;
+  function remove<C extends Array<unknown>>(collection: C, key: number): C;
+  function remove<C, K extends keyof C>(collection: C, key: K): C;
+  function remove<C extends { [key: string]: unknown }, K extends keyof C>(
+    collection: C,
+    key: K
+  ): C;
   /**
    * Returns a copy of the collection with the value at key set to the provided
@@ -5123,11 +5293,23 @@ declare module Immutable {
    * console.log(originalObject) // { x: 123, y: 456 }
    * ```
    */
-  export function set<K, V, C extends Collection<K, V>>(collection: C, key: K, value: V): C;
-  export function set<TProps, C extends Record<TProps>, K extends keyof TProps>(record: C, key: K, value: TProps[K]): C;
-  export function set<V, C extends Array<V>>(collection: C, key: number, value: V): C;
-  export function set<C, K extends keyof C>(object: C, key: K, value: C[K]): C;
-  export function set<V, C extends {[key: string]: V}>(collection: C, key: string, value: V): C;
+  function set<K, V, C extends Collection<K, V>>(
+    collection: C,
+    key: K,
+    value: V
+  ): C;
+  function set<
+    TProps extends object,
+    C extends Record<TProps>,
+    K extends keyof TProps
+  >(record: C, key: K, value: TProps[K]): C;
+  function set<V, C extends Array<V>>(collection: C, key: number, value: V): C;
+  function set<C, K extends keyof C>(object: C, key: K, value: C[K]): C;
+  function set<V, C extends { [key: string]: V }>(
+    collection: C,
+    key: string,
+    value: V
+  ): C;
   /**
    * Returns a copy of the collection with the value at key set to the result of
@@ -5148,16 +5330,66 @@ declare module Immutable {
    * console.log(originalObject) // { x: 123, y: 456 }
    * ```
    */
-  export function update<K, V, C extends Collection<K, V>>(collection: C, key: K, updater: (value: V) => V): C;
-  export function update<K, V, C extends Collection<K, V>, NSV>(collection: C, key: K, notSetValue: NSV, updater: (value: V | NSV) => V): C;
-  export function update<TProps, C extends Record<TProps>, K extends keyof TProps>(record: C, key: K, updater: (value: TProps[K]) => TProps[K]): C;
-  export function update<TProps, C extends Record<TProps>, K extends keyof TProps, NSV>(record: C, key: K, notSetValue: NSV, updater: (value: TProps[K] | NSV) => TProps[K]): C;
-  export function update<V>(collection: Array<V>, key: number, updater: (value: V) => V): Array<V>;
-  export function update<V, NSV>(collection: Array<V>, key: number, notSetValue: NSV, updater: (value: V | NSV) => V): Array<V>;
-  export function update<C, K extends keyof C>(object: C, key: K, updater: (value: C[K]) => C[K]): C;
-  export function update<C, K extends keyof C, NSV>(object: C, key: K, notSetValue: NSV, updater: (value: C[K] | NSV) => C[K]): C;
-  export function update<V, C extends {[key: string]: V}, K extends keyof C>(collection: C, key: K, updater: (value: V) => V): {[key: string]: V};
-  export function update<V, C extends {[key: string]: V}, K extends keyof C, NSV>(collection: C, key: K, notSetValue: NSV, updater: (value: V | NSV) => V): {[key: string]: V};
+  function update<K, V, C extends Collection<K, V>>(
+    collection: C,
+    key: K,
+    updater: (value: V | undefined) => V
+  ): C;
+  function update<K, V, C extends Collection<K, V>, NSV>(
+    collection: C,
+    key: K,
+    notSetValue: NSV,
+    updater: (value: V | NSV) => V
+  ): C;
+  function update<
+    TProps extends object,
+    C extends Record<TProps>,
+    K extends keyof TProps
+  >(record: C, key: K, updater: (value: TProps[K]) => TProps[K]): C;
+  function update<
+    TProps extends object,
+    C extends Record<TProps>,
+    K extends keyof TProps,
+    NSV
+  >(
+    record: C,
+    key: K,
+    notSetValue: NSV,
+    updater: (value: TProps[K] | NSV) => TProps[K]
+  ): C;
+  function update<V>(
+    collection: Array<V>,
+    key: number,
+    updater: (value: V) => V
+  ): Array<V>;
+  function update<V, NSV>(
+    collection: Array<V>,
+    key: number,
+    notSetValue: NSV,
+    updater: (value: V | NSV) => V
+  ): Array<V>;
+  function update<C, K extends keyof C>(
+    object: C,
+    key: K,
+    updater: (value: C[K]) => C[K]
+  ): C;
+  function update<C, K extends keyof C, NSV>(
+    object: C,
+    key: K,
+    notSetValue: NSV,
+    updater: (value: C[K] | NSV) => C[K]
+  ): C;
+  function update<V, C extends { [key: string]: V }, K extends keyof C>(
+    collection: C,
+    key: K,
+    updater: (value: V) => V
+  ): { [key: string]: V };
+  function update<V, C extends { [key: string]: V }, K extends keyof C, NSV>(
+    collection: C,
+    key: K,
+    notSetValue: NSV,
+    updater: (value: V | NSV) => V
+  ): { [key: string]: V };
   /**
    * Returns the value at the provided key path starting at the provided
@@ -5173,7 +5405,11 @@ declare module Immutable {
    * getIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p'], 'ifNotSet') // 'ifNotSet'
    * ```
    */
-  export function getIn(collection: any, keyPath: Iterable<any>, notSetValue: any): any;
+  function getIn(
+    collection: unknown,
+    keyPath: Iterable<unknown>,
+    notSetValue?: unknown
+  ): unknown;
   /**
    * Returns true if the key path is defined in the provided collection.
@@ -5188,7 +5424,7 @@ declare module Immutable {
    * hasIn({ x: { y: { z: 123 }}}, ['x', 'q', 'p']) // false
    * ```
    */
-  export function hasIn(collection: any, keyPath: Iterable<any>): boolean;
+  function hasIn(collection: unknown, keyPath: Iterable<unknown>): boolean;
   /**
    * Returns a copy of the collection with the value at the key path removed.
@@ -5204,7 +5440,7 @@ declare module Immutable {
    * console.log(original) // { x: { y: { z: 123 }}}
    * ```
    */
-  export function removeIn<C>(collection: C, keyPath: Iterable<any>): C;
+  function removeIn<C>(collection: C, keyPath: Iterable<unknown>): C;
   /**
    * Returns a copy of the collection with the value at the key path set to the
@@ -5221,7 +5457,11 @@ declare module Immutable {
    * console.log(original) // { x: { y: { z: 123 }}}
    * ```
    */
-  export function setIn<C>(collection: C, keyPath: Iterable<any>, value: any): C;
+  function setIn<C>(
+    collection: C,
+    keyPath: Iterable<unknown>,
+    value: unknown
+  ): C;
   /**
    * Returns a copy of the collection with the value at key path set to the
@@ -5238,8 +5478,17 @@ declare module Immutable {
    * console.log(original) // { x: { y: { z: 123 }}}
    * ```
    */
-  export function updateIn<C>(collection: C, keyPath: Iterable<any>, updater: (value: any) => any): C;
-  export function updateIn<C>(collection: C, keyPath: Iterable<any>, notSetValue: any, updater: (value: any) => any): C;
+  function updateIn<C>(
+    collection: C,
+    keyPath: Iterable<unknown>,
+    updater: (value: unknown) => unknown
+  ): C;
+  function updateIn<C>(
+    collection: C,
+    keyPath: Iterable<unknown>,
+    notSetValue: unknown,
+    updater: (value: unknown) => unknown
+  ): C;
   /**
    * Returns a copy of the collection with the remaining collections merged in.
@@ -5255,9 +5504,13 @@ declare module Immutable {
    * console.log(original) // { x: 123, y: 456 }
    * ```
    */
-  export function merge<C>(
+  function merge<C>(
     collection: C,
-    ...collections: Array<Iterable<any> | Iterable<[any, any]> | {[key: string]: any}>
+    ...collections: Array<
+      | Iterable<unknown>
+      | Iterable<[unknown, unknown]>
+      | { [key: string]: unknown }
+    >
   ): C;
   /**
@@ -5279,15 +5532,29 @@ declare module Immutable {
    * console.log(original) // { x: 123, y: 456 }
    * ```
    */
-  export function mergeWith<C>(
-    merger: (oldVal: any, newVal: any, key: any) => any,
+  function mergeWith<C>(
+    merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown,
     collection: C,
-    ...collections: Array<Iterable<any> | Iterable<[any, any]> | {[key: string]: any}>
+    ...collections: Array<
+      | Iterable<unknown>
+      | Iterable<[unknown, unknown]>
+      | { [key: string]: unknown }
+    >
   ): C;
   /**
-   * Returns a copy of the collection with the remaining collections merged in
-   * deeply (recursively).
+   * Like `merge()`, but when two compatible collections are encountered with
+   * the same key, it merges them as well, recursing deeply through the nested
+   * data. Two collections are considered to be compatible (and thus will be
+   * merged together) if they both fall into one of three categories: keyed
+   * (e.g., `Map`s, `Record`s, and objects), indexed (e.g., `List`s and
+   * arrays), or set-like (e.g., `Set`s). If they fall into separate
+   * categories, `mergeDeep` will replace the existing collection with the
+   * collection being merged in. This behavior can be customized by using
+   * `mergeDeepWith()`.
+   *
+   * Note: Indexed and set-like collections are merged using
+   * `concat()`/`union()` and therefore do not recurse.
    *
    * A functional alternative to `collection.mergeDeep()` which will also work
    * with plain Objects and Arrays.
@@ -5300,15 +5567,20 @@ declare module Immutable {
    * console.log(original) // { x: { y: 123 }}
    * ```
    */
-  export function mergeDeep<C>(
+  function mergeDeep<C>(
     collection: C,
-    ...collections: Array<Iterable<any> | Iterable<[any, any]> | {[key: string]: any}>
+    ...collections: Array<
+      | Iterable<unknown>
+      | Iterable<[unknown, unknown]>
+      | { [key: string]: unknown }
+    >
   ): C;
   /**
-   * Returns a copy of the collection with the remaining collections merged in
-   * deeply (recursively), calling the `merger` function whenever an existing
-   * value is encountered.
+   * Like `mergeDeep()`, but when two non-collections or incompatible
+   * collections are encountered at the same key, it uses the `merger` function
+   * to determine the resulting value. Collections are considered incompatible
+   * if they fall into separate categories between keyed, indexed, and set-like.
    *
    * A functional alternative to `collection.mergeDeepWith()` which will also
    * work with plain Objects and Arrays.
@@ -5325,13 +5597,37 @@ declare module Immutable {
    * console.log(original) // { x: { y: 123 }}
    * ```
    */
-  export function mergeDeepWith<C>(
-    merger: (oldVal: any, newVal: any, key: any) => any,
+  function mergeDeepWith<C>(
+    merger: (oldVal: unknown, newVal: unknown, key: unknown) => unknown,
     collection: C,
-    ...collections: Array<Iterable<any> | Iterable<[any, any]> | {[key: string]: any}>
+    ...collections: Array<
+      | Iterable<unknown>
+      | Iterable<[unknown, unknown]>
+      | { [key: string]: unknown }
+    >
   ): C;
 }
-declare module "immutable" {
-  export = Immutable
-}
+/**
+ * Defines the main export of the immutable module to be the Immutable namespace
+ * This supports many common module import patterns:
+ *
+ *     const Immutable = require("immutable");
+ *     const { List } = require("immutable");
+ *     import Immutable from "immutable";
+ *     import * as Immutable from "immutable";
+ *     import { List } from "immutable";
+ *
+ */
+export = Immutable;
+/**
+ * A global "Immutable" namespace used by UMD modules which allows the use of
+ * the full Immutable API.
+ *
+ * If using Immutable as an imported module, prefer using:
+ *
+ *     import Immutable from 'immutable'
+ *
+ */
+export as namespace Immutable;