npm - immutable - Versions diffs - 4.0.0-rc.9 → 4.0.0 - Mend

immutable 4.0.0-rc.9 → 4.0.0

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 +255 -174
package/dist/immutable.d.ts +1160 -677
package/dist/immutable.es.js +809 -635
package/dist/immutable.js +5100 -4917
package/dist/immutable.js.flow +972 -287
package/dist/immutable.min.js +53 -36
package/package.json +8 -98
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 -5149

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,14 +66,14 @@
  * `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 ])`.
  *
  *
  * Note: All examples are presented in the modern [ES2015][] version of
- * JavaScript. To run in older browsers, they need to be translated to ES3.
+ * JavaScript. Use tools like Babel to support older browsers.
  *
  * For example:
  *
@@ -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,26 +105,25 @@ 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
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List } = require('immutable@4.0.0-rc.9');
+     * const { List } = require('immutable');
      * List.isList([]); // false
      * 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`.
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List } = require('immutable@4.0.0-rc.9');
+     * const { List } = require('immutable');
      * List.of(1, 2, 3, 4)
      * // List [ 1, 2, 3, 4 ]
      * ```
@@ -141,7 +132,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List } = require('immutable@4.0.0-rc.9');
+     * const { List } = require('immutable');
      * List.of({x:1}, 2, [3], 4)
      * // List [ { x: 1 }, 2, [ 3 ], 4 ]
      * ```
@@ -153,9 +144,12 @@ declare module Immutable {
    * Create a new immutable List containing the values of the provided
    * collection-like.
    *
+   * Note: `List` is a factory function and not a class, and does not use the
+   * `new` keyword during construction.
+   *
    * <!-- runkit:activate -->
    * ```js
-   * const { List, Set } = require('immutable@4.0.0-rc.9')
+   * const { List, Set } = require('immutable')
    *
    * const emptyList = List()
    * // List []
@@ -177,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.
      */
@@ -201,7 +192,7 @@ declare module Immutable {
      * enough to include the `index`.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * const originalList = List([ 0 ]);
@@ -234,7 +225,7 @@ declare module Immutable {
      * Note: `delete` cannot be safely used in IE8
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * List([ 0, 1, 2, 3, 4 ]).delete(0);
@@ -258,7 +249,7 @@ declare module Immutable {
      * This is synonymous with `list.splice(index, 0, value)`.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * List([ 0, 1, 2, 3, 4 ]).insert(6, 5)
@@ -276,7 +267,7 @@ declare module Immutable {
      * Returns a new List with 0 size and no values in constant time.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * List([ 1, 2, 3, 4 ]).clear()
@@ -292,7 +283,7 @@ declare module Immutable {
      * List's `size`.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * List([ 1, 2, 3, 4 ]).push(5)
@@ -325,7 +316,7 @@ declare module Immutable {
      * values ahead to higher indices.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * List([ 2, 3, 4]).unshift(1);
@@ -345,7 +336,7 @@ declare module Immutable {
      * value in this List.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * List([ 0, 1, 2, 3, 4 ]).shift();
@@ -366,7 +357,7 @@ declare module Immutable {
      * List. `v.update(-1)` updates the last item in the List.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * const list = List([ 'a', 'b', 'c' ])
@@ -380,7 +371,7 @@ declare module Immutable {
      * For example, to sum a List after mapping and filtering:
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * function sum(collection) {
@@ -399,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;
     /**
@@ -414,7 +405,6 @@ declare module Immutable {
      */
     setSize(size: number): List<T>;
     // Deep persistent changes
     /**
@@ -426,7 +416,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List } = require('immutable@4.0.0-rc.9')
+     * const { List } = require('immutable')
      * const list = List([ 0, 1, 2, List([ 3, 4 ])])
      * list.setIn([3, 0], 999);
      * // List [ 0, 1, 2, List [ 999, 4 ] ]
@@ -438,7 +428,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List } = require('immutable@4.0.0-rc.9')
+     * const { List } = require('immutable')
      * const list = List([ 0, 1, 2, { plain: 'object' }])
      * list.setIn([3, 'plain'], 'value');
      * // List([ 0, 1, 2, { plain: 'value' }])
@@ -446,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
@@ -454,7 +444,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List } = require('immutable@4.0.0-rc.9')
+     * const { List } = require('immutable')
      * const list = List([ 0, 1, 2, List([ 3, 4 ])])
      * list.deleteIn([3, 0]);
      * // List [ 0, 1, 2, List [ 4 ] ]
@@ -466,7 +456,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List } = require('immutable@4.0.0-rc.9')
+     * const { List } = require('immutable')
      * const list = List([ 0, 1, 2, { plain: 'object' }])
      * list.removeIn([3, 'plain']);
      * // List([ 0, 1, 2, {}])
@@ -476,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
@@ -510,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()
@@ -550,19 +550,16 @@ declare module Immutable {
      * `mapper` function.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * List([ 1, 2 ]).map(x => 10 * x)
      * // List [ 10, 20 ]
      * ```
-     *
-     * Note: `map()` always returns a new instance, even if it produced the same
-     * value at every step.
      */
     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;
     /**
@@ -597,7 +594,7 @@ declare module Immutable {
      * Like `zipWith`, but using the default `zipper`: creating an `Array`.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * const a = List([ 1, 2, 3 ]);
@@ -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.
@@ -616,7 +616,7 @@ declare module Immutable {
      * exhausted. Missing values from shorter collections are filled with `undefined`.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * const a = List([ 1, 2 ]);
@@ -628,16 +628,19 @@ 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
      * custom `zipper` function.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { List } = require('immutable');" }
      * -->
      * ```js
      * const a = List([ 1, 2, 3 ]);
@@ -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.
@@ -678,7 +680,7 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { Map, List } = require('immutable@4.0.0-rc.9');
+   * const { Map, List } = require('immutable');
    * Map().set(List([ 1 ]), 'listofone').get(List([ 1 ]));
    * // 'listofone'
    * ```
@@ -689,26 +691,25 @@ declare module Immutable {
    *
    * Implemented by a hash-array mapped trie.
    */
-  export module Map {
+  namespace Map {
     /**
      * True if the provided value is a Map
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * Map.isMap({}) // false
      * 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
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * Map.of(
      *   'key', 'value',
      *   'numerical value', 3,
@@ -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>;
   }
   /**
@@ -728,9 +729,12 @@ declare module Immutable {
    * Created with the same key value pairs as the provided Collection.Keyed or
    * JavaScript Object or expects a Collection of [K, V] tuple entries.
    *
+   * Note: `Map` is a factory function and not a class, and does not use the
+   * `new` keyword during construction.
+   *
    * <!-- runkit:activate -->
    * ```js
-   * const { Map } = require('immutable@4.0.0-rc.9')
+   * const { Map } = require('immutable')
    * Map({ key: "value" })
    * Map([ [ "key", "value" ] ])
    * ```
@@ -740,7 +744,7 @@ declare module Immutable {
    * quote-less shorthand, while Immutable Maps accept keys of any type.
    *
    * <!-- runkit:activate
-   *      { "preamble": "const { Map } = require('immutable@4.0.0-rc.9');" }
+   *      { "preamble": "const { Map } = require('immutable');" }
    * -->
    * ```js
    * let obj = { 1: "one" }
@@ -755,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.
      */
@@ -776,7 +777,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * const originalMap = Map()
      * const newerMap = originalMap.set('key', 'value')
      * const newestMap = newerMap.set('key', 'newer value')
@@ -801,7 +802,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * const originalMap = Map({
      *   key: 'value',
      *   otherKey: 'other value'
@@ -823,7 +824,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * const names = Map({ a: "Aaron", b: "Barry", c: "Connor" })
      * names.deleteAll([ 'a', 'c' ])
      * // Map { "b": "Barry" }
@@ -841,7 +842,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * Map({ key: 'value' }).clear()
      * // Map {}
      * ```
@@ -858,7 +859,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * const aMap = Map({ key: 'value' })
      * const newMap = aMap.update('key', value => value + value)
      * // Map { "key": "valuevalue" }
@@ -869,7 +870,7 @@ declare module Immutable {
      * `update` and `push` can be used together:
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Map, List } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { Map, List } = require('immutable');" }
      * -->
      * ```js
      * const aMap = Map({ nestedList: List([ 1, 2, 3 ]) })
@@ -881,7 +882,7 @@ declare module Immutable {
      * function when the value at the key does not exist in the Map.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Map } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { Map } = require('immutable');" }
      * -->
      * ```js
      * const aMap = Map({ key: 'value' })
@@ -894,7 +895,7 @@ declare module Immutable {
      * is provided.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Map } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { Map } = require('immutable');" }
      * -->
      * ```js
      * const aMap = Map({ apples: 10 })
@@ -910,7 +911,7 @@ declare module Immutable {
      * The previous example behaves differently when written with default values:
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Map } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { Map } = require('immutable');" }
      * -->
      * ```js
      * const aMap = Map({ apples: 10 })
@@ -922,7 +923,7 @@ declare module Immutable {
      * returned as well.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Map } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { Map } = require('immutable');" }
      * -->
      * ```js
      * const aMap = Map({ key: 'value' })
@@ -936,7 +937,7 @@ declare module Immutable {
      * For example, to sum the values in a Map
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Map } = require('immutable@4.0.0-rc.9');" }
+     *      { "preamble": "const { Map } = require('immutable');" }
      * -->
      * ```js
      * function sum(collection) {
@@ -953,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;
     /**
@@ -966,7 +967,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * const one = Map({ a: 10, b: 20, c: 30 })
      * const two = Map({ b: 40, a: 50, d: 60 })
      * one.merge(two) // Map { "a": 50, "b": 40, "c": 30, "d": 60 }
@@ -977,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
@@ -989,7 +998,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * const one = Map({ a: 10, b: 20, c: 30 })
      * const two = Map({ b: 40, a: 50, d: 60 })
      * one.mergeWith((oldVal, newVal) => oldVal / newVal, two)
@@ -1002,20 +1011,26 @@ 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
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * const one = Map({ a: Map({ x: 10, y: 10 }), b: Map({ x: 20, y: 50 }) })
      * const two = Map({ a: Map({ x: 2 }), b: Map({ y: 5 }), c: Map({ z: 3 }) })
      * one.mergeDeep(two)
@@ -1028,15 +1043,20 @@ 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
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * const one = Map({ a: Map({ x: 10, y: 10 }), b: Map({ x: 20, y: 50 }) })
      * const two = Map({ a: Map({ x: 2 }), b: Map({ y: 5 }), c: Map({ z: 3 }) })
      * one.mergeDeepWith((oldVal, newVal) => oldVal / newVal, two)
@@ -1046,15 +1066,14 @@ declare module Immutable {
      * //   "c": Map { "z": 3 }
      * // }
      * ```
+     *
      * Note: `mergeDeepWith` can be used in `withMutations`.
      */
     mergeDeepWith(
-      merger: (oldVal: V, newVal: V, key: K) => V,
-      ...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
     /**
@@ -1063,7 +1082,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * const originalMap = Map({
      *   subObject: Map({
      *     subKey: 'subvalue',
@@ -1099,7 +1118,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * const originalMap = Map({
      *   subObject: {
      *     subKey: 'subvalue',
@@ -1123,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
@@ -1133,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
@@ -1146,7 +1165,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map, List } = require('immutable@4.0.0-rc.9')
+     * const { Map, List } = require('immutable')
      * const map = Map({ inMap: Map({ inList: List([ 1, 2, 3 ]) }) })
      * const newMap = map.updateIn(['inMap', 'inList'], list => list.push(4))
      * // Map { "inMap": Map { "inList": List [ 1, 2, 3, 4 ] } }
@@ -1158,7 +1177,7 @@ declare module Immutable {
      * provided, otherwise `undefined`.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Map } = require('immutable@4.0.0-rc.9')" }
+     *      { "preamble": "const { Map } = require('immutable')" }
      * -->
      * ```js
      * const map = Map({ a: Map({ b: Map({ c: 10 }) }) })
@@ -1170,7 +1189,7 @@ declare module Immutable {
      * no change will occur. This is still true if `notSetValue` is provided.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Map } = require('immutable@4.0.0-rc.9')" }
+     *      { "preamble": "const { Map } = require('immutable')" }
      * -->
      * ```js
      * const map = Map({ a: Map({ b: Map({ c: 10 }) }) })
@@ -1186,7 +1205,7 @@ declare module Immutable {
      * The previous example behaves differently when written with default values:
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Map } = require('immutable@4.0.0-rc.9')" }
+     *      { "preamble": "const { Map } = require('immutable')" }
      * -->
      * ```js
      * const map = Map({ a: Map({ b: Map({ c: 10 }) }) })
@@ -1199,7 +1218,7 @@ declare module Immutable {
      * immutably by creating new copies of those values with the changes applied.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Map } = require('immutable@4.0.0-rc.9')" }
+     *      { "preamble": "const { Map } = require('immutable')" }
      * -->
      * ```js
      * const map = Map({ a: { b: { c: 10 } } })
@@ -1212,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
@@ -1227,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
@@ -1241,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
@@ -1260,7 +1289,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * const map1 = Map()
      * const map2 = map1.withMutations(map => {
      *   map.set('a', 1).set('b', 2).set('c', 3)
@@ -1273,21 +1302,25 @@ 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
      * a mutable copy of this collection. Mutable copies *always* return `this`,
      * and thus shouldn't be used for equality. Your function should never return
      * a mutable copy of a collection, only use it internally to create a new
-     * collection. If possible, use `withMutations` as it provides an easier to
-     * use API.
+     * collection.
+     *
+     * If possible, use `withMutations` to work with temporary mutable copies as
+     * it provides an easier to use API and considers many common optimizations.
      *
      * Note: if the collection is already mutable, `asMutable` returns itself.
      *
      * Note: Not all methods can be used on a mutable collection or within
      * `withMutations`! Read the documentation for each method to see if it
      * is safe to use in `withMutations`.
+     *
+     * @see `Map#asImmutable`
      */
     asMutable(): this;
@@ -1301,8 +1334,15 @@ declare module Immutable {
     /**
      * The yin to `asMutable`'s yang. Because it applies to mutable collections,
-     * this operation is *mutable* and returns itself. Once performed, the mutable
-     * copy has become immutable and can be safely returned from a function.
+     * this operation is *mutable* and may return itself (though may not
+     * return itself, i.e. if the result is an empty collection). Once
+     * performed, the original mutable copy must no longer be mutated since it
+     * may be the immutable result.
+     *
+     * If possible, use `withMutations` to work with temporary mutable copies as
+     * it provides an easier to use API and considers many common optimizations.
+     *
+     * @see `Map#asMutable`
      */
     asImmutable(): this;
@@ -1314,13 +1354,10 @@ declare module Immutable {
      *
      *     Map({ a: 1, b: 2 }).map(x => 10 * x)
      *     // Map { a: 10, b: 20 }
-     *
-     * Note: `map()` always returns a new instance, even if it produced the same
-     * value at every step.
      */
     map<M>(
       mapper: (value: V, key: K, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Map<K, M>;
     /**
@@ -1328,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>;
     /**
@@ -1346,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>;
     /**
@@ -1358,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;
     /**
@@ -1371,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().
@@ -1383,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>;
   }
   /**
@@ -1404,20 +1444,39 @@ declare module Immutable {
    *     let newOrderedMap = OrderedMap({key: "value"})
    *     let newOrderedMap = OrderedMap([["key", "value"]])
    *
+   * 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.
      */
     readonly size: number;
+    /**
+     * Returns a new OrderedMap also containing the new key, value pair. If an
+     * equivalent key already exists in this OrderedMap, it will be replaced
+     * while maintaining the existing order.
+     *
+     * <!-- runkit:activate -->
+     * ```js
+     * const { OrderedMap } = require('immutable')
+     * const originalMap = OrderedMap({a:1, b:1, c:1})
+     * const updatedMap = originalMap.set('b', 2)
+     *
+     * originalMap
+     * // OrderedMap {a: 1, b: 1, c: 1}
+     * updatedMap
+     * // OrderedMap {a: 1, b: 2, c: 1}
+     * ```
+     *
+     * Note: `set` can be used in `withMutations`.
+     */
+    set(key: K, value: V): this;
     /**
      * Returns a new OrderedMap resulting from merging the provided Collections
      * (or JS objects) into this OrderedMap. In other words, this takes each
@@ -1428,7 +1487,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { OrderedMap } = require('immutable@4.0.0-rc.9')
+     * const { OrderedMap } = require('immutable')
      * const one = OrderedMap({ a: 10, b: 20, c: 30 })
      * const two = OrderedMap({ b: 40, a: 50, d: 60 })
      * one.merge(two) // OrderedMap { "a": 50, "b": 40, "c": 30, "d": 60 }
@@ -1439,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
@@ -1458,7 +1525,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: V, key: K, iter: this) => M,
-      context?: any
+      context?: unknown
     ): OrderedMap<K, M>;
     /**
@@ -1466,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>;
     /**
@@ -1484,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>;
     /**
@@ -1496,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;
     /**
@@ -1509,7 +1580,6 @@ declare module Immutable {
     flip(): OrderedMap<V, K>;
   }
   /**
    * A Collection of unique values with `O(log32 N)` adds and has.
    *
@@ -1521,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`.
@@ -1537,20 +1606,20 @@ 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
      * a collection of other sets.
      *
      * ```js
-     * const { Set } = require('immutable@4.0.0-rc.9')
+     * const { Set } = require('immutable')
      * const intersected = Set.intersect([
      *   Set([ 'a', 'b', 'c' ])
      *   Set([ 'c', 'a', 't' ])
      * ])
-     * // Set [ "a", "c"" ]
+     * // Set [ "a", "c" ]
      * ```
      */
     function intersect<T>(sets: Iterable<Iterable<T>>): Set<T>;
@@ -1560,12 +1629,12 @@ declare module Immutable {
      * collection of other sets.
      *
      * ```js
-     * const { Set } = require('immutable@4.0.0-rc.9')
+     * const { Set } = require('immutable')
      * const unioned = Set.union([
      *   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>;
@@ -1574,13 +1643,13 @@ declare module Immutable {
   /**
    * Create a new immutable Set containing the values of the provided
    * collection-like.
+   *
+   * 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.
      */
@@ -1638,11 +1707,17 @@ declare module Immutable {
     /**
      * Returns a Set excluding any values contained within `collections`.
      *
+     * <!-- runkit:activate -->
+     * ```js
+     * const { OrderedSet } = require('immutable')
+     * OrderedSet([ 1, 2, 3 ]).subtract([1, 3])
+     * // OrderedSet [2]
+     * ```
+     *
      * Note: `subtract` can be used in `withMutations`.
      */
     subtract(...collections: Array<Iterable<T>>): this;
     // Transient changes
     /**
@@ -1652,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
@@ -1681,13 +1756,10 @@ declare module Immutable {
      *
      *     Set([1,2]).map(x => 10 * x)
      *     // Set [10,20]
-     *
-     * Note: `map()` always returns a new instance, even if it produced the same
-     * value at every step.
      */
     map<M>(
       mapper: (value: T, key: T, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Set<M>;
     /**
@@ -1697,7 +1769,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: T, key: T, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): Set<M>;
     /**
@@ -1709,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.
@@ -1728,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`.
@@ -1744,20 +1814,22 @@ 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>;
   }
   /**
    * Create a new immutable OrderedSet containing the values of the provided
    * collection-like.
+   *
+   * 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.
      */
@@ -1783,13 +1855,10 @@ declare module Immutable {
      *
      *     OrderedSet([ 1, 2 ]).map(x => 10 * x)
      *     // OrderedSet [10, 20]
-     *
-     * Note: `map()` always returns a new instance, even if it produced the same
-     * value at every step.
      */
     map<M>(
       mapper: (value: T, key: T, iter: this) => M,
-      context?: any
+      context?: unknown
     ): OrderedSet<M>;
     /**
@@ -1799,7 +1868,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: T, key: T, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): OrderedSet<M>;
     /**
@@ -1811,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;
     /**
@@ -1831,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
@@ -1852,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
@@ -1864,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()`.
@@ -1892,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`.
@@ -1911,13 +1987,13 @@ declare module Immutable {
    *
    * The iteration order of the provided collection is preserved in the
    * resulting `Stack`.
+   *
+   * 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.
      */
@@ -1930,7 +2006,6 @@ declare module Immutable {
      */
     peek(): T | undefined;
     // Persistent changes
     /**
@@ -1984,7 +2059,6 @@ declare module Immutable {
      */
     pop(): Stack<T>;
     // Transient changes
     /**
@@ -1994,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
@@ -2034,7 +2108,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: T, key: number, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Stack<M>;
     /**
@@ -2044,7 +2118,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: T, key: number, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): Stack<M>;
     /**
@@ -2056,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;
     /**
@@ -2074,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.
@@ -2094,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
@@ -2111,27 +2191,29 @@ 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
    * infinity. When `start` is equal to `end`, returns empty range.
    *
+   * Note: `Range` is a factory function and not a class, and does not use the
+   * `new` keyword during construction.
+   *
    * ```js
-   * const { Range } = require('immutable@4.0.0-rc.9')
+   * const { Range } = require('immutable')
    * Range() // [ 0, 1, 2, 3, ... ]
    * Range(10) // [ 10, 11, 12, 13, ... ]
    * Range(10, 15) // [ 10, 11, 12, 13, 14 ]
@@ -2140,21 +2222,26 @@ 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
    * not defined, returns an infinite `Seq` of `value`.
    *
+   * Note: `Repeat` is a factory function and not a class, and does not use the
+   * `new` keyword during construction.
+   *
    * ```js
-   * const { Repeat } = require('immutable@4.0.0-rc.9')
+   * const { Repeat } = require('immutable')
    * Repeat('foo') // [ 'foo', 'foo', 'foo', ... ]
    * 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
@@ -2164,21 +2251,19 @@ declare module Immutable {
    * create Record instances.
    *
    * ```js
-   * const { Record } = require('immutable@4.0.0-rc.9')
+   * const { Record } = require('immutable')
    * const ABRecord = Record({ a: 1, b: 2 })
-   * const myRecord = new ABRecord({ b: 3 })
+   * const myRecord = ABRecord({ b: 3 })
    * ```
    *
    * Records always have a value for the keys they define. `remove`ing a key
    * 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
@@ -2187,7 +2272,7 @@ declare module Immutable {
    * ignored for this record.
    *
    * ```js
-   * const myRecord = new ABRecord({ b: 3, x: 10 })
+   * const myRecord = ABRecord({ b: 3, x: 10 })
    * myRecord.get('x') // undefined
    * ```
    *
@@ -2202,10 +2287,20 @@ declare module Immutable {
    * myRecord.b = 5 // throws Error
    * ```
    *
-   * Record Classes can be extended as well, allowing for custom methods on your
+   * Record Types can be extended as well, allowing for custom methods on your
    * Record. This is not a common pattern in functional environments, but is in
    * many JS programs.
    *
+   * However Record Types are more restricted than typical JavaScript classes.
+   * They do not use a class constructor, which also means they cannot use
+   * class properties (since those are technically part of a constructor).
+   *
+   * While Record Types can be syntactically created with the JavaScript `class`
+   * form, the resulting Record function is actually a factory function, not a
+   * class constructor. Even though Record Types are not classes, JavaScript
+   * currently requires the use of `new` when creating new Record instances if
+   * they are defined as a `class`.
+   *
    * ```
    * class ABRecord extends Record({ a: 1, b: 2 }) {
    *   getAB() {
@@ -2221,12 +2316,12 @@ declare module Immutable {
    * **Flow Typing Records:**
    *
    * Immutable.js exports two Flow types designed to make it easier to use
-   * Records with flow typed code, `RecordOf<T>` and `RecordFactory<TProps>`.
+   * Records with flow typed code, `RecordOf<TProps>` and `RecordFactory<TProps>`.
    *
    * When defining a new kind of Record factory function, use a flow type that
    * describes the values the record contains along with `RecordFactory<TProps>`.
    * To type instances of the Record (which the factory function returns),
-   * use `RecordOf<T>`.
+   * use `RecordOf<TProps>`.
    *
    * Typically, new Record definitions will export both the Record factory
    * function as well as the Record instance type for use in other code.
@@ -2236,7 +2331,8 @@ declare module Immutable {
    *
    * // Use RecordFactory<TProps> for defining new Record factory functions.
    * type Point3DProps = { x: number, y: number, z: number };
-   * const makePoint3D: RecordFactory<Point3DProps> = Record({ x: 0, y: 0, z: 0 });
+   * const defaultValues: Point3DProps = { x: 0, y: 0, z: 0 };
+   * const makePoint3D: RecordFactory<Point3DProps> = Record(defaultValues);
    * export makePoint3D;
    *
    * // Use RecordOf<T> for defining new instances of that Record.
@@ -2244,10 +2340,34 @@ declare module Immutable {
    * const some3DPoint: Point3D = makePoint3D({ x: 10, y: 20, z: 30 });
    * ```
    *
+   * **Flow Typing Record Subclasses:**
+   *
+   * Records can be subclassed as a means to add additional methods to Record
+   * instances. This is generally discouraged in favor of a more functional API,
+   * since Subclasses have some minor overhead. However the ability to create
+   * a rich API on Record types can be quite valuable.
+   *
+   * When using Flow to type Subclasses, do not use `RecordFactory<TProps>`,
+   * instead apply the props type when subclassing:
+   *
+   * ```js
+   * type PersonProps = {name: string, age: number};
+   * const defaultValues: PersonProps = {name: 'Aristotle', age: 2400};
+   * const PersonRecord = Record(defaultValues);
+   * class Person extends PersonRecord<PersonProps> {
+   *   getName(): string {
+   *     return this.get('name')
+   *   }
+   *
+   *   setName(name: string): this {
+   *     return this.set('name', name);
+   *   }
+   * }
+   * ```
    *
    * **Choosing Records vs plain JavaScript objects**
    *
-   * Records ofters a persistently immutable alternative to plain JavaScript
+   * Records offer a persistently immutable alternative to plain JavaScript
    * objects, however they're not required to be used within Immutable.js
    * collections. In fact, the deep-access and deep-updating functions
    * like `getIn()` and `setIn()` work with plain JavaScript Objects as well.
@@ -2282,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
@@ -2296,7 +2415,7 @@ declare module Immutable {
      * method. If one was not provided, the string "Record" is returned.
      *
      * ```js
-     * const { Record } = require('immutable@4.0.0-rc.9')
+     * const { Record } = require('immutable')
      * const Person = Record({
      *   name: null
      * }, 'Person')
@@ -2306,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
@@ -2314,7 +2433,7 @@ declare module Immutable {
      * type:
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Record } = require('immutable@4.0.0-rc.9')" }
+     *      { "preamble": "const { Record } = require('immutable')" }
      * -->
      * ```js
      * // makePerson is a Record Factory function
@@ -2329,7 +2448,7 @@ declare module Immutable {
      * access on the resulting instances:
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Record } = require('immutable@4.0.0-rc.9');const makePerson = Record({ name: null, favoriteColor: 'unknown' });const alan = makePerson({ name: 'Alan' });" }
+     *      { "preamble": "const { Record } = require('immutable');const makePerson = Record({ name: null, favoriteColor: 'unknown' });const alan = makePerson({ name: 'Alan' });" }
      * -->
      * ```js
      * // Use the Record API
@@ -2356,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>;
   }
   /**
@@ -2371,14 +2501,19 @@ declare module Immutable {
    * Record Factory, which is a function that creates Record instances.
    *
    * See above for examples of using `Record()`.
+   *
+   * 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;
+    has(key: string): key is keyof TProps & string;
     /**
      * Returns the value associated with the provided key, which may be the
@@ -2388,32 +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;
     /**
@@ -2433,23 +2576,32 @@ 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
     /**
      * Deeply converts this Record to equivalent native JavaScript Object.
+     *
+     * 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.
@@ -2469,7 +2621,7 @@ declare module Immutable {
      *
      * @see `Map#withMutations`
      */
-    withMutations(mutator: (mutable: this) => any): this;
+    withMutations(mutator: (mutable: this) => unknown): this;
     /**
      * @see `Map#asMutable`
@@ -2493,6 +2645,14 @@ declare module Immutable {
     [Symbol.iterator](): IterableIterator<[keyof TProps, TProps[keyof TProps]]>;
   }
+  /**
+   * RecordOf<T> is used in TypeScript to define interfaces expecting an
+   * instance of record with type T.
+   *
+   * This is equivalent to an instance of a record created by a Record Factory.
+   */
+  type RecordOf<TProps extends object> = Record<TProps> & Readonly<TProps>;
   /**
    * `Seq` describes a lazy operation, allowing them to efficiently chain
    * use of all the higher-order collection methods (such as `map` and `filter`)
@@ -2511,7 +2671,7 @@ declare module Immutable {
    * `Seq`'s values are never iterated:
    *
    * ```js
-   * const { Seq } = require('immutable@4.0.0-rc.9')
+   * const { Seq } = require('immutable')
    * const oddSquares = Seq([ 1, 2, 3, 4, 5, 6, 7, 8 ])
    *   .filter(x => x % 2 !== 0)
    *   .map(x => x * x)
@@ -2530,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)
    * ```
    *
@@ -2550,7 +2710,7 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { Range } = require('immutable@4.0.0-rc.9')
+   * const { Range } = require('immutable')
    * Range(1, Infinity)
    *   .skip(1000)
    *   .map(n => -n)
@@ -2568,35 +2728,40 @@ 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>;
+    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
      * collection of [K, V] tuples.
+     *
+     * 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.
@@ -2621,15 +2786,19 @@ 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
        * `mapper` function.
        *
        * ```js
-       * const { Seq } = require('immutable@4.0.0-rc.9')
+       * const { Seq } = require('immutable')
        * Seq.Keyed({ a: 1, b: 2 }).map(x => 10 * x)
        * // Seq { "a": 10, "b": 20 }
        * ```
@@ -2639,7 +2808,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: V, key: K, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Seq.Keyed<K, M>;
       /**
@@ -2647,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>;
       /**
@@ -2665,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>;
       /**
@@ -2677,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.
        */
@@ -2705,16 +2878,19 @@ declare module Immutable {
     /**
      * Always returns Seq.Indexed, discarding associated keys and
      * supplying incrementing indices.
+     *
+     * 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.
@@ -2729,19 +2905,21 @@ 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
        * `mapper` function.
        *
        * ```js
-       * const { Seq } = require('immutable@4.0.0-rc.9')
+       * const { Seq } = require('immutable')
        * Seq.Indexed([ 1, 2 ]).map(x => 10 * x)
        * // Seq [ 10, 20 ]
        * ```
@@ -2751,7 +2929,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: T, key: number, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Seq.Indexed<M>;
       /**
@@ -2761,7 +2939,7 @@ declare module Immutable {
        */
       flatMap<M>(
         mapper: (value: T, key: number, iter: this) => Iterable<M>,
-        context?: any
+        context?: unknown
       ): Seq.Indexed<M>;
       /**
@@ -2773,11 +2951,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;
       /**
@@ -2791,9 +2969,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.
@@ -2807,9 +2990,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
@@ -2824,19 +3012,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.
@@ -2844,8 +3033,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
        */
@@ -2854,16 +3042,17 @@ declare module Immutable {
     /**
      * Always returns a Seq.Set, discarding associated indices or keys.
+     *
+     * 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.
@@ -2878,7 +3067,7 @@ declare module Immutable {
       /**
        * Returns itself
        */
-      toSeq(): this
+      toSeq(): this;
       /**
        * Returns a new Seq with other collections concatenated to this one.
@@ -2902,7 +3091,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: T, key: T, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Seq.Set<M>;
       /**
@@ -2912,7 +3101,7 @@ declare module Immutable {
        */
       flatMap<M>(
         mapper: (value: T, key: T, iter: this) => Iterable<M>,
-        context?: any
+        context?: unknown
       ): Seq.Set<M>;
       /**
@@ -2924,14 +3113,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>;
+    }
   }
   /**
@@ -2942,21 +3132,27 @@ declare module Immutable {
    *   * If a `Seq`, that same `Seq`.
    *   * If an `Collection`, a `Seq` of the same kind (Keyed, Indexed, or Set).
    *   * If an Array-like, an `Seq.Indexed`.
-   *   * If an Object with an Iterator, an `Seq.Indexed`.
-   *   * If an Iterator, an `Seq.Indexed`.
+   *   * If an Iterable Object, an `Seq.Indexed`.
    *   * If an Object, a `Seq.Keyed`.
    *
+   * Note: An Iterator itself will be treated as an object, becoming a `Seq.Keyed`,
+   * which is usually not what you want. You should turn your Iterator Object into
+   * an iterable object by defining a Symbol.iterator (or @@iterator) method which
+   * returns `this`.
+   *
+   * 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<K = unknown, V = unknown>(): Seq<K, V>;
+  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.
@@ -2969,7 +3165,6 @@ declare module Immutable {
      */
     readonly size: number | undefined;
     // Force evaluation
     /**
@@ -3001,7 +3196,7 @@ declare module Immutable {
      * `mapper` function.
      *
      * ```js
-     * const { Seq } = require('immutable@4.0.0-rc.9')
+     * const { Seq } = require('immutable')
      * Seq([ 1, 2 ]).map(x => 10 * x)
      * // Seq [ 10, 20 ]
      * ```
@@ -3011,7 +3206,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: V, key: K, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Seq<K, M>;
     /**
@@ -3019,7 +3214,7 @@ declare module Immutable {
      * `mapper` function.
      *
      * ```js
-     * const { Seq } = require('immutable@4.0.0-rc.9')
+     * const { Seq } = require('immutable')
      * Seq([ 1, 2 ]).map(x => 10 * x)
      * // Seq [ 10, 20 ]
      * ```
@@ -3030,7 +3225,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: V, key: K, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Seq<M, M>;
     /**
@@ -3040,7 +3235,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: V, key: K, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): Seq<K, M>;
     /**
@@ -3051,7 +3246,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: V, key: K, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): Seq<M, M>;
     /**
@@ -3063,11 +3258,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;
   }
@@ -3085,28 +3280,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@4.0.0-rc.9')`
+     * @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@4.0.0-rc.9')`
+     * @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@4.0.0-rc.9')`
+     * @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@4.0.0-rc.9')`
+     * @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.
@@ -3115,24 +3316,27 @@ 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
      *
      * Similar to `Collection()`, however it expects collection-likes of [K, V]
      * tuples if not constructed from a Collection.Keyed or JS Object.
+     *
+     * 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.
@@ -3152,7 +3356,6 @@ declare module Immutable {
        */
       toSeq(): Seq.Keyed<K, V>;
       // Sequence functions
       /**
@@ -3161,7 +3364,7 @@ declare module Immutable {
        *
        * <!-- runkit:activate -->
        * ```js
-       * const { Map } = require('immutable@4.0.0-rc.9')
+       * const { Map } = require('immutable')
        * Map({ a: 'z', b: 'y' }).flip()
        * // Map { "z": "a", "y": "b" }
        * ```
@@ -3171,15 +3374,19 @@ 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
        * `mapper` function.
        *
        * ```js
-       * const { Collection } = require('immutable@4.0.0-rc.9')
+       * const { Collection } = require('immutable')
        * Collection.Keyed({ a: 1, b: 2 }).map(x => 10 * x)
        * // Seq { "a": 10, "b": 20 }
        * ```
@@ -3189,7 +3396,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: V, key: K, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Collection.Keyed<K, M>;
       /**
@@ -3198,7 +3405,7 @@ declare module Immutable {
        *
        * <!-- runkit:activate -->
        * ```js
-       * const { Map } = require('immutable@4.0.0-rc.9')
+       * const { Map } = require('immutable')
        * Map({ a: 1, b: 2 }).mapKeys(x => x.toUpperCase())
        * // Map { "A": 1, "B": 2 }
        * ```
@@ -3208,7 +3415,7 @@ declare module Immutable {
        */
       mapKeys<M>(
         mapper: (key: K, value: V, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Collection.Keyed<M, V>;
       /**
@@ -3217,7 +3424,7 @@ declare module Immutable {
        *
        * <!-- runkit:activate -->
        * ```js
-       * const { Map } = require('immutable@4.0.0-rc.9')
+       * const { Map } = require('immutable')
        * Map({ a: 1, b: 2 })
        *   .mapEntries(([ k, v ]) => [ k.toUpperCase(), v * 2 ])
        * // Map { "A": 2, "B": 4 }
@@ -3225,10 +3432,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>;
       /**
@@ -3238,7 +3451,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>;
       /**
@@ -3250,17 +3463,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
@@ -3276,18 +3488,23 @@ 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.
+     *
+     * 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.
@@ -3311,7 +3528,6 @@ declare module Immutable {
       get<NSV>(index: number, notSetValue: NSV): T | NSV;
       get(index: number): T | undefined;
       // Conversion to Seq
       /**
@@ -3324,8 +3540,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
@@ -3343,25 +3558,25 @@ declare module Immutable {
        * second from each, etc.
        *
        * <!-- runkit:activate
-       *      { "preamble": "require('immutable@4.0.0-rc.9')"}
+       *      { "preamble": "require('immutable')"}
        * -->
        * ```js
-       * const { List } = require('immutable@4.0.0-rc.9')
+       * 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.
        *
        * <!-- runkit:activate
-       *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9')" }
+       *      { "preamble": "const { List } = require('immutable')" }
        * -->
        * ```js
        * List([ 1, 2, 3 ]).interleave(
        *   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,
@@ -3369,7 +3584,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
@@ -3381,7 +3596,7 @@ declare module Immutable {
        *
        * <!-- runkit:activate -->
        * ```js
-       * const { List } = require('immutable@4.0.0-rc.9')
+       * const { List } = require('immutable')
        * List([ 'a', 'b', 'c', 'd' ]).splice(1, 2, 'q', 'r', 's')
        * // List [ "a", "q", "r", "s", "d" ]
        * ```
@@ -3391,11 +3606,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
@@ -3405,7 +3616,7 @@ declare module Immutable {
        *
        *
        * <!-- runkit:activate
-       *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9')" }
+       *      { "preamble": "const { List } = require('immutable')" }
        * -->
        * ```js
        * const a = List([ 1, 2, 3 ]);
@@ -3413,9 +3624,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.
@@ -3429,16 +3645,21 @@ 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
        * collections by using a custom `zipper` function.
        *
        * <!-- runkit:activate
-       *      { "preamble": "const { List } = require('immutable@4.0.0-rc.9')" }
+       *      { "preamble": "const { List } = require('immutable')" }
        * -->
        * ```js
        * const a = List([ 1, 2, 3 ]);
@@ -3449,19 +3670,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
       /**
@@ -3482,7 +3702,7 @@ declare module Immutable {
        */
       findIndex(
         predicate: (value: T, index: number, iter: this) => boolean,
-        context?: any
+        context?: unknown
       ): number;
       /**
@@ -3491,7 +3711,7 @@ declare module Immutable {
        */
       findLastIndex(
         predicate: (value: T, index: number, iter: this) => boolean,
-        context?: any
+        context?: unknown
       ): number;
       // Sequence algorithms
@@ -3499,14 +3719,16 @@ 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
        * `mapper` function.
        *
        * ```js
-       * const { Collection } = require('immutable@4.0.0-rc.9')
+       * const { Collection } = require('immutable')
        * Collection.Indexed([1,2]).map(x => 10 * x)
        * // Seq [ 1, 2 ]
        * ```
@@ -3516,7 +3738,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: T, key: number, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Collection.Indexed<M>;
       /**
@@ -3526,7 +3748,7 @@ declare module Immutable {
        */
       flatMap<M>(
         mapper: (value: T, key: number, iter: this) => Iterable<M>,
-        context?: any
+        context?: unknown
       ): Collection.Indexed<M>;
       /**
@@ -3538,17 +3760,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
@@ -3558,7 +3779,7 @@ declare module Immutable {
      * the value as both the first and second arguments to the provided function.
      *
      * ```js
-     * const { Collection } = require('immutable@4.0.0-rc.9')
+     * const { Collection } = require('immutable')
      * const seq = Collection.Set([ 'A', 'B', 'C' ])
      * // Seq { "A", "B", "C" }
      * seq.forEach((v, k) =>
@@ -3566,18 +3787,21 @@ declare module Immutable {
      * )
      * ```
      */
-    export module Set {}
+    namespace Set {}
     /**
      * Similar to `Collection()`, but always returns a Collection.Set.
+     *
+     * 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.
@@ -3616,7 +3840,7 @@ declare module Immutable {
        */
       map<M>(
         mapper: (value: T, key: T, iter: this) => M,
-        context?: any
+        context?: unknown
       ): Collection.Set<M>;
       /**
@@ -3626,7 +3850,7 @@ declare module Immutable {
        */
       flatMap<M>(
         mapper: (value: T, key: T, iter: this) => Iterable<M>,
-        context?: any
+        context?: unknown
       ): Collection.Set<M>;
       /**
@@ -3638,16 +3862,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>;
     }
   }
   /**
@@ -3657,20 +3880,31 @@ declare module Immutable {
    *
    *   * If an `Collection`, that same `Collection`.
    *   * If an Array-like, an `Collection.Indexed`.
-   *   * If an Object with an Iterator, an `Collection.Indexed`.
-   *   * If an Iterator, an `Collection.Indexed`.
+   *   * If an Object with an Iterator defined, an `Collection.Indexed`.
    *   * If an Object, an `Collection.Keyed`.
    *
    * This methods forces the conversion of Objects and Strings to Collections.
    * If you want to ensure that a Collection of one item is returned, use
    * `Seq.of`.
+   *
+   * Note: An Iterator itself will be treated as an object, becoming a `Seq.Keyed`,
+   * which is usually not what you want. You should turn your Iterator Object into
+   * an iterable object by defining a Symbol.iterator (or @@iterator) method which
+   * returns `this`.
+   *
+   * 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>;
+  function Collection<K = unknown, V = unknown>(): Collection<K, V>;
+  interface Collection<K, V> extends ValueObject {
     // Value equality
     /**
@@ -3680,7 +3914,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.
@@ -3690,7 +3924,7 @@ declare module Immutable {
      * lookup via a different instance.
      *
      * <!-- runkit:activate
-     *      { "preamble": "const { Set,  List } = require('immutable@4.0.0-rc.9')" }
+     *      { "preamble": "const { Set,  List } = require('immutable')" }
      * -->
      * ```js
      * const a = List([ 1, 2, 3 ]);
@@ -3704,11 +3938,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
     /**
@@ -3737,15 +3970,20 @@ declare module Immutable {
     contains(value: V): boolean;
     /**
-     * The first value in the Collection.
+     * In case the `Collection` is not empty returns the first element of the
+     * `Collection`.
+     * In case the `Collection` is empty returns the optional default
+     * value if provided, if no default value is provided returns undefined.
      */
-    first(): V | undefined;
+    first<NSV = undefined>(notSetValue?: NSV): V | NSV;
     /**
-     * The last value in the Collection.
+     * In case the `Collection` is not empty returns the last element of the
+     * `Collection`.
+     * In case the `Collection` is empty returns the optional default
+     * value if provided, if no default value is provided returns undefined.
      */
-    last(): V | undefined;
+    last<NSV = undefined>(notSetValue?: NSV): V | NSV;
     // Reading deep values
@@ -3755,9 +3993,9 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map, List } = require('immutable@4.0.0-rc.9')
+     * const { Map, List } = require('immutable')
      * const deepData = Map({ x: List([ Map({ y: 123 }) ]) });
-     * getIn(deepData, ['x', 0, 'y']) // 123
+     * deepData.getIn(['x', 0, 'y']) // 123
      * ```
      *
      * Plain JavaScript Object or Arrays may be nested within an Immutable.js
@@ -3765,18 +4003,18 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map, List } = require('immutable@4.0.0-rc.9')
+     * const { Map, List } = require('immutable')
      * const deepData = Map({ x: [ { y: 123 } ] });
-     * getIn(deepData, ['x', 0, 'y']) // 123
+     * 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
@@ -3788,7 +4026,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Seq } = require('immutable@4.0.0-rc.9')
+     * const { Seq } = require('immutable')
      *
      * function sum(collection) {
      *   return collection.reduce((sum, x) => sum + x, 0)
@@ -3803,7 +4041,6 @@ declare module Immutable {
      */
     update<R>(updater: (value: this) => R): R;
     // Conversion to JavaScript types
     /**
@@ -3812,7 +4049,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.
@@ -3837,7 +4074,6 @@ declare module Immutable {
      */
     toObject(): { [key: string]: V };
     // Conversion to Collections
     /**
@@ -3884,7 +4120,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map, List } = require('immutable@4.0.0-rc.9')
+     * const { Map, List } = require('immutable')
      * var myMap = Map({ a: 'Apple', b: 'Banana' })
      * List(myMap) // List [ [ "a", "Apple" ], [ "b", "Banana" ] ]
      * myMap.toList() // List [ "Apple", "Banana" ]
@@ -3901,7 +4137,6 @@ declare module Immutable {
      */
     toStack(): Stack<V>;
     // Conversion to Seq
     /**
@@ -3921,7 +4156,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Seq } = require('immutable@4.0.0-rc.9')
+     * const { Seq } = require('immutable')
      * const indexedSeq = Seq([ 'A', 'B', 'C' ])
      * // Seq [ "A", "B", "C" ]
      * indexedSeq.filter(v => v === 'B')
@@ -3944,7 +4179,6 @@ declare module Immutable {
      */
     toSetSeq(): Seq.Set<V>;
     // Iterators
     /**
@@ -3974,6 +4208,7 @@ declare module Immutable {
      */
     entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<unknown>;
     // Collections (Seq)
@@ -3993,7 +4228,6 @@ declare module Immutable {
      */
     entrySeq(): Seq.Indexed<[K, V]>;
     // Sequence algorithms
     /**
@@ -4002,7 +4236,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Collection } = require('immutable@4.0.0-rc.9')
+     * const { Collection } = require('immutable')
      * Collection({ a: 1, b: 2 }).map(x => 10 * x)
      * // Seq { "a": 10, "b": 20 }
      * ```
@@ -4012,7 +4246,7 @@ declare module Immutable {
      */
     map<M>(
       mapper: (value: V, key: K, iter: this) => M,
-      context?: any
+      context?: unknown
     ): Collection<K, M>;
     /**
@@ -4021,7 +4255,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
@@ -4029,7 +4263,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * Map({ a: 1, b: 2, c: 3, d: 4}).filter(x => x % 2 === 0)
      * // Map { "b": 2, "d": 4 }
      * ```
@@ -4039,11 +4273,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;
     /**
@@ -4052,7 +4286,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * Map({ a: 1, b: 2, c: 3, d: 4}).filterNot(x => x % 2 === 0)
      * // Map { "a": 1, "c": 3 }
      * ```
@@ -4062,7 +4296,7 @@ declare module Immutable {
      */
     filterNot(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): this;
     /**
@@ -4089,7 +4323,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { Map } = require('immutable@4.0.0-rc.9')
+     * const { Map } = require('immutable')
      * Map({ "c": 3, "a": 1, "b": 2 }).sort((a, b) => {
      *   if (a < b) { return -1; }
      *   if (a > b) { return 1; }
@@ -4109,7 +4343,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.
@@ -4129,7 +4373,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List, Map } = require('immutable@4.0.0-rc.9')
+     * const { List, Map } = require('immutable')
      * const listOfMaps = List([
      *   Map({ v: 0 }),
      *   Map({ v: 1 }),
@@ -4147,9 +4391,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
@@ -4161,11 +4404,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
     /**
@@ -4216,15 +4458,15 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List } = require('immutable@4.0.0-rc.9')
+     * 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;
     /**
@@ -4233,15 +4475,15 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List } = require('immutable@4.0.0-rc.9')
+     * 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;
     /**
@@ -4262,7 +4504,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List } = require('immutable@4.0.0-rc.9')
+     * const { List } = require('immutable')
      * List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
      *   .takeWhile(x => x.match(/o/))
      * // List [ "dog", "frog" ]
@@ -4270,7 +4512,7 @@ declare module Immutable {
      */
     takeWhile(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): this;
     /**
@@ -4279,7 +4521,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List } = require('immutable@4.0.0-rc.9')
+     * const { List } = require('immutable')
      * List([ 'dog', 'frog', 'cat', 'hat', 'god' ])
      *   .takeUntil(x => x.match(/at/))
      * // List [ "dog", "frog" ]
@@ -4287,10 +4529,9 @@ declare module Immutable {
      */
     takeUntil(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): this;
     // Combination
     /**
@@ -4300,7 +4541,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.
@@ -4312,11 +4555,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.
@@ -4325,7 +4569,7 @@ declare module Immutable {
      */
     flatMap<M>(
       mapper: (value: V, key: K, iter: this) => Iterable<M>,
-      context?: any
+      context?: unknown
     ): Collection<K, M>;
     /**
@@ -4336,7 +4580,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
@@ -4353,7 +4597,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
@@ -4368,7 +4612,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
@@ -4379,7 +4623,7 @@ declare module Immutable {
      */
     every(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): boolean;
     /**
@@ -4387,7 +4631,7 @@ declare module Immutable {
      */
     some(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): boolean;
     /**
@@ -4417,7 +4661,7 @@ declare module Immutable {
     count(): number;
     count(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): number;
     /**
@@ -4428,10 +4672,9 @@ declare module Immutable {
      */
     countBy<G>(
       grouper: (value: V, key: K, iter: this) => G,
-      context?: any
+      context?: unknown
     ): Map<G, number>;
     // Search for value
     /**
@@ -4439,7 +4682,7 @@ declare module Immutable {
      */
     find(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any,
+      context?: unknown,
       notSetValue?: V
     ): V | undefined;
@@ -4450,7 +4693,7 @@ declare module Immutable {
      */
     findLast(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any,
+      context?: unknown,
       notSetValue?: V
     ): V | undefined;
@@ -4459,7 +4702,7 @@ declare module Immutable {
      */
     findEntry(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any,
+      context?: unknown,
       notSetValue?: V
     ): [K, V] | undefined;
@@ -4471,7 +4714,7 @@ declare module Immutable {
      */
     findLastEntry(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any,
+      context?: unknown,
       notSetValue?: V
     ): [K, V] | undefined;
@@ -4480,7 +4723,7 @@ declare module Immutable {
      */
     findKey(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): K | undefined;
     /**
@@ -4490,7 +4733,7 @@ declare module Immutable {
      */
     findLastKey(
       predicate: (value: V, key: K, iter: this) => boolean,
-      context?: any
+      context?: unknown
     ): K | undefined;
     /**
@@ -4524,8 +4767,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,
@@ -4553,15 +4804,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
     /**
@@ -4578,7 +4836,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()`.
@@ -4586,7 +4844,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.
@@ -4597,7 +4855,7 @@ declare module Immutable {
      *
      * <!-- runkit:activate -->
      * ```js
-     * const { List, Set } = require('immutable@4.0.0-rc.9');
+     * const { List, Set } = require('immutable');
      * const a = List([ 1, 2, 3 ]);
      * const b = List([ 1, 2, 3 ]);
      * assert.notStrictEqual(a, b); // different instances
@@ -4617,7 +4875,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;
   }
@@ -4625,10 +4883,14 @@ 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
-   * refering to each collection and the parent JS object provided as `this`.
+   * referring to each collection and the parent JS object provided as `this`.
    * For the top level, object, the key will be `""`. This `reviver` is expected
    * to return a new Immutable Collection, allowing for custom conversions from
    * deep JS objects. Finally, a `path` is provided which is the sequence of
@@ -4641,21 +4903,17 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { fromJS, isKeyed } = require('immutable@4.0.0-rc.9')
+   * const { fromJS, isKeyed } = require('immutable')
    * function (key, value) {
-   *   return isKeyed(value) ? value.Map() : value.toList()
+   *   return isKeyed(value) ? value.toMap() : value.toList()
    * }
    * ```
    *
-   * `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 -->
    * ```js
-   * const { fromJS, isKeyed } = require('immutable@4.0.0-rc.9')
+   * const { fromJS, isKeyed } = require('immutable')
    * fromJS({ a: {b: [10, 20, 30]}, c: 40}, function (key, value, path) {
    *   console.log(key, value, path)
    *   return isKeyed(value) ? value.toOrderedMap() : value.toList()
@@ -4672,7 +4930,7 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { Map } = require('immutable@4.0.0-rc.9')
+   * const { Map } = require('immutable')
    * let obj = { 1: "one" };
    * Object.keys(obj); // [ "1" ]
    * assert.equal(obj["1"], obj[1]); // "one" === "one"
@@ -4687,15 +4945,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
@@ -4707,7 +4969,7 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { Map, is } = require('immutable@4.0.0-rc.9')
+   * const { Map, is } = require('immutable')
    * const map1 = Map({ a: 1, b: 1, c: 1 })
    * const map2 = Map({ a: 1, b: 1, c: 1 })
    * assert.equal(map1 !== map2, true)
@@ -4722,14 +4984,14 @@ 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
    * two values are equivalent and is used to determine how to store those
    * values. Provided with any value, `hash()` will return a 31-bit integer.
    *
-   * When designing Objects which may be equal, it's important than when a
+   * When designing Objects which may be equal, it's important that when a
    * `.equals()` method returns true, that both values `.hashCode()` method
    * return the same value. `hash()` may be used to produce those values.
    *
@@ -4746,7 +5008,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.
@@ -4755,7 +5017,7 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { isImmutable, Map, List, Stack } = require('immutable@4.0.0-rc.9');
+   * const { isImmutable, Map, List, Stack } = require('immutable');
    * isImmutable([]); // false
    * isImmutable({}); // false
    * isImmutable(Map()); // true
@@ -4764,14 +5026,16 @@ 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.
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { isCollection, Map, List, Stack } = require('immutable@4.0.0-rc.9');
+   * const { isCollection, Map, List, Stack } = require('immutable');
    * isCollection([]); // false
    * isCollection({}); // false
    * isCollection(Map()); // true
@@ -4779,14 +5043,16 @@ 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.
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { isKeyed, Map, List, Stack } = require('immutable@4.0.0-rc.9');
+   * const { isKeyed, Map, List, Stack } = require('immutable');
    * isKeyed([]); // false
    * isKeyed({}); // false
    * isKeyed(Map()); // true
@@ -4794,14 +5060,16 @@ 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.
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { isIndexed, Map, List, Stack, Set } = require('immutable@4.0.0-rc.9');
+   * const { isIndexed, Map, List, Stack, Set } = require('immutable');
    * isIndexed([]); // false
    * isIndexed({}); // false
    * isIndexed(Map()); // false
@@ -4810,14 +5078,16 @@ 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.
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { isAssociative, Map, List, Stack, Set } = require('immutable@4.0.0-rc.9');
+   * const { isAssociative, Map, List, Stack, Set } = require('immutable');
    * isAssociative([]); // false
    * isAssociative({}); // false
    * isAssociative(Map()); // true
@@ -4826,7 +5096,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
@@ -4834,7 +5108,7 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { isOrdered, Map, OrderedMap, List, Set } = require('immutable@4.0.0-rc.9');
+   * const { isOrdered, Map, OrderedMap, List, Set } = require('immutable');
    * isOrdered([]); // false
    * isOrdered({}); // false
    * isOrdered(Map()); // false
@@ -4843,7 +5117,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()`
@@ -4852,7 +5126,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.
+   */
+  function isSeq(
+    maybeSeq: unknown
+  ): maybeSeq is
+    | Seq.Indexed<unknown>
+    | Seq.Keyed<unknown, unknown>
+    | Seq.Set<unknown>;
+  /**
+   * True if `maybeList` is a List.
+   */
+  function isList(maybeList: unknown): maybeList is List<unknown>;
+  /**
+   * True if `maybeMap` is a Map.
+   *
+   * Also true for OrderedMaps.
+   */
+  function isMap(maybeMap: unknown): maybeMap is Map<unknown, unknown>;
+  /**
+   * True if `maybeOrderedMap` is an OrderedMap.
+   */
+  function isOrderedMap(
+    maybeOrderedMap: unknown
+  ): maybeOrderedMap is OrderedMap<unknown, unknown>;
+  /**
+   * True if `maybeStack` is a Stack.
+   */
+  function isStack(maybeStack: unknown): maybeStack is Stack<unknown>;
+  /**
+   * True if `maybeSet` is a Set.
+   *
+   * Also true for OrderedSets.
+   */
+  function isSet(maybeSet: unknown): maybeSet is Set<unknown>;
+  /**
+   * True if `maybeOrderedSet` is an OrderedSet.
+   */
+  function isOrderedSet(
+    maybeOrderedSet: unknown
+  ): maybeOrderedSet is OrderedSet<unknown>;
+  /**
+   * True if `maybeRecord` is a Record.
+   */
+  function isRecord(maybeRecord: unknown): maybeRecord is Record<{}>;
   /**
    * Returns the value within the provided collection associated with the
@@ -4863,20 +5190,40 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { get } = require('immutable@4.0.0-rc.9')
+   * const { get } = require('immutable')
    * get([ 'dog', 'frog', 'cat' ], 2) // 'frog'
    * get({ x: 123, y: 456 }, 'x') // 123
    * 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.
@@ -4887,14 +5234,14 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { has } = require('immutable@4.0.0-rc.9')
+   * const { has } = require('immutable')
    * has([ 'dog', 'frog', 'cat' ], 2) // true
    * has([ 'dog', 'frog', 'cat' ], 5) // false
    * has({ x: 123, y: 456 }, 'x') // true
    * 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.
@@ -4905,7 +5252,7 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { remove } = require('immutable@4.0.0-rc.9')
+   * const { remove } = require('immutable')
    * const originalArray = [ 'dog', 'frog', 'cat' ]
    * remove(originalArray, 1) // [ 'dog', 'cat' ]
    * console.log(originalArray) // [ 'dog', 'frog', 'cat' ]
@@ -4914,11 +5261,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
@@ -4930,7 +5287,7 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { set } = require('immutable@4.0.0-rc.9')
+   * const { set } = require('immutable')
    * const originalArray = [ 'dog', 'frog', 'cat' ]
    * set(originalArray, 1, 'cow') // [ 'dog', 'cow', 'cat' ]
    * console.log(originalArray) // [ 'dog', 'frog', 'cat' ]
@@ -4939,11 +5296,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
@@ -4955,25 +5324,75 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { update } = require('immutable@4.0.0-rc.9')
+   * const { update } = require('immutable')
    * const originalArray = [ 'dog', 'frog', 'cat' ]
    * update(originalArray, 1, val => val.toUpperCase()) // [ 'dog', 'FROG', 'cat' ]
    * console.log(originalArray) // [ 'dog', 'frog', 'cat' ]
    * const originalObject = { x: 123, y: 456 }
-   * set(originalObject, 'x', val => val * 6) // { x: 738, y: 456 }
+   * update(originalObject, 'x', val => val * 6) // { x: 738, y: 456 }
    * 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
@@ -4984,12 +5403,16 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { getIn } = require('immutable@4.0.0-rc.9')
+   * const { getIn } = require('immutable')
    * getIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // 123
    * 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.
@@ -4999,12 +5422,12 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { hasIn } = require('immutable@4.0.0-rc.9')
+   * const { hasIn } = require('immutable')
    * hasIn({ x: { y: { z: 123 }}}, ['x', 'y', 'z']) // true
    * 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.
@@ -5014,13 +5437,13 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { removeIn } = require('immutable@4.0.0-rc.9')
+   * const { removeIn } = require('immutable')
    * const original = { x: { y: { z: 123 }}}
    * removeIn(original, ['x', 'y', 'z']) // { x: { y: {}}}
    * 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
@@ -5031,13 +5454,17 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { setIn } = require('immutable@4.0.0-rc.9')
+   * const { setIn } = require('immutable')
    * const original = { x: { y: { z: 123 }}}
    * setIn(original, ['x', 'y', 'z'], 456) // { x: { y: { z: 456 }}}
    * 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
@@ -5048,14 +5475,23 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { setIn } = require('immutable@4.0.0-rc.9')
+   * const { updateIn } = require('immutable')
    * const original = { x: { y: { z: 123 }}}
-   * setIn(original, ['x', 'y', 'z'], val => val * 6) // { x: { y: { z: 738 }}}
+   * updateIn(original, ['x', 'y', 'z'], val => val * 6) // { x: { y: { z: 738 }}}
    * 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.
@@ -5065,15 +5501,19 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { merge } = require('immutable@4.0.0-rc.9')
+   * const { merge } = require('immutable')
    * const original = { x: 123, y: 456 }
    * merge(original, { y: 789, z: 'abc' }) // { x: 123, y: 789, z: 'abc' }
-   * console.log(original) // { x: { y: { z: 123 }}}
+   * 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;
   /**
@@ -5085,53 +5525,72 @@ declare module Immutable {
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { mergeWith } = require('immutable@4.0.0-rc.9')
+   * const { mergeWith } = require('immutable')
    * const original = { x: 123, y: 456 }
    * mergeWith(
    *   (oldVal, newVal) => oldVal + newVal,
    *   original,
    *   { y: 789, z: 'abc' }
    * ) // { x: 123, y: 1245, z: 'abc' }
-   * console.log(original) // { x: { y: { z: 123 }}}
+   * 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.
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { merge } = require('immutable@4.0.0-rc.9')
+   * const { mergeDeep } = require('immutable')
    * const original = { x: { y: 123 }}
-   * merge(original, { x: { z: 456 }}) // { x: { y: 123, z: 456 }}
+   * mergeDeep(original, { x: { z: 456 }}) // { x: { y: 123, z: 456 }}
    * 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.
    *
    * <!-- runkit:activate -->
    * ```js
-   * const { merge } = require('immutable@4.0.0-rc.9')
+   * const { mergeDeepWith } = require('immutable')
    * const original = { x: { y: 123 }}
    * mergeDeepWith(
    *   (oldVal, newVal) => oldVal + newVal,
@@ -5141,13 +5600,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;