immutable 3.7.5 → 3.8.2

package/dist/immutable.d.ts

@@ -1,10 +1,8 @@
 /**
- *  Copyright (c) 2014-2015, Facebook, Inc.
- *  All rights reserved.
+ * Copyright (c) 2014-present, Facebook, Inc.
  *
- *  This source code is licensed under the BSD-style license found in the
- *  LICENSE file in the root directory of this source tree. An additional grant
- *  of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
  */
 
 /**
@@ -57,7 +55,7 @@ declare module Immutable {
    *
    * `reviver` acts similarly to the [same parameter in `JSON.parse`][1].
    *
-   * `Immutable.fromJS` is conservative in it's conversion. It will only convert
+   * `Immutable.fromJS` is conservative in its conversion. It will only convert
    * arrays which pass `Array.isArray` to Lists, and only raw objects (no custom
    * prototype) to Map.
    *
@@ -121,7 +119,7 @@ declare module Immutable {
    *
    * Unlike a JavaScript Array, there is no distinction between an
    * "unset" index and an index set to `undefined`. `List#forEach` visits all
-   * indices from 0 to size, regardless of if they where explicitly defined.
+   * indices from 0 to size, regardless of whether they were explicitly defined.
    */
   export module List {
 
@@ -141,15 +139,15 @@ declare module Immutable {
    * iterable-like.
    */
   export function List<T>(): List<T>;
-  export function List<T>(iter: IndexedIterable<T>): List<T>;
-  export function List<T>(iter: SetIterable<T>): List<T>;
-  export function List<K, V>(iter: KeyedIterable<K, V>): List</*[K,V]*/any>;
+  export function List<T>(iter: Iterable.Indexed<T>): List<T>;
+  export function List<T>(iter: Iterable.Set<T>): List<T>;
+  export function List<K, V>(iter: Iterable.Keyed<K, V>): List</*[K,V]*/any>;
   export function List<T>(array: Array<T>): List<T>;
   export function List<T>(iterator: Iterator<T>): List<T>;
   export function List<T>(iterable: /*Iterable<T>*/Object): List<T>;
 
 
-  export interface List<T> extends IndexedCollection<T> {
+  export interface List<T> extends Collection.Indexed<T> {
 
     // Persistent changes
 
@@ -181,6 +179,14 @@ declare module Immutable {
     delete(index: number): List<T>;
     remove(index: number): List<T>;
 
+    /**
+     * Returns a new List with `value` at `index` with a size 1 more than this
+     * List. Values at indices above `index` are shifted over by 1.
+     *
+     * This is synonymous with `list.splice(index, 0, value)
+     */
+    insert(index: number, value: T): List<T>;
+
     /**
      * Returns a new List with 0 size and no values.
      */
@@ -236,7 +242,7 @@ declare module Immutable {
     /**
      * @see `Map#merge`
      */
-    merge(...iterables: IndexedIterable<T>[]): List<T>;
+    merge(...iterables: Iterable.Indexed<T>[]): List<T>;
     merge(...iterables: Array<T>[]): List<T>;
 
     /**
@@ -244,7 +250,7 @@ declare module Immutable {
      */
     mergeWith(
       merger: (previous?: T, next?: T, key?: number) => T,
-      ...iterables: IndexedIterable<T>[]
+      ...iterables: Iterable.Indexed<T>[]
     ): List<T>;
     mergeWith(
       merger: (previous?: T, next?: T, key?: number) => T,
@@ -254,7 +260,7 @@ declare module Immutable {
     /**
      * @see `Map#mergeDeep`
      */
-    mergeDeep(...iterables: IndexedIterable<T>[]): List<T>;
+    mergeDeep(...iterables: Iterable.Indexed<T>[]): List<T>;
     mergeDeep(...iterables: Array<T>[]): List<T>;
 
     /**
@@ -262,7 +268,7 @@ declare module Immutable {
      */
     mergeDeepWith(
       merger: (previous?: T, next?: T, key?: number) => T,
-      ...iterables: IndexedIterable<T>[]
+      ...iterables: Iterable.Indexed<T>[]
     ): List<T>;
     mergeDeepWith(
       merger: (previous?: T, next?: T, key?: number) => T,
@@ -332,11 +338,11 @@ declare module Immutable {
      */
     mergeIn(
       keyPath: Iterable<any, any>,
-      ...iterables: IndexedIterable<T>[]
+      ...iterables: Iterable.Indexed<T>[]
     ): List<T>;
     mergeIn(
       keyPath: Array<any>,
-      ...iterables: IndexedIterable<T>[]
+      ...iterables: Iterable.Indexed<T>[]
     ): List<T>;
     mergeIn(
       keyPath: Array<any>,
@@ -348,11 +354,11 @@ declare module Immutable {
      */
     mergeDeepIn(
       keyPath: Iterable<any, any>,
-      ...iterables: IndexedIterable<T>[]
+      ...iterables: Iterable.Indexed<T>[]
     ): List<T>;
     mergeDeepIn(
       keyPath: Array<any>,
-      ...iterables: IndexedIterable<T>[]
+      ...iterables: Iterable.Indexed<T>[]
     ): List<T>;
     mergeDeepIn(
       keyPath: Array<any>,
@@ -384,7 +390,7 @@ declare module Immutable {
 
 
   /**
-   * Immutable Map is an unordered KeyedIterable of (key, value) pairs with
+   * Immutable Map is an unordered Iterable.Keyed of (key, value) pairs with
    * `O(log32 N)` gets and `O(log32 N)` persistent sets.
    *
    * Iteration order of a Map is undefined, however is stable. Multiple
@@ -412,12 +418,17 @@ declare module Immutable {
      * True if the provided value is a Map
      */
     function isMap(maybeMap: any): boolean;
+
+    /**
+     * Creates a new Map from alternating keys and values
+     */
+    function of(...keyValues: any[]): Map<any, any>;
   }
 
   /**
    * Creates a new Immutable Map.
    *
-   * Created with the same key value pairs as the provided KeyedIterable or
+   * Created with the same key value pairs as the provided Iterable.Keyed or
    * JavaScript Object or expects an Iterable of [K, V] tuple entries.
    *
    *     var newMap = Map({key: "value"});
@@ -443,14 +454,14 @@ declare module Immutable {
    * not altered.
    */
   export function Map<K, V>(): Map<K, V>;
-  export function Map<K, V>(iter: KeyedIterable<K, V>): Map<K, V>;
+  export function Map<K, V>(iter: Iterable.Keyed<K, V>): Map<K, V>;
   export function Map<K, V>(iter: Iterable<any, /*[K,V]*/Array<any>>): Map<K, V>;
   export function Map<K, V>(array: Array</*[K,V]*/Array<any>>): Map<K, V>;
   export function Map<V>(obj: {[key: string]: V}): Map<string, V>;
   export function Map<K, V>(iterator: Iterator</*[K,V]*/Array<any>>): Map<K, V>;
   export function Map<K, V>(iterable: /*Iterable<[K,V]>*/Object): Map<K, V>;
 
-  export interface Map<K, V> extends KeyedCollection<K, V> {
+  export interface Map<K, V> extends Collection.Keyed<K, V> {
 
     // Persistent changes
 
@@ -739,7 +750,7 @@ declare module Immutable {
   /**
    * Creates a new Immutable OrderedMap.
    *
-   * Created with the same key value pairs as the provided KeyedIterable or
+   * Created with the same key value pairs as the provided Iterable.Keyed or
    * JavaScript Object or expects an Iterable of [K, V] tuple entries.
    *
    * The iteration order of key-value pairs provided to this constructor will
@@ -750,7 +761,7 @@ declare module Immutable {
    *
    */
   export function OrderedMap<K, V>(): OrderedMap<K, V>;
-  export function OrderedMap<K, V>(iter: KeyedIterable<K, V>): OrderedMap<K, V>;
+  export function OrderedMap<K, V>(iter: Iterable.Keyed<K, V>): OrderedMap<K, V>;
   export function OrderedMap<K, V>(iter: Iterable<any, /*[K,V]*/Array<any>>): OrderedMap<K, V>;
   export function OrderedMap<K, V>(array: Array</*[K,V]*/Array<any>>): OrderedMap<K, V>;
   export function OrderedMap<V>(obj: {[key: string]: V}): OrderedMap<string, V>;
@@ -796,14 +807,14 @@ declare module Immutable {
    * iterable-like.
    */
   export function Set<T>(): Set<T>;
-  export function Set<T>(iter: SetIterable<T>): Set<T>;
-  export function Set<T>(iter: IndexedIterable<T>): Set<T>;
-  export function Set<K, V>(iter: KeyedIterable<K, V>): Set</*[K,V]*/any>;
+  export function Set<T>(iter: Iterable.Set<T>): Set<T>;
+  export function Set<T>(iter: Iterable.Indexed<T>): Set<T>;
+  export function Set<K, V>(iter: Iterable.Keyed<K, V>): Set</*[K,V]*/any>;
   export function Set<T>(array: Array<T>): Set<T>;
   export function Set<T>(iterator: Iterator<T>): Set<T>;
   export function Set<T>(iterable: /*Iterable<T>*/Object): Set<T>;
 
-  export interface Set<T> extends SetCollection<T> {
+  export interface Set<T> extends Collection.Set<T> {
 
     // Persistent changes
 
@@ -908,9 +919,9 @@ declare module Immutable {
    * iterable-like.
    */
   export function OrderedSet<T>(): OrderedSet<T>;
-  export function OrderedSet<T>(iter: SetIterable<T>): OrderedSet<T>;
-  export function OrderedSet<T>(iter: IndexedIterable<T>): OrderedSet<T>;
-  export function OrderedSet<K, V>(iter: KeyedIterable<K, V>): OrderedSet</*[K,V]*/any>;
+  export function OrderedSet<T>(iter: Iterable.Set<T>): OrderedSet<T>;
+  export function OrderedSet<T>(iter: Iterable.Indexed<T>): OrderedSet<T>;
+  export function OrderedSet<K, V>(iter: Iterable.Keyed<K, V>): OrderedSet</*[K,V]*/any>;
   export function OrderedSet<T>(array: Array<T>): OrderedSet<T>;
   export function OrderedSet<T>(iterator: Iterator<T>): OrderedSet<T>;
   export function OrderedSet<T>(iterable: /*Iterable<T>*/Object): OrderedSet<T>;
@@ -952,14 +963,14 @@ declare module Immutable {
    * resulting `Stack`.
    */
   export function Stack<T>(): Stack<T>;
-  export function Stack<T>(iter: IndexedIterable<T>): Stack<T>;
-  export function Stack<T>(iter: SetIterable<T>): Stack<T>;
-  export function Stack<K, V>(iter: KeyedIterable<K, V>): Stack</*[K,V]*/any>;
+  export function Stack<T>(iter: Iterable.Indexed<T>): Stack<T>;
+  export function Stack<T>(iter: Iterable.Set<T>): Stack<T>;
+  export function Stack<K, V>(iter: Iterable.Keyed<K, V>): Stack</*[K,V]*/any>;
   export function Stack<T>(array: Array<T>): Stack<T>;
   export function Stack<T>(iterator: Iterator<T>): Stack<T>;
   export function Stack<T>(iterable: /*Iterable<T>*/Object): Stack<T>;
 
-  export interface Stack<T> extends IndexedCollection<T> {
+  export interface Stack<T> extends Collection.Indexed<T> {
 
     // Reading values
 
@@ -1040,7 +1051,7 @@ declare module Immutable {
 
 
   /**
-   * Returns a IndexedSeq of numbers from `start` (inclusive) to `end`
+   * 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.
    *
@@ -1052,18 +1063,18 @@ declare module Immutable {
    *     Range(30,30,5) // []
    *
    */
-  export function Range(start?: number, end?: number, step?: number): IndexedSeq<number>;
+  export function Range(start?: number, end?: number, step?: number): Seq.Indexed<number>;
 
 
   /**
-   * Returns a IndexedSeq of `value` repeated `times` times. When `times` is
+   * Returns a Seq.Indexed of `value` repeated `times` times. When `times` is
    * not defined, returns an infinite `Seq` of `value`.
    *
    *     Repeat('foo') // ['foo','foo','foo',...]
    *     Repeat('bar',4) // ['bar','bar','bar','bar']
    *
    */
-  export function Repeat<T>(value: T, times?: number): IndexedSeq<T>;
+  export function Repeat<T>(value: T, times?: number): Seq.Indexed<T>;
 
 
   /**
@@ -1085,7 +1096,9 @@ declare module Immutable {
    *     myRecordWithoutB.size // 2
    *
    * Values provided to the constructor not found in the Record type will
-   * be ignored:
+   * be ignored. For example, in this case, ABRecord is provided a key "x" even
+   * though only "a" and "b" have been defined. The value for "x" will be
+   * ignored for this record.
    *
    *     var myRecord = new ABRecord({b:3, x:10})
    *     myRecord.get('x') // undefined
@@ -1116,7 +1129,7 @@ declare module Immutable {
    *
    */
   export module Record {
-    interface Class {
+    export interface Class {
       new (): Map<string, any>;
       new (values: {[key: string]: any}): Map<string, any>;
       new (values: Iterable<string, any>): Map<string, any>; // deprecated
@@ -1153,9 +1166,9 @@ declare module Immutable {
    *
    * Once the Seq is used, it performs only the work necessary. In this
    * example, no intermediate data structures are ever created, filter is only
-   * called three times, and map is only called twice:
+   * called three times, and map is only called once:
    *
-   *     console.log(evenSquares.get(1)); // 9
+   *     console.log(oddSquares.get(1)); // 9
    *
    * Seq allows for the efficient chaining of operations,
    * allowing for the expression of logic that can otherwise be very tedious:
@@ -1188,9 +1201,102 @@ declare module Immutable {
     function isSeq(maybeSeq: any): boolean;
 
     /**
-     * Returns a Seq of the values provided. Alias for `IndexedSeq.of()`.
+     * Returns a Seq of the values provided. Alias for `Seq.Indexed.of()`.
+     */
+    function of<T>(...values: T[]): Seq.Indexed<T>;
+
+
+    /**
+     * `Seq` which represents key-value pairs.
+     */
+    export module Keyed {}
+
+    /**
+     * Always returns a Seq.Keyed, if input is not keyed, expects an
+     * iterable of [K, V] tuples.
+     */
+    export function Keyed<K, V>(): Seq.Keyed<K, V>;
+    export function Keyed<K, V>(seq: Iterable.Keyed<K, V>): Seq.Keyed<K, V>;
+    export function Keyed<K, V>(seq: Iterable<any, /*[K,V]*/any>): Seq.Keyed<K, V>;
+    export function Keyed<K, V>(array: Array</*[K,V]*/any>): Seq.Keyed<K, V>;
+    export function Keyed<V>(obj: {[key: string]: V}): Seq.Keyed<string, V>;
+    export function Keyed<K, V>(iterator: Iterator</*[K,V]*/any>): Seq.Keyed<K, V>;
+    export function Keyed<K, V>(iterable: /*Iterable<[K,V]>*/Object): Seq.Keyed<K, V>;
+
+    export interface Keyed<K, V> extends Seq<K, V>, Iterable.Keyed<K, V> {
+
+      /**
+       * Returns itself
+       */
+      toSeq(): /*this*/Seq.Keyed<K, V>
+    }
+
+
+    /**
+     * `Seq` which represents an ordered indexed list of values.
+     */
+    module Indexed {
+
+      /**
+       * Provides an Seq.Indexed of the values provided.
+       */
+      function of<T>(...values: T[]): Seq.Indexed<T>;
+    }
+
+    /**
+     * Always returns Seq.Indexed, discarding associated keys and
+     * supplying incrementing indices.
+     */
+    export function Indexed<T>(): Seq.Indexed<T>;
+    export function Indexed<T>(seq: Iterable.Indexed<T>): Seq.Indexed<T>;
+    export function Indexed<T>(seq: Iterable.Set<T>): Seq.Indexed<T>;
+    export function Indexed<K, V>(seq: Iterable.Keyed<K, V>): Seq.Indexed</*[K,V]*/any>;
+    export function Indexed<T>(array: Array<T>): Seq.Indexed<T>;
+    export function Indexed<T>(iterator: Iterator<T>): Seq.Indexed<T>;
+    export function Indexed<T>(iterable: /*Iterable<T>*/Object): Seq.Indexed<T>;
+
+    export interface Indexed<T> extends Seq<number, T>, Iterable.Indexed<T> {
+
+      /**
+       * Returns itself
+       */
+      toSeq(): /*this*/Seq.Indexed<T>
+    }
+
+
+    /**
+     * `Seq` which represents a set of values.
+     *
+     * Because `Seq` are often lazy, `Seq.Set` does not provide the same guarantee
+     * of value uniqueness as the concrete `Set`.
+     */
+    export module Set {
+
+      /**
+       * Returns a Seq.Set of the provided values
+       */
+      function of<T>(...values: T[]): Seq.Set<T>;
+    }
+
+    /**
+     * Always returns a Seq.Set, discarding associated indices or keys.
      */
-    function of<T>(...values: T[]): IndexedSeq<T>;
+    export function Set<T>(): Seq.Set<T>;
+    export function Set<T>(seq: Iterable.Set<T>): Seq.Set<T>;
+    export function Set<T>(seq: Iterable.Indexed<T>): Seq.Set<T>;
+    export function Set<K, V>(seq: Iterable.Keyed<K, V>): Seq.Set</*[K,V]*/any>;
+    export function Set<T>(array: Array<T>): Seq.Set<T>;
+    export function Set<T>(iterator: Iterator<T>): Seq.Set<T>;
+    export function Set<T>(iterable: /*Iterable<T>*/Object): Seq.Set<T>;
+
+    export interface Set<T> extends Seq<T, T>, Iterable.Set<T> {
+
+      /**
+       * Returns itself
+       */
+      toSeq(): /*this*/Seq.Set<T>
+    }
+
   }
 
   /**
@@ -1200,19 +1306,19 @@ declare module Immutable {
    *
    *   * If a `Seq`, that same `Seq`.
    *   * If an `Iterable`, a `Seq` of the same kind (Keyed, Indexed, or Set).
-   *   * If an Array-like, an `IndexedSeq`.
-   *   * If an Object with an Iterator, an `IndexedSeq`.
-   *   * If an Iterator, an `IndexedSeq`.
-   *   * If an Object, a `KeyedSeq`.
+   *   * If an Array-like, an `Seq.Indexed`.
+   *   * If an Object with an Iterator, an `Seq.Indexed`.
+   *   * If an Iterator, an `Seq.Indexed`.
+   *   * If an Object, a `Seq.Keyed`.
    *
    */
   export function Seq<K, V>(): Seq<K, V>;
   export function Seq<K, V>(seq: Seq<K, V>): Seq<K, V>;
   export function Seq<K, V>(iterable: Iterable<K, V>): Seq<K, V>;
-  export function Seq<T>(array: Array<T>): IndexedSeq<T>;
-  export function Seq<V>(obj: {[key: string]: V}): KeyedSeq<string, V>;
-  export function Seq<T>(iterator: Iterator<T>): IndexedSeq<T>;
-  export function Seq<T>(iterable: /*ES6Iterable<T>*/Object): IndexedSeq<T>;
+  export function Seq<T>(array: Array<T>): Seq.Indexed<T>;
+  export function Seq<V>(obj: {[key: string]: V}): Seq.Keyed<string, V>;
+  export function Seq<T>(iterator: Iterator<T>): Seq.Indexed<T>;
+  export function Seq<T>(iterable: /*ES6Iterable<T>*/Object): Seq.Indexed<T>;
 
   export interface Seq<K, V> extends Iterable<K, V> {
 
@@ -1254,98 +1360,6 @@ declare module Immutable {
     cacheResult(): /*this*/Seq<K, V>;
   }
 
-
-  /**
-   * `Seq` which represents key-value pairs.
-   */
-  export module KeyedSeq {}
-
-  /**
-   * Always returns a KeyedSeq, if input is not keyed, expects an
-   * iterable of [K, V] tuples.
-   */
-  export function KeyedSeq<K, V>(): KeyedSeq<K, V>;
-  export function KeyedSeq<K, V>(seq: KeyedIterable<K, V>): KeyedSeq<K, V>;
-  export function KeyedSeq<K, V>(seq: Iterable<any, /*[K,V]*/any>): KeyedSeq<K, V>;
-  export function KeyedSeq<K, V>(array: Array</*[K,V]*/any>): KeyedSeq<K, V>;
-  export function KeyedSeq<V>(obj: {[key: string]: V}): KeyedSeq<string, V>;
-  export function KeyedSeq<K, V>(iterator: Iterator</*[K,V]*/any>): KeyedSeq<K, V>;
-  export function KeyedSeq<K, V>(iterable: /*Iterable<[K,V]>*/Object): KeyedSeq<K, V>;
-
-  export interface KeyedSeq<K, V> extends Seq<K, V>, KeyedIterable<K, V> {
-
-    /**
-     * Returns itself
-     */
-    toSeq(): /*this*/KeyedSeq<K, V>
-  }
-
-
-  /**
-   * `Seq` which represents an ordered indexed list of values.
-   */
-  export module IndexedSeq {
-
-    /**
-     * Provides an IndexedSeq of the values provided.
-     */
-    function of<T>(...values: T[]): IndexedSeq<T>;
-  }
-
-  /**
-   * Always returns IndexedSeq, discarding associated keys and
-   * supplying incrementing indices.
-   */
-  export function IndexedSeq<T>(): IndexedSeq<T>;
-  export function IndexedSeq<T>(seq: IndexedIterable<T>): IndexedSeq<T>;
-  export function IndexedSeq<T>(seq: SetIterable<T>): IndexedSeq<T>;
-  export function IndexedSeq<K, V>(seq: KeyedIterable<K, V>): IndexedSeq</*[K,V]*/any>;
-  export function IndexedSeq<T>(array: Array<T>): IndexedSeq<T>;
-  export function IndexedSeq<T>(iterator: Iterator<T>): IndexedSeq<T>;
-  export function IndexedSeq<T>(iterable: /*Iterable<T>*/Object): IndexedSeq<T>;
-
-  export interface IndexedSeq<T> extends Seq<number, T>, IndexedIterable<T> {
-
-    /**
-     * Returns itself
-     */
-    toSeq(): /*this*/IndexedSeq<T>
-  }
-
-  /**
-   * `Seq` which represents a set of values.
-   *
-   * Because `Seq` are often lazy, `SetSeq` does not provide the same guarantee
-   * of value uniqueness as the concrete `Set`.
-   */
-  export module SetSeq {
-
-    /**
-     * Returns a SetSeq of the provided values
-     */
-    function of<T>(...values: T[]): SetSeq<T>;
-  }
-
-  /**
-   * Always returns a SetSeq, discarding associated indices or keys.
-   */
-  export function SetSeq<T>(): SetSeq<T>;
-  export function SetSeq<T>(seq: SetIterable<T>): SetSeq<T>;
-  export function SetSeq<T>(seq: IndexedIterable<T>): SetSeq<T>;
-  export function SetSeq<K, V>(seq: KeyedIterable<K, V>): SetSeq</*[K,V]*/any>;
-  export function SetSeq<T>(array: Array<T>): SetSeq<T>;
-  export function SetSeq<T>(iterator: Iterator<T>): SetSeq<T>;
-  export function SetSeq<T>(iterable: /*Iterable<T>*/Object): SetSeq<T>;
-
-  export interface SetSeq<T> extends Seq<T, T>, SetIterable<T> {
-
-    /**
-     * Returns itself
-     */
-    toSeq(): /*this*/SetSeq<T>
-  }
-
-
   /**
    * The `Iterable` is a set of (key, value) entries which can be iterated, and
    * is the base class for all collections in `immutable`, allowing them to
@@ -1361,12 +1375,12 @@ declare module Immutable {
     function isIterable(maybeIterable: any): boolean;
 
     /**
-     * True if `maybeKeyed` is a KeyedIterable, or any of its subclasses.
+     * True if `maybeKeyed` is an Iterable.Keyed, or any of its subclasses.
      */
     function isKeyed(maybeKeyed: any): boolean;
 
     /**
-     * True if `maybeIndexed` is a IndexedIterable, or any of its subclasses.
+     * True if `maybeIndexed` is a Iterable.Indexed, or any of its subclasses.
      */
     function isIndexed(maybeIndexed: any): boolean;
 
@@ -1377,9 +1391,293 @@ declare module Immutable {
 
     /**
      * True if `maybeOrdered` is an Iterable where iteration order is well
-     * defined. True for IndexedIterable as well as OrderedMap and OrderedSet.
+     * defined. True for Iterable.Indexed as well as OrderedMap and OrderedSet.
      */
     function isOrdered(maybeOrdered: any): boolean;
+
+
+    /**
+     * Keyed Iterables have discrete keys tied to each value.
+     *
+     * When iterating `Iterable.Keyed`, each iteration will yield a `[K, V]`
+     * tuple, in other words, `Iterable#entries` is the default iterator for
+     * Keyed Iterables.
+     */
+    export module Keyed {}
+
+    /**
+     * Creates an Iterable.Keyed
+     *
+     * Similar to `Iterable()`, however it expects iterable-likes of [K, V]
+     * tuples if not constructed from a Iterable.Keyed or JS Object.
+     */
+    export function Keyed<K, V>(iter: Iterable.Keyed<K, V>): Iterable.Keyed<K, V>;
+    export function Keyed<K, V>(iter: Iterable<any, /*[K,V]*/any>): Iterable.Keyed<K, V>;
+    export function Keyed<K, V>(array: Array</*[K,V]*/any>): Iterable.Keyed<K, V>;
+    export function Keyed<V>(obj: {[key: string]: V}): Iterable.Keyed<string, V>;
+    export function Keyed<K, V>(iterator: Iterator</*[K,V]*/any>): Iterable.Keyed<K, V>;
+    export function Keyed<K, V>(iterable: /*Iterable<[K,V]>*/Object): Iterable.Keyed<K, V>;
+
+    export interface Keyed<K, V> extends Iterable<K, V> {
+
+      /**
+       * Returns Seq.Keyed.
+       * @override
+       */
+      toSeq(): Seq.Keyed<K, V>;
+
+
+      // Sequence functions
+
+      /**
+       * Returns a new Iterable.Keyed of the same type where the keys and values
+       * have been flipped.
+       *
+       *     Seq({ a: 'z', b: 'y' }).flip() // { z: 'a', y: 'b' }
+       *
+       */
+      flip(): /*this*/Iterable.Keyed<V, K>;
+
+      /**
+       * Returns a new Iterable.Keyed of the same type with keys passed through
+       * a `mapper` function.
+       *
+       *     Seq({ a: 1, b: 2 })
+       *       .mapKeys(x => x.toUpperCase())
+       *     // Seq { A: 1, B: 2 }
+       *
+       */
+      mapKeys<M>(
+        mapper: (key?: K, value?: V, iter?: /*this*/Iterable.Keyed<K, V>) => M,
+        context?: any
+      ): /*this*/Iterable.Keyed<M, V>;
+
+      /**
+       * Returns a new Iterable.Keyed of the same type with entries
+       * ([key, value] tuples) passed through a `mapper` function.
+       *
+       *     Seq({ a: 1, b: 2 })
+       *       .mapEntries(([k, v]) => [k.toUpperCase(), v * 2])
+       *     // Seq { A: 2, B: 4 }
+       *
+       */
+      mapEntries<KM, VM>(
+        mapper: (
+          entry?: /*(K, V)*/Array<any>,
+          index?: number,
+          iter?: /*this*/Iterable.Keyed<K, V>
+        ) => /*[KM, VM]*/Array<any>,
+        context?: any
+      ): /*this*/Iterable.Keyed<KM, VM>;
+    }
+
+
+    /**
+     * Indexed Iterables have incrementing numeric keys. They exhibit
+     * slightly different behavior than `Iterable.Keyed` for some methods in order
+     * to better mirror the behavior of JavaScript's `Array`, and add methods
+     * which do not make sense on non-indexed Iterables such as `indexOf`.
+     *
+     * Unlike JavaScript arrays, `Iterable.Indexed`s are always dense. "Unset"
+     * indices and `undefined` indices are indistinguishable, and all indices from
+     * 0 to `size` are visited when iterated.
+     *
+     * All Iterable.Indexed methods return re-indexed Iterables. In other words,
+     * indices always start at 0 and increment until size. If you wish to
+     * preserve indices, using them as keys, convert to a Iterable.Keyed by
+     * calling `toKeyedSeq`.
+     */
+    export module Indexed {}
+
+    /**
+     * Creates a new Iterable.Indexed.
+     */
+    export function Indexed<T>(iter: Iterable.Indexed<T>): Iterable.Indexed<T>;
+    export function Indexed<T>(iter: Iterable.Set<T>): Iterable.Indexed<T>;
+    export function Indexed<K, V>(iter: Iterable.Keyed<K, V>): Iterable.Indexed</*[K,V]*/any>;
+    export function Indexed<T>(array: Array<T>): Iterable.Indexed<T>;
+    export function Indexed<T>(iterator: Iterator<T>): Iterable.Indexed<T>;
+    export function Indexed<T>(iterable: /*Iterable<T>*/Object): Iterable.Indexed<T>;
+
+    export interface Indexed<T> extends Iterable<number, T> {
+
+      // Reading values
+
+      /**
+       * Returns the value associated with the provided index, or notSetValue if
+       * the index is beyond the bounds of the Iterable.
+       *
+       * `index` may be a negative number, which indexes back from the end of the
+       * Iterable. `s.get(-1)` gets the last item in the Iterable.
+       */
+      get(index: number, notSetValue?: T): T;
+
+
+      // Conversion to Seq
+
+      /**
+       * Returns Seq.Indexed.
+       * @override
+       */
+      toSeq(): Seq.Indexed<T>;
+
+      /**
+       * If this is an iterable of [key, value] entry tuples, it will return a
+       * Seq.Keyed of those entries.
+       */
+      fromEntrySeq(): Seq.Keyed<any, any>;
+
+
+      // Combination
+
+      /**
+       * Returns an Iterable of the same type with `separator` between each item
+       * in this Iterable.
+       */
+      interpose(separator: T): /*this*/Iterable.Indexed<T>;
+
+      /**
+       * Returns an Iterable of the same type with the provided `iterables`
+       * interleaved into this iterable.
+       *
+       * The resulting Iterable includes the first item from each, then the
+       * second from each, etc.
+       *
+       *     I.Seq.of(1,2,3).interleave(I.Seq.of('A','B','C'))
+       *     // Seq [ 1, 'A', 2, 'B', 3, 'C' ]
+       *
+       * The shortest Iterable stops interleave.
+       *
+       *     I.Seq.of(1,2,3).interleave(
+       *       I.Seq.of('A','B'),
+       *       I.Seq.of('X','Y','Z')
+       *     )
+       *     // Seq [ 1, 'A', 'X', 2, 'B', 'Y' ]
+       */
+      interleave(...iterables: Array<Iterable<any, T>>): /*this*/Iterable.Indexed<T>;
+
+      /**
+       * Splice returns a new indexed Iterable by replacing a region of this
+       * Iterable with new values. If values are not provided, it only skips the
+       * region to be removed.
+       *
+       * `index` may be a negative number, which indexes back from the end of the
+       * Iterable. `s.splice(-2)` splices after the second to last item.
+       *
+       *     Seq(['a','b','c','d']).splice(1, 2, 'q', 'r', 's')
+       *     // Seq ['a', 'q', 'r', 's', 'd']
+       *
+       */
+      splice(
+        index: number,
+        removeNum: number,
+        ...values: /*Array<Iterable.Indexed<T> | T>*/any[]
+      ): /*this*/Iterable.Indexed<T>;
+
+      /**
+       * Returns an Iterable of the same type "zipped" with the provided
+       * iterables.
+       *
+       * Like `zipWith`, but using the default `zipper`: creating an `Array`.
+       *
+       *     var a = Seq.of(1, 2, 3);
+       *     var b = Seq.of(4, 5, 6);
+       *     var c = a.zip(b); // Seq [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]
+       *
+       */
+      zip(...iterables: Array<Iterable<any, any>>): /*this*/Iterable.Indexed<any>;
+
+      /**
+       * Returns an Iterable of the same type "zipped" with the provided
+       * iterables by using a custom `zipper` function.
+       *
+       *     var a = Seq.of(1, 2, 3);
+       *     var b = Seq.of(4, 5, 6);
+       *     var c = a.zipWith((a, b) => a + b, b); // Seq [ 5, 7, 9 ]
+       *
+       */
+      zipWith<U, Z>(
+        zipper: (value: T, otherValue: U) => Z,
+        otherIterable: Iterable<any, U>
+      ): Iterable.Indexed<Z>;
+      zipWith<U, V, Z>(
+        zipper: (value: T, otherValue: U, thirdValue: V) => Z,
+        otherIterable: Iterable<any, U>,
+        thirdIterable: Iterable<any, V>
+      ): Iterable.Indexed<Z>;
+      zipWith<Z>(
+        zipper: (...any: Array<any>) => Z,
+        ...iterables: Array<Iterable<any, any>>
+      ): Iterable.Indexed<Z>;
+
+
+      // Search for value
+
+      /**
+       * Returns the first index at which a given value can be found in the
+       * Iterable, or -1 if it is not present.
+       */
+      indexOf(searchValue: T): number;
+
+      /**
+       * Returns the last index at which a given value can be found in the
+       * Iterable, or -1 if it is not present.
+       */
+      lastIndexOf(searchValue: T): number;
+
+      /**
+       * Returns the first index in the Iterable where a value satisfies the
+       * provided predicate function. Otherwise -1 is returned.
+       */
+      findIndex(
+        predicate: (value?: T, index?: number, iter?: /*this*/Iterable.Indexed<T>) => boolean,
+        context?: any
+      ): number;
+
+      /**
+       * Returns the last index in the Iterable where a value satisfies the
+       * provided predicate function. Otherwise -1 is returned.
+       */
+      findLastIndex(
+        predicate: (value?: T, index?: number, iter?: /*this*/Iterable.Indexed<T>) => boolean,
+        context?: any
+      ): number;
+    }
+
+
+    /**
+     * Set Iterables only represent values. They have no associated keys or
+     * indices. Duplicate values are possible in Seq.Sets, however the
+     * concrete `Set` does not allow duplicate values.
+     *
+     * Iterable methods on Iterable.Set such as `map` and `forEach` will provide
+     * the value as both the first and second arguments to the provided function.
+     *
+     *     var seq = Seq.Set.of('A', 'B', 'C');
+     *     assert.equal(seq.every((v, k) => v === k), true);
+     *
+     */
+    export module Set {}
+
+    /**
+     * Similar to `Iterable()`, but always returns a Iterable.Set.
+     */
+    export function Set<T>(iter: Iterable.Set<T>): Iterable.Set<T>;
+    export function Set<T>(iter: Iterable.Indexed<T>): Iterable.Set<T>;
+    export function Set<K, V>(iter: Iterable.Keyed<K, V>): Iterable.Set</*[K,V]*/any>;
+    export function Set<T>(array: Array<T>): Iterable.Set<T>;
+    export function Set<T>(iterator: Iterator<T>): Iterable.Set<T>;
+    export function Set<T>(iterable: /*Iterable<T>*/Object): Iterable.Set<T>;
+
+    export interface Set<T> extends Iterable<T, T> {
+
+      /**
+       * Returns Seq.Set.
+       * @override
+       */
+      toSeq(): Seq.Set<T>;
+    }
+
   }
 
   /**
@@ -1388,21 +1686,21 @@ declare module Immutable {
    * The type of Iterable created is based on the input.
    *
    *   * If an `Iterable`, that same `Iterable`.
-   *   * If an Array-like, an `IndexedIterable`.
-   *   * If an Object with an Iterator, an `IndexedIterable`.
-   *   * If an Iterator, an `IndexedIterable`.
-   *   * If an Object, a `KeyedIterable`.
+   *   * If an Array-like, an `Iterable.Indexed`.
+   *   * If an Object with an Iterator, an `Iterable.Indexed`.
+   *   * If an Iterator, an `Iterable.Indexed`.
+   *   * If an Object, an `Iterable.Keyed`.
    *
    * This methods forces the conversion of Objects and Strings to Iterables.
    * If you want to ensure that a Iterable of one item is returned, use
    * `Seq.of`.
    */
   export function Iterable<K, V>(iterable: Iterable<K, V>): Iterable<K, V>;
-  export function Iterable<T>(array: Array<T>): IndexedIterable<T>;
-  export function Iterable<V>(obj: {[key: string]: V}): KeyedIterable<string, V>;
-  export function Iterable<T>(iterator: Iterator<T>): IndexedIterable<T>;
-  export function Iterable<T>(iterable: /*ES6Iterable<T>*/Object): IndexedIterable<T>;
-  export function Iterable<V>(value: V): IndexedIterable<V>;
+  export function Iterable<T>(array: Array<T>): Iterable.Indexed<T>;
+  export function Iterable<V>(obj: {[key: string]: V}): Iterable.Keyed<string, V>;
+  export function Iterable<T>(iterator: Iterator<T>): Iterable.Indexed<T>;
+  export function Iterable<T>(iterable: /*ES6Iterable<T>*/Object): Iterable.Indexed<T>;
+  export function Iterable<V>(value: V): Iterable.Indexed<V>;
 
   export interface Iterable<K, V> {
 
@@ -1452,12 +1750,12 @@ declare module Immutable {
     get(key: K, notSetValue?: V): V;
 
     /**
-     * True if a key exists within this `Iterable`.
+     * True if a key exists within this `Iterable`, using `Immutable.is` to determine equality
      */
     has(key: K): boolean;
 
     /**
-     * True if a value exists within this `Iterable`.
+     * True if a value exists within this `Iterable`, using `Immutable.is` to determine equality
      * @alias contains
      */
     includes(value: V): boolean;
@@ -1496,8 +1794,8 @@ declare module Immutable {
     /**
      * Deeply converts this Iterable to equivalent JS.
      *
-     * `IndexedIterables`, and `SetIterables` become Arrays, while
-     * `KeyedIterables` become Objects.
+     * `Iterable.Indexeds`, and `Iterable.Sets` become Arrays, while
+     * `Iterable.Keyeds` become Objects.
      *
      * @alias toJSON
      */
@@ -1532,7 +1830,7 @@ declare module Immutable {
      * Note: This is equivalent to `OrderedMap(this.toKeyedSeq())`, but
      * provided for convenience and to allow for chained expressions.
      */
-    toOrderedMap(): Map<K, V>;
+    toOrderedMap(): OrderedMap<K, V>;
 
     /**
      * Converts this Iterable to a Set, discarding keys. Throws if values
@@ -1550,7 +1848,7 @@ declare module Immutable {
      * Note: This is equivalent to `OrderedSet(this.valueSeq())`, but provided
      * for convenience and to allow for chained expressions.
      */
-    toOrderedSet(): Set<V>;
+    toOrderedSet(): OrderedSet<V>;
 
     /**
      * Converts this Iterable to a List, discarding keys.
@@ -1579,10 +1877,10 @@ declare module Immutable {
     toSeq(): Seq<K, V>;
 
     /**
-     * Returns a KeyedSeq from this Iterable where indices are treated as keys.
+     * Returns a Seq.Keyed from this Iterable where indices are treated as keys.
      *
      * This is useful if you want to operate on an
-     * IndexedIterable and preserve the [index, value] pairs.
+     * Iterable.Indexed and preserve the [index, value] pairs.
      *
      * The returned Seq will have identical iteration order as
      * this Iterable.
@@ -1595,33 +1893,39 @@ declare module Immutable {
      *     keyedSeq.filter(v => v === 'B').toString() // Seq { 1: 'B' }
      *
      */
-    toKeyedSeq(): KeyedSeq<K, V>;
+    toKeyedSeq(): Seq.Keyed<K, V>;
 
     /**
-     * Returns an IndexedSeq of the values of this Iterable, discarding keys.
+     * Returns an Seq.Indexed of the values of this Iterable, discarding keys.
      */
-    toIndexedSeq(): IndexedSeq<V>;
+    toIndexedSeq(): Seq.Indexed<V>;
 
     /**
-     * Returns a SetSeq of the values of this Iterable, discarding keys.
+     * Returns a Seq.Set of the values of this Iterable, discarding keys.
      */
-    toSetSeq(): SetSeq<V>;
+    toSetSeq(): Seq.Set<V>;
 
 
     // Iterators
 
     /**
      * An iterator of this `Iterable`'s keys.
+     *
+     * Note: this will return an ES6 iterator which does not support Immutable JS sequence algorithms. Use `keySeq` instead, if this is what you want.
      */
     keys(): Iterator<K>;
 
     /**
      * An iterator of this `Iterable`'s values.
+     *
+     * Note: this will return an ES6 iterator which does not support Immutable JS sequence algorithms. Use `valueSeq` instead, if this is what you want.
      */
     values(): Iterator<V>;
 
     /**
      * An iterator of this `Iterable`'s entries as `[key, value]` tuples.
+     *
+     * Note: this will return an ES6 iterator which does not support Immutable JS sequence algorithms. Use `entrySeq` instead, if this is what you want.
      */
     entries(): Iterator</*[K, V]*/Array<any>>;
 
@@ -1629,20 +1933,20 @@ declare module Immutable {
     // Iterables (Seq)
 
     /**
-     * Returns a new IndexedSeq of the keys of this Iterable,
+     * Returns a new Seq.Indexed of the keys of this Iterable,
      * discarding values.
      */
-    keySeq(): IndexedSeq<K>;
+    keySeq(): Seq.Indexed<K>;
 
     /**
-     * Returns an IndexedSeq of the values of this Iterable, discarding keys.
+     * Returns an Seq.Indexed of the values of this Iterable, discarding keys.
      */
-    valueSeq(): IndexedSeq<V>;
+    valueSeq(): Seq.Indexed<V>;
 
     /**
-     * Returns a new IndexedSeq of [key, value] tuples.
+     * Returns a new Seq.Indexed of [key, value] tuples.
      */
-    entrySeq(): IndexedSeq</*(K, V)*/Array<any>>;
+    entrySeq(): Seq.Indexed</*(K, V)*/Array<any>>;
 
 
     // Sequence algorithms
@@ -1723,7 +2027,7 @@ declare module Immutable {
     ): /*this*/Iterable<K, V>;
 
     /**
-     * Returns a `KeyedIterable` of `KeyedIterables`, grouped by the return
+     * Returns a `Iterable.Keyed` of `Iterable.Keyeds`, grouped by the return
      * value of the `grouper` function.
      *
      * Note: This is always an eager operation.
@@ -1731,7 +2035,7 @@ declare module Immutable {
     groupBy<G>(
       grouper: (value?: V, key?: K, iter?: /*this*/Iterable<K, V>) => G,
       context?: any
-    ): /*Map*/KeyedSeq<G, /*this*/Iterable<K, V>>;
+    ): /*Map*/Seq.Keyed<G, /*this*/Iterable<K, V>>;
 
 
     // Side effects
@@ -1979,7 +2283,7 @@ declare module Immutable {
     ): number;
 
     /**
-     * Returns a `KeyedSeq` of counts, grouped by the return value of
+     * Returns a `Seq.Keyed` of counts, grouped by the return value of
      * the `grouper` function.
      *
      * Note: This is not a lazy operation.
@@ -1993,7 +2297,7 @@ declare module Immutable {
     // Search for value
 
     /**
-     * Returns the value for which the `predicate` returns true.
+     * Returns the first value for which the `predicate` returns true.
      */
     find(
       predicate: (value?: V, key?: K, iter?: /*this*/Iterable<K, V>) => boolean,
@@ -2013,7 +2317,7 @@ declare module Immutable {
     ): V;
 
     /**
-     * Returns the [key, value] entry for which the `predicate` returns true.
+     * Returns the first [key, value] entry for which the `predicate` returns true.
      */
     findEntry(
       predicate: (value?: V, key?: K, iter?: /*this*/Iterable<K, V>) => boolean,
@@ -2033,6 +2337,34 @@ declare module Immutable {
       notSetValue?: V
     ): /*[K, V]*/Array<any>;
 
+    /**
+     * Returns the key for which the `predicate` returns true.
+     */
+    findKey(
+      predicate: (value?: V, key?: K, iter?: /*this*/Iterable.Keyed<K, V>) => boolean,
+      context?: any
+    ): K;
+
+    /**
+     * Returns the last key for which the `predicate` returns true.
+     *
+     * Note: `predicate` will be called for each entry in reverse.
+     */
+    findLastKey(
+      predicate: (value?: V, key?: K, iter?: /*this*/Iterable.Keyed<K, V>) => boolean,
+      context?: any
+    ): K;
+
+    /**
+     * Returns the key associated with the search value, or undefined.
+     */
+    keyOf(searchValue: V): K;
+
+    /**
+     * Returns the last key associated with the search value, or undefined.
+     */
+    lastKeyOf(searchValue: V): K;
+
     /**
      * Returns the maximum value in this collection. If any values are
      * comparatively equivalent, the first one found will be returned.
@@ -2120,328 +2452,63 @@ declare module Immutable {
 
 
   /**
-   * Keyed Iterables have discrete keys tied to each value.
-   *
-   * When iterating `KeyedIterable`, each iteration will yield a `[K, V]` tuple,
-   * in other words, `Iterable#entries` is the default iterator for Keyed
-   * Iterables.
-   */
-  export module KeyedIterable {}
-
-  /**
-   * Creates a KeyedIterable
+   * Collection is the abstract base class for concrete data structures. It
+   * cannot be constructed directly.
    *
-   * Similar to `Iterable()`, however it expects iterable-likes of [K, V]
-   * tuples if not constructed from a KeyedIterable or JS Object.
-   */
-  export function KeyedIterable<K, V>(iter: KeyedIterable<K, V>): KeyedIterable<K, V>;
-  export function KeyedIterable<K, V>(iter: Iterable<any, /*[K,V]*/any>): KeyedIterable<K, V>;
-  export function KeyedIterable<K, V>(array: Array</*[K,V]*/any>): KeyedIterable<K, V>;
-  export function KeyedIterable<V>(obj: {[key: string]: V}): KeyedIterable<string, V>;
-  export function KeyedIterable<K, V>(iterator: Iterator</*[K,V]*/any>): KeyedIterable<K, V>;
-  export function KeyedIterable<K, V>(iterable: /*Iterable<[K,V]>*/Object): KeyedIterable<K, V>;
-
-  export interface KeyedIterable<K, V> extends Iterable<K, V> {
-
-    /**
-     * Returns KeyedSeq.
-     * @override
-     */
-    toSeq(): KeyedSeq<K, V>;
-
-
-    // Sequence functions
-
-    /**
-     * Returns a new KeyedIterable of the same type where the keys and values
-     * have been flipped.
-     *
-     *     Seq({ a: 'z', b: 'y' }).flip() // { z: 'a', y: 'b' }
-     *
-     */
-    flip(): /*this*/KeyedIterable<V, K>;
-
-    /**
-     * Returns a new KeyedIterable of the same type with keys passed through a
-     * `mapper` function.
-     *
-     *     Seq({ a: 1, b: 2 })
-     *       .mapKeys(x => x.toUpperCase())
-     *     // Seq { A: 1, B: 2 }
-     *
-     */
-    mapKeys<M>(
-      mapper: (key?: K, value?: V, iter?: /*this*/KeyedIterable<K, V>) => M,
-      context?: any
-    ): /*this*/KeyedIterable<M, V>;
-
-    /**
-     * Returns a new KeyedIterable of the same type with entries
-     * ([key, value] tuples) passed through a `mapper` function.
-     *
-     *     Seq({ a: 1, b: 2 })
-     *       .mapEntries(([k, v]) => [k.toUpperCase(), v * 2])
-     *     // Seq { A: 2, B: 4 }
-     *
-     */
-    mapEntries<KM, VM>(
-      mapper: (
-        entry?: /*(K, V)*/Array<any>,
-        index?: number,
-        iter?: /*this*/KeyedIterable<K, V>
-      ) => /*[KM, VM]*/Array<any>,
-      context?: any
-    ): /*this*/KeyedIterable<KM, VM>;
-
-
-    // Search for value
-
-    /**
-     * Returns the key associated with the search value, or undefined.
-     */
-    keyOf(searchValue: V): K;
-
-    /**
-     * Returns the last key associated with the search value, or undefined.
-     */
-    lastKeyOf(searchValue: V): K;
-
-    /**
-     * Returns the key for which the `predicate` returns true.
-     */
-    findKey(
-      predicate: (value?: V, key?: K, iter?: /*this*/KeyedIterable<K, V>) => boolean,
-      context?: any
-    ): K;
-
-    /**
-     * Returns the last key for which the `predicate` returns true.
-     *
-     * Note: `predicate` will be called for each entry in reverse.
-     */
-    findLastKey(
-      predicate: (value?: V, key?: K, iter?: /*this*/KeyedIterable<K, V>) => boolean,
-      context?: any
-    ): K;
-  }
-
-
-  /**
-   * Indexed Iterables have incrementing numeric keys. They exhibit
-   * slightly different behavior than `KeyedIterable` for some methods in order
-   * to better mirror the behavior of JavaScript's `Array`, and add methods
-   * which do not make sense on non-indexed Iterables such as `indexOf`.
-   *
-   * Unlike JavaScript arrays, `IndexedIterable`s are always dense. "Unset"
-   * indices and `undefined` indices are indistinguishable, and all indices from
-   * 0 to `size` are visited when iterated.
-   *
-   * All IndexedIterable methods return re-indexed Iterables. In other words,
-   * indices always start at 0 and increment until size. If you wish to
-   * preserve indices, using them as keys, convert to a KeyedIterable by calling
-   * `toKeyedSeq`.
+   * Implementations should extend one of the subclasses, `Collection.Keyed`,
+   * `Collection.Indexed`, or `Collection.Set`.
    */
-  export module IndexedIterable {}
-
-  /**
-   * Creates a new IndexedIterable.
-   */
-  export function IndexedIterable<T>(iter: IndexedIterable<T>): IndexedIterable<T>;
-  export function IndexedIterable<T>(iter: SetIterable<T>): IndexedIterable<T>;
-  export function IndexedIterable<K, V>(iter: KeyedIterable<K, V>): IndexedIterable</*[K,V]*/any>;
-  export function IndexedIterable<T>(array: Array<T>): IndexedIterable<T>;
-  export function IndexedIterable<T>(iterator: Iterator<T>): IndexedIterable<T>;
-  export function IndexedIterable<T>(iterable: /*Iterable<T>*/Object): IndexedIterable<T>;
-
-  export interface IndexedIterable<T> extends Iterable<number, T> {
-
-    // Reading values
-
-    /**
-     * Returns the value associated with the provided index, or notSetValue if
-     * the index is beyond the bounds of the Iterable.
-     *
-     * `index` may be a negative number, which indexes back from the end of the
-     * Iterable. `s.get(-1)` gets the last item in the Iterable.
-     */
-    get(index: number, notSetValue?: T): T;
+  export module Collection {
 
 
-    // Conversion to Seq
-
     /**
-     * Returns IndexedSeq.
-     * @override
+     * `Collection` which represents key-value pairs.
      */
-    toSeq(): IndexedSeq<T>;
+    export module Keyed {}
 
-    /**
-     * If this is an iterable of [key, value] entry tuples, it will return a
-     * KeyedSeq of those entries.
-     */
-    fromEntrySeq(): KeyedSeq<any, any>;
+    export interface Keyed<K, V> extends Collection<K, V>, Iterable.Keyed<K, V> {
 
+      /**
+       * Returns Seq.Keyed.
+       * @override
+       */
+      toSeq(): Seq.Keyed<K, V>;
+    }
 
-    // Combination
 
     /**
-     * Returns an Iterable of the same type with `separator` between each item
-     * in this Iterable.
+     * `Collection` which represents ordered indexed values.
      */
-    interpose(separator: T): /*this*/IndexedIterable<T>;
+    export module Indexed {}
 
-    /**
-     * Returns an Iterable of the same type with the provided `iterables`
-     * interleaved into this iterable.
-     *
-     * The resulting Iterable includes the first item from each, then the
-     * second from each, etc.
-     *
-     *     I.Seq.of(1,2,3).interleave(I.Seq.of('A','B','C'))
-     *     // Seq [ 1, 'A', 2, 'B', 3, 'C' ]
-     *
-     * The shortest Iterable stops interleave.
-     *
-     *     I.Seq.of(1,2,3).interleave(
-     *       I.Seq.of('A','B'),
-     *       I.Seq.of('X','Y','Z')
-     *     )
-     *     // Seq [ 1, 'A', 'X', 2, 'B', 'Y' ]
-     */
-    interleave(...iterables: Array<Iterable<any, T>>): /*this*/IndexedIterable<T>;
+    export interface Indexed<T> extends Collection<number, T>, Iterable.Indexed<T> {
 
-    /**
-     * Splice returns a new indexed Iterable by replacing a region of this
-     * Iterable with new values. If values are not provided, it only skips the
-     * region to be removed.
-     *
-     * `index` may be a negative number, which indexes back from the end of the
-     * Iterable. `s.splice(-2)` splices after the second to last item.
-     *
-     *     Seq(['a','b','c','d']).splice(1, 2, 'q', 'r', 's')
-     *     // Seq ['a', 'q', 'r', 's', 'd']
-     *
-     */
-    splice(
-      index: number,
-      removeNum: number,
-      ...values: /*Array<IndexedIterable<T> | T>*/any[]
-    ): /*this*/IndexedIterable<T>;
+      /**
+       * Returns Seq.Indexed.
+       * @override
+       */
+      toSeq(): Seq.Indexed<T>;
+    }
 
-    /**
-     * Returns an Iterable of the same type "zipped" with the provided
-     * iterables.
-     *
-     * Like `zipWith`, but using the default `zipper`: creating an `Array`.
-     *
-     *     var a = Seq.of(1, 2, 3);
-     *     var b = Seq.of(4, 5, 6);
-     *     var c = a.zip(b); // Seq [ [ 1, 4 ], [ 2, 5 ], [ 3, 6 ] ]
-     *
-     */
-    zip(...iterables: Array<Iterable<any, any>>): /*this*/IndexedIterable<any>;
 
     /**
-     * Returns an Iterable of the same type "zipped" with the provided
-     * iterables by using a custom `zipper` function.
+     * `Collection` which represents values, unassociated with keys or indices.
      *
-     *     var a = Seq.of(1, 2, 3);
-     *     var b = Seq.of(4, 5, 6);
-     *     var c = a.zipWith((a, b) => a + b, b); // Seq [ 5, 7, 9 ]
-     *
-     */
-    zipWith<U, Z>(
-      zipper: (value: T, otherValue: U) => Z,
-      otherIterable: Iterable<any, U>
-    ): IndexedIterable<Z>;
-    zipWith<U, V, Z>(
-      zipper: (value: T, otherValue: U, thirdValue: V) => Z,
-      otherIterable: Iterable<any, U>,
-      thirdIterable: Iterable<any, V>
-    ): IndexedIterable<Z>;
-    zipWith<Z>(
-      zipper: (...any: Array<any>) => Z,
-      ...iterables: Array<Iterable<any, any>>
-    ): IndexedIterable<Z>;
-
-
-    // Search for value
-
-    /**
-     * Returns the first index at which a given value can be found in the
-     * Iterable, or -1 if it is not present.
-     */
-    indexOf(searchValue: T): number;
-
-    /**
-     * Returns the last index at which a given value can be found in the
-     * Iterable, or -1 if it is not present.
-     */
-    lastIndexOf(searchValue: T): number;
-
-    /**
-     * Returns the first index in the Iterable where a value satisfies the
-     * provided predicate function. Otherwise -1 is returned.
-     */
-    findIndex(
-      predicate: (value?: T, index?: number, iter?: /*this*/IndexedIterable<T>) => boolean,
-      context?: any
-    ): number;
-
-    /**
-     * Returns the last index in the Iterable where a value satisfies the
-     * provided predicate function. Otherwise -1 is returned.
+     * `Collection.Set` implementations should guarantee value uniqueness.
      */
-    findLastIndex(
-      predicate: (value?: T, index?: number, iter?: /*this*/IndexedIterable<T>) => boolean,
-      context?: any
-    ): number;
-  }
+    export module Set {}
 
+    export interface Set<T> extends Collection<T, T>, Iterable.Set<T> {
 
-  /**
-   * Set Iterables only represent values. They have no associated keys or
-   * indices. Duplicate values are possible in SetSeqs, however the
-   * concrete `Set` does not allow duplicate values.
-   *
-   * Iterable methods on SetIterable such as `map` and `forEach` will provide
-   * the value as both the first and second arguments to the provided function.
-   *
-   *     var seq = SetSeq.of('A', 'B', 'C');
-   *     assert.equal(seq.every((v, k) => v === k), true);
-   *
-   */
-  export module SetIterable {}
-
-  /**
-   * Similar to `Iterable()`, but always returns a SetIterable.
-   */
-  export function SetIterable<T>(iter: SetIterable<T>): SetIterable<T>;
-  export function SetIterable<T>(iter: IndexedIterable<T>): SetIterable<T>;
-  export function SetIterable<K, V>(iter: KeyedIterable<K, V>): SetIterable</*[K,V]*/any>;
-  export function SetIterable<T>(array: Array<T>): SetIterable<T>;
-  export function SetIterable<T>(iterator: Iterator<T>): SetIterable<T>;
-  export function SetIterable<T>(iterable: /*Iterable<T>*/Object): SetIterable<T>;
-
-  export interface SetIterable<T> extends Iterable<T, T> {
+      /**
+       * Returns Seq.Set.
+       * @override
+       */
+      toSeq(): Seq.Set<T>;
+    }
 
-    /**
-     * Returns SetSeq.
-     * @override
-     */
-    toSeq(): SetSeq<T>;
   }
 
-
-  /**
-   * Collection is the abstract base class for concrete data structures. It
-   * cannot be constructed directly.
-   *
-   * Implementations should extend one of the subclasses, `KeyedCollection`,
-   * `IndexedCollection`, or `SetCollection`.
-   */
-  export module Collection {}
-
   export interface Collection<K, V> extends Iterable<K, V> {
 
     /**
@@ -2451,53 +2518,6 @@ declare module Immutable {
   }
 
 
-  /**
-   * `Collection` which represents key-value pairs.
-   */
-  export module KeyedCollection {}
-
-  export interface KeyedCollection<K, V> extends Collection<K, V>, KeyedIterable<K, V> {
-
-    /**
-     * Returns KeyedSeq.
-     * @override
-     */
-    toSeq(): KeyedSeq<K, V>;
-  }
-
-
-  /**
-   * `Collection` which represents ordered indexed values.
-   */
-  export module IndexedCollection {}
-
-  export interface IndexedCollection<T> extends Collection<number, T>, IndexedIterable<T> {
-
-    /**
-     * Returns IndexedSeq.
-     * @override
-     */
-    toSeq(): IndexedSeq<T>;
-  }
-
-
-  /**
-   * `Collection` which represents values, unassociated with keys or indices.
-   *
-   * `SetCollection` implementations should guarantee value uniqueness.
-   */
-  export module SetCollection {}
-
-  export interface SetCollection<T> extends Collection<T, T>, SetIterable<T> {
-
-    /**
-     * Returns SetSeq.
-     * @override
-     */
-    toSeq(): SetSeq<T>;
-  }
-
-
   /**
    * ES6 Iterator.
    *