immutable 3.7.2 → 3.7.6

package/dist/immutable.d.ts

@@ -28,7 +28,7 @@
  * [ES6]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/New_in_JavaScript/ECMAScript_6_support_in_Mozilla
  */
 
-declare module 'immutable' {
+declare module Immutable {
 
   /**
    * Deeply converts plain JS objects and arrays to Immutable Maps and Lists.
@@ -38,7 +38,7 @@ declare module 'immutable' {
    * and proceeding to the top-level collection itself), along with the key
    * refering 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 Iterable, allowing for custom convertions from
+   * to return a new Immutable Iterable, allowing for custom conversions from
    * deep JS objects.
    *
    * This example converts JSON to List and OrderedMap:
@@ -61,6 +61,25 @@ declare module 'immutable' {
    * arrays which pass `Array.isArray` to Lists, and only raw objects (no custom
    * prototype) to Map.
    *
+   * Keep in mind, when using JS objects to construct Immutable Maps, that
+   * JavaScript Object properties are always strings, even if written in a
+   * quote-less shorthand, while Immutable Maps accept keys of any type.
+   *
+   * ```js
+   * var obj = { 1: "one" };
+   * Object.keys(obj); // [ "1" ]
+   * obj["1"]; // "one"
+   * obj[1];   // "one"
+   *
+   * var map = Map(obj);
+   * map.get("1"); // "one"
+   * map.get(1);   // undefined
+   * ```
+   *
+   * Property access for JavaScript Objects first converts the key to a string,
+   * but since Immutable Map keys can be of any type the argument to `get()` is
+   * not altered.
+   *
    * [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"
    */
@@ -102,7 +121,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 if they were explicitly defined.
    */
   export module List {
 
@@ -122,15 +141,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
 
@@ -148,7 +167,7 @@ declare module 'immutable' {
 
     /**
      * Returns a new List which excludes this `index` and with a size 1 less
-     * than this List. Values at indicies above `index` are shifted down by 1 to
+     * than this List. Values at indices above `index` are shifted down by 1 to
      * fill the position.
      *
      * This is synonymous with `list.splice(index, 1)`.
@@ -162,6 +181,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.
      */
@@ -217,7 +244,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>;
 
     /**
@@ -225,7 +252,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,
@@ -235,7 +262,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>;
 
     /**
@@ -243,7 +270,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,
@@ -313,11 +340,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>,
@@ -329,11 +356,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>,
@@ -344,6 +371,10 @@ declare module 'immutable' {
     // Transient changes
 
     /**
+     * Note: Not all methods can be used on a mutable collection or within
+     * `withMutations`! Only `set`, `push`, `pop`, `shift`, `unshift` and
+     * `merge` may be used mutatively.
+     *
      * @see `Map#withMutations`
      */
     withMutations(mutator: (mutable: List<T>) => any): List<T>;
@@ -361,7 +392,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
@@ -394,22 +425,40 @@ declare module 'immutable' {
   /**
    * 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"});
    *     var newMap = Map([["key", "value"]]);
    *
+   * Keep in mind, when using JS objects to construct Immutable Maps, that
+   * JavaScript Object properties are always strings, even if written in a
+   * quote-less shorthand, while Immutable Maps accept keys of any type.
+   *
+   * ```js
+   * var obj = { 1: "one" };
+   * Object.keys(obj); // [ "1" ]
+   * obj["1"]; // "one"
+   * obj[1];   // "one"
+   *
+   * var map = Map(obj);
+   * map.get("1"); // "one"
+   * map.get(1);   // undefined
+   * ```
+   *
+   * Property access for JavaScript Objects first converts the key to a string,
+   * but since Immutable Map keys can be of any type the argument to `get()` is
+   * 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
 
@@ -452,8 +501,8 @@ declare module 'immutable' {
      * each iterable and sets it on this Map.
      *
      * If any of the values provided to `merge` are not Iterable (would return
-     * false for `Immutable.isIterable`) then they are deeply converted via
-     * `Immutable.fromJS` before being merged. However, if the value is an
+     * false for `Immutable.Iterable.isIterable`) then they are deeply converted
+     * via `Immutable.fromJS` before being merged. However, if the value is an
      * Iterable but includes non-iterable JS objects or arrays, those nested
      * values will be preserved.
      *
@@ -645,6 +694,9 @@ declare module 'immutable' {
      *     assert(map1.size === 0);
      *     assert(map2.size === 3);
      *
+     * Note: Not all methods can be used on a mutable collection or within
+     * `withMutations`! Only `set` and `merge` may be used mutatively.
+     *
      */
     withMutations(mutator: (mutable: Map<K, V>) => any): Map<K, V>;
 
@@ -657,6 +709,9 @@ declare module 'immutable' {
      * use API.
      *
      * Note: if the collection is already mutable, `asMutable` returns itself.
+     *
+     * Note: Not all methods can be used on a mutable collection or within
+     * `withMutations`! Only `set` and `merge` may be used mutatively.
      */
     asMutable(): Map<K, V>;
 
@@ -692,7 +747,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
@@ -703,7 +758,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>;
@@ -749,14 +804,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
 
@@ -807,6 +862,9 @@ declare module 'immutable' {
     // Transient changes
 
     /**
+     * Note: Not all methods can be used on a mutable collection or within
+     * `withMutations`! Only `add` may be used mutatively.
+     *
      * @see `Map#withMutations`
      */
     withMutations(mutator: (mutable: Set<T>) => any): Set<T>;
@@ -858,9 +916,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>;
@@ -902,14 +960,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
 
@@ -970,6 +1028,9 @@ declare module 'immutable' {
     // Transient changes
 
     /**
+     * Note: Not all methods can be used on a mutable collection or within
+     * `withMutations`! Only `set`, `push`, and `pop` may be used mutatively.
+     *
      * @see `Map#withMutations`
      */
     withMutations(mutator: (mutable: Stack<T>) => any): Stack<T>;
@@ -987,7 +1048,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.
    *
@@ -999,18 +1060,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>;
 
 
   /**
@@ -1032,7 +1093,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
@@ -1058,7 +1121,7 @@ declare module 'immutable' {
    *       }
    *     }
    *
-   *     var myRecord = new ABRecord(b:3)
+   *     var myRecord = new ABRecord({b: 3})
    *     myRecord.getAB() // 4
    *
    */
@@ -1100,7 +1163,7 @@ 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
    *
@@ -1135,9 +1198,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.
      */
-    function of<T>(...values: T[]): IndexedSeq<T>;
+    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.
+     */
+    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>
+    }
+
   }
 
   /**
@@ -1147,19 +1303,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> {
 
@@ -1201,98 +1357,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
@@ -1308,12 +1372,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;
 
@@ -1324,9 +1388,324 @@ 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>;
+
+
+      // 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*/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;
+    }
+
+
+    /**
+     * 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>;
+    }
+
   }
 
   /**
@@ -1335,21 +1714,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> {
 
@@ -1434,8 +1813,8 @@ declare module 'immutable' {
      * True if the result of following a path of keys or indices through nested
      * Iterables results in a set value.
      */
-    hasIn(searchKeyPath: Array<any>, notSetValue?: any): boolean;
-    hasIn(searchKeyPath: Iterable<any, any>, notSetValue?: any): boolean;
+    hasIn(searchKeyPath: Array<any>): boolean;
+    hasIn(searchKeyPath: Iterable<any, any>): boolean;
 
 
     // Conversion to JavaScript types
@@ -1443,8 +1822,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
      */
@@ -1526,10 +1905,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.
@@ -1542,17 +1921,17 @@ 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
@@ -1576,20 +1955,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
@@ -1670,7 +2049,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.
@@ -1678,7 +2057,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
@@ -1926,7 +2305,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.
@@ -2067,328 +2446,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`.
-   */
-  export module IndexedIterable {}
-
-  /**
-   * Creates a new IndexedIterable.
+   * Implementations should extend one of the subclasses, `Collection.Keyed`,
+   * `Collection.Indexed`, or `Collection.Set`.
    */
-  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 module Collection {
 
-  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.
+     * `Collection` which represents key-value pairs.
      */
-    get(index: number, notSetValue?: T): T;
+    export module Keyed {}
 
+    export interface Keyed<K, V> extends Collection<K, V>, Iterable.Keyed<K, V> {
 
-    // Conversion to Seq
+      /**
+       * Returns Seq.Keyed.
+       * @override
+       */
+      toSeq(): Seq.Keyed<K, V>;
+    }
 
-    /**
-     * Returns IndexedSeq.
-     * @override
-     */
-    toSeq(): IndexedSeq<T>;
 
     /**
-     * If this is an iterable of [key, value] entry tuples, it will return a
-     * KeyedSeq of those entries.
+     * `Collection` which represents ordered indexed values.
      */
-    fromEntrySeq(): KeyedSeq<any, any>;
-
+    export module Indexed {}
 
-    // Combination
+    export interface Indexed<T> extends Collection<number, T>, Iterable.Indexed<T> {
 
-    /**
-     * Returns an Iterable of the same type with `separator` between each item
-     * in this Iterable.
-     */
-    interpose(separator: T): /*this*/IndexedIterable<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*/IndexedIterable<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.
-     *
-     *     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 ] ]
+     * `Collection` which represents values, unassociated with keys or indices.
      *
+     * `Collection.Set` implementations should guarantee value uniqueness.
      */
-    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>;
+    export module Set {}
 
+    export interface Set<T> extends Collection<T, T>, Iterable.Set<T> {
 
-    // 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.
-     */
-    findLastIndex(
-      predicate: (value?: T, index?: number, iter?: /*this*/IndexedIterable<T>) => boolean,
-      context?: any
-    ): number;
-  }
-
-
-  /**
-   * 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> {
 
     /**
@@ -2398,53 +2512,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.
    *
@@ -2458,3 +2525,7 @@ declare module 'immutable' {
   }
 
 }
+
+declare module "immutable" {
+  export = Immutable
+}