immutable 3.8.2 → 4.0.0-rc.12

package/dist/immutable.js.flow

@@ -9,81 +9,96 @@
  * This file provides type definitions for use with the Flow type checker.
  *
  * An important caveat when using these definitions is that the types for
- * `Iterable.Keyed`, `Iterable.Indexed`, `Seq.Keyed`, and so on are stubs.
+ * `Collection.Keyed`, `Collection.Indexed`, `Seq.Keyed`, and so on are stubs.
  * When referring to those types, you can get the proper definitions by
- * importing the types `KeyedIterable`, `IndexedIterable`, `KeyedSeq`, etc.
+ * importing the types `KeyedCollection`, `IndexedCollection`, `KeyedSeq`, etc.
  * For example,
  *
  *     import { Seq } from 'immutable'
- *     import type { IndexedIterable, IndexedSeq } from 'immutable'
+ *     import type { IndexedCollection, IndexedSeq } from 'immutable'
  *
  *     const someSeq: IndexedSeq<number> = Seq.Indexed.of(1, 2, 3)
  *
- *     function takesASeq<T, TS: IndexedIterable<T>>(iter: TS): TS {
+ *     function takesASeq<T, TS: IndexedCollection<T>>(iter: TS): TS {
  *       return iter.butLast()
  *     }
  *
  *     takesASeq(someSeq)
  *
- * @flow
+ * @flow strict
  */
 
-/*
- * Alias for ECMAScript `Iterable` type, declared in
- * https://github.com/facebook/flow/blob/master/lib/core.js
- *
- * Note that Immutable values implement the `ESIterable` interface.
- */
-type ESIterable<T> = $Iterable<T,void,void>;
-
-declare class Iterable<K, V> extends _Iterable<K, V, typeof KeyedIterable, typeof IndexedIterable, typeof SetIterable> {}
-
-declare class _Iterable<K, V, KI, II, SI> {
-  static Keyed:   KI;
-  static Indexed: II;
-  static Set:     SI;
-
-  static isIterable(maybeIterable: any): boolean;
-  static isKeyed(maybeKeyed: any): boolean;
-  static isIndexed(maybeIndexed: any): boolean;
-  static isAssociative(maybeAssociative: any): boolean;
-  static isOrdered(maybeOrdered: any): boolean;
-
-  equals(other: Iterable<K,V>): boolean;
+// Helper type that represents plain objects allowed as arguments to
+// some constructors and functions.
+type PlainObjInput<K, V> = {+[key: K]: V, __proto__: null};
+
+// Helper types to extract the "keys" and "values" use by the *In() methods.
+type $KeyOf<C> = $Call<
+  & (<K>(?_Collection<K, mixed>) => K)
+  & (<T>(?$ReadOnlyArray<T>) => number)
+  & (<T>(?RecordInstance<T> | T) => $Keys<T>),
+  C
+>;
+
+type $ValOf<C, K = $KeyOf<C>> = $Call<
+  & (<V>(?_Collection<any, V>) => V)
+  & (<T>(?$ReadOnlyArray<T>) => T)
+  & (<T, K: $Keys<T>>(?RecordInstance<T> | T, K) => $ElementType<T, K>)
+  & (<V>(?{[any]: V}) => V),
+  C,
+  K
+>;
+
+type $IterableOf<C> = $Call<
+  & (<V: Array<any> | IndexedCollection<any> | SetCollection<any>>(V) => Iterable<$ValOf<V>>)
+  & (<V: KeyedCollection<any, any> | RecordInstance<any> | PlainObjInput<any, any>>(V) => Iterable<[$KeyOf<V>, $ValOf<V>]>),
+  C
+>;
+
+declare class _Collection<K, +V> implements ValueObject {
+  equals(other: mixed): boolean;
   hashCode(): number;
-  get(key: K): V;
-  get<V_>(key: K, notSetValue: V_): V|V_;
+  get(key: K, ..._: []): V | void;
+  get<NSV>(key: K, notSetValue: NSV): V | NSV;
   has(key: K): boolean;
   includes(value: V): boolean;
   contains(value: V): boolean;
-  first(): V;
-  last(): V;
+  first<NSV>(notSetValue?: NSV): V | NSV;
+  last<NSV>(notSetValue?: NSV): V | NSV;
+
+  hasIn(keyPath: Iterable<mixed>): boolean;
 
-  getIn<T>(searchKeyPath: ESIterable<any>, notSetValue: T): T;
-  getIn<T>(searchKeyPath: ESIterable<any>): T;
-  hasIn(searchKeyPath: ESIterable<any>): boolean;
+  getIn(keyPath: [], notSetValue?: mixed): this;
+  getIn<NSV>(keyPath: [K], notSetValue: NSV): V | NSV;
+  getIn<NSV, K2: $KeyOf<V>>(keyPath: [K, K2], notSetValue: NSV): $ValOf<V, K2> | NSV;
+  getIn<NSV, K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>>(keyPath: [K, K2, K3], notSetValue: NSV): $ValOf<$ValOf<V, K2>, K3> | NSV;
+  getIn<NSV, K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>>(keyPath: [K, K2, K3, K4], notSetValue: NSV): $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4> | NSV;
+  getIn<NSV, K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>>(keyPath: [K, K2, K3, K4, K5], notSetValue: NSV): $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5> | NSV;
 
-  toJS(): any;
-  toArray(): V[];
+  update<U>(updater: (value: this) => U): U;
+
+  toJS(): Array<any> | { [key: string]: mixed };
+  toJSON(): Array<V> | { [key: string]: V };
+  toArray(): Array<V> | Array<[K,V]>;
   toObject(): { [key: string]: V };
-  toMap(): Map<K,V>;
-  toOrderedMap(): Map<K,V>;
+  toMap(): Map<K, V>;
+  toOrderedMap(): OrderedMap<K, V>;
   toSet(): Set<V>;
-  toOrderedSet(): Set<V>;
+  toOrderedSet(): OrderedSet<V>;
   toList(): List<V>;
   toStack(): Stack<V>;
-  toSeq(): Seq<K,V>;
-  toKeyedSeq(): KeyedSeq<K,V>;
+  toSeq(): Seq<K, V>;
+  toKeyedSeq(): KeyedSeq<K, V>;
   toIndexedSeq(): IndexedSeq<V>;
   toSetSeq(): SetSeq<V>;
 
   keys(): Iterator<K>;
   values(): Iterator<V>;
-  entries(): Iterator<[K,V]>;
+  entries(): Iterator<[K, V]>;
 
   keySeq(): IndexedSeq<K>;
   valueSeq(): IndexedSeq<V>;
-  entrySeq(): IndexedSeq<[K,V]>;
+  entrySeq(): IndexedSeq<[K, V]>;
 
   reverse(): this;
   sort(comparator?: (valueA: V, valueB: V) => number): this;
@@ -95,12 +110,12 @@ declare class _Iterable<K, V, KI, II, SI> {
 
   groupBy<G>(
     grouper: (value: V, key: K, iter: this) => G,
-    context?: any
+    context?: mixed
   ): KeyedSeq<G, this>;
 
   forEach(
     sideEffect: (value: V, key: K, iter: this) => any,
-    context?: any
+    context?: mixed
   ): number;
 
   slice(begin?: number, end?: number): this;
@@ -108,73 +123,62 @@ declare class _Iterable<K, V, KI, II, SI> {
   butLast(): this;
   skip(amount: number): this;
   skipLast(amount: number): this;
-  skipWhile(predicate: (value: V, key: K, iter: this) => mixed, context?: any): this;
-  skipUntil(predicate: (value: V, key: K, iter: this) => mixed, context?: any): this;
+  skipWhile(predicate: (value: V, key: K, iter: this) => mixed, context?: mixed): this;
+  skipUntil(predicate: (value: V, key: K, iter: this) => mixed, context?: mixed): this;
   take(amount: number): this;
   takeLast(amount: number): this;
-  takeWhile(predicate: (value: V, key: K, iter: this) => mixed, context?: any): this;
-  takeUntil(predicate: (value: V, key: K, iter: this) => mixed, context?: any): this;
-  flatten(depth?: number): /*this*/Iterable<any,any>;
-  flatten(shallow?: boolean): /*this*/Iterable<any,any>;
-
-  filter(
-    predicate: (value: V, key: K, iter: this) => mixed,
-    context?: any
-  ): this;
+  takeWhile(predicate: (value: V, key: K, iter: this) => mixed, context?: mixed): this;
+  takeUntil(predicate: (value: V, key: K, iter: this) => mixed, context?: mixed): this;
 
   filterNot(
     predicate: (value: V, key: K, iter: this) => mixed,
-    context?: any
+    context?: mixed
   ): this;
 
   reduce<R>(
     reducer: (reduction: R, value: V, key: K, iter: this) => R,
-    initialReduction?: R,
-    context?: any,
+    initialReduction: R,
+    context?: mixed,
+  ): R;
+  reduce<R>(
+    reducer: (reduction: V | R, value: V, key: K, iter: this) => R
   ): R;
 
   reduceRight<R>(
     reducer: (reduction: R, value: V, key: K, iter: this) => R,
-    initialReduction?: R,
-    context?: any,
+    initialReduction: R,
+    context?: mixed,
+  ): R;
+  reduceRight<R>(
+    reducer: (reduction: V | R, value: V, key: K, iter: this) => R
   ): R;
 
-  every(predicate: (value: V, key: K, iter: this) => mixed, context?: any): boolean;
-  some(predicate: (value: V, key: K, iter: this) => mixed, context?: any): boolean;
+  every(predicate: (value: V, key: K, iter: this) => mixed, context?: mixed): boolean;
+  some(predicate: (value: V, key: K, iter: this) => mixed, context?: mixed): boolean;
   join(separator?: string): string;
   isEmpty(): boolean;
-  count(predicate?: (value: V, key: K, iter: this) => mixed, context?: any): number;
-  countBy<G>(grouper: (value: V, key: K, iter: this) => G, context?: any): Map<G,number>;
+  count(predicate?: (value: V, key: K, iter: this) => mixed, context?: mixed): number;
+  countBy<G>(grouper: (value: V, key: K, iter: this) => G, context?: mixed): Map<G, number>;
 
-  find(
+  find<NSV>(
     predicate: (value: V, key: K, iter: this) => mixed,
-    context?: any,
-  ): ?V;
-  find<V_>(
+    context?: mixed,
+    notSetValue?: NSV
+  ): V | NSV;
+  findLast<NSV>(
     predicate: (value: V, key: K, iter: this) => mixed,
-    context: any,
-    notSetValue: V_
-  ): V|V_;
+    context?: mixed,
+    notSetValue?: NSV
+  ): V | NSV;
 
-  findLast(
-    predicate: (value: V, key: K, iter: this) => mixed,
-    context?: any,
-  ): ?V;
-  findLast<V_>(
-    predicate: (value: V, key: K, iter: this) => mixed,
-    context: any,
-    notSetValue: V_
-  ): V|V_;
+  findEntry(predicate: (value: V, key: K, iter: this) => mixed): [K, V] | void;
+  findLastEntry(predicate: (value: V, key: K, iter: this) => mixed): [K, V] | void;
 
+  findKey(predicate: (value: V, key: K, iter: this) => mixed, context?: mixed): K | void;
+  findLastKey(predicate: (value: V, key: K, iter: this) => mixed, context?: mixed): K | void;
 
-  findEntry(predicate: (value: V, key: K, iter: this) => mixed): ?[K,V];
-  findLastEntry(predicate: (value: V, key: K, iter: this) => mixed): ?[K,V];
-
-  findKey(predicate: (value: V, key: K, iter: this) => mixed, context?: any): ?K;
-  findLastKey(predicate: (value: V, key: K, iter: this) => mixed, context?: any): ?K;
-
-  keyOf(searchValue: V): ?K;
-  lastKeyOf(searchValue: V): ?K;
+  keyOf(searchValue: V): K | void;
+  lastKeyOf(searchValue: V): K | void;
 
   max(comparator?: (valueA: V, valueB: V) => number): V;
   maxBy<C>(
@@ -187,54 +191,106 @@ declare class _Iterable<K, V, KI, II, SI> {
     comparator?: (valueA: C, valueB: C) => number
   ): V;
 
-  isSubset(iter: Iterable<any, V>): boolean;
-  isSubset(iter: ESIterable<V>): boolean;
-  isSuperset(iter: Iterable<any, V>): boolean;
-  isSuperset(iter: ESIterable<V>): boolean;
+  isSubset(iter: Iterable<V>): boolean;
+  isSuperset(iter: Iterable<V>): boolean;
 }
 
-declare class KeyedIterable<K,V> extends Iterable<K,V> {
-  static <K,V>(iter?: ESIterable<[K,V]>): KeyedIterable<K,V>;
-  static <K,V>(obj?: { [key: K]: V }): KeyedIterable<K,V>;
+declare function isImmutable(maybeImmutable: mixed): boolean %checks(maybeImmutable instanceof Collection);
+declare function isCollection(maybeCollection: mixed): boolean %checks(maybeCollection instanceof Collection);
+declare function isKeyed(maybeKeyed: mixed): boolean %checks(maybeKeyed instanceof KeyedCollection);
+declare function isIndexed(maybeIndexed: mixed): boolean %checks(maybeIndexed instanceof IndexedCollection);
+declare function isAssociative(maybeAssociative: mixed): boolean %checks(
+  maybeAssociative instanceof KeyedCollection ||
+  maybeAssociative instanceof IndexedCollection
+);
+declare function isOrdered(maybeOrdered: mixed): boolean %checks(
+  maybeOrdered instanceof IndexedCollection ||
+  maybeOrdered instanceof OrderedMap ||
+  maybeOrdered instanceof OrderedSet
+);
+declare function isValueObject(maybeValue: mixed): boolean;
+
+declare function isSeq(maybeSeq: any): boolean %checks(maybeSeq instanceof Seq);
+declare function isList(maybeList: any): boolean %checks(maybeList instanceof List);
+declare function isMap(maybeMap: any): boolean %checks(maybeMap instanceof Map);
+declare function isOrderedMap(maybeOrderedMap: any): boolean %checks(maybeOrderedMap instanceof OrderedMap);
+declare function isStack(maybeStack: any): boolean %checks(maybeStack instanceof Stack);
+declare function isSet(maybeSet: any): boolean %checks(maybeSet instanceof Set);
+declare function isOrderedSet(maybeOrderedSet: any): boolean %checks(maybeOrderedSet instanceof OrderedSet);
+declare function isRecord(maybeRecord: any): boolean %checks(maybeRecord instanceof Record);
+
+declare interface ValueObject {
+  equals(other: mixed): boolean;
+  hashCode(): number;
+}
 
-  @@iterator(): Iterator<[K,V]>;
-  toSeq(): KeyedSeq<K,V>;
-  flip(): /*this*/KeyedIterable<V,K>;
+declare class Collection<K, +V> extends _Collection<K, V> {
+  static Keyed: typeof KeyedCollection;
+  static Indexed: typeof IndexedCollection;
+  static Set: typeof SetCollection;
 
-  mapKeys<K_>(
-    mapper: (key: K, value: V, iter: this) => K_,
-    context?: any
-  ): /*this*/KeyedIterable<K_,V>;
+  static isCollection: typeof isCollection;
+  static isKeyed: typeof isKeyed;
+  static isIndexed: typeof isIndexed;
+  static isAssociative: typeof isAssociative;
+  static isOrdered: typeof isOrdered;
+}
 
-  mapEntries<K_,V_>(
-    mapper: (entry: [K,V], index: number, iter: this) => [K_,V_],
-    context?: any
-  ): /*this*/KeyedIterable<K_,V_>;
+declare class KeyedCollection<K, +V> extends Collection<K, V> {
+  static <K, V>(values?: Iterable<[K, V]> | PlainObjInput<K, V>): KeyedCollection<K, V>;
 
-  concat(...iters: ESIterable<[K,V]>[]): this;
+  toJS(): { [key: string]: mixed };
+  toJSON(): { [key: string]: V };
+  toArray(): Array<[K, V]>;
+  @@iterator(): Iterator<[K, V]>;
+  toSeq(): KeyedSeq<K, V>;
+  flip(): KeyedCollection<V, K>;
 
-  map<V_>(
-    mapper: (value: V, key: K, iter: this) => V_,
-    context?: any
-  ): /*this*/KeyedIterable<K,V_>;
+  concat<KC, VC>(...iters: Array<Iterable<[KC, VC]> | PlainObjInput<KC, VC>>): KeyedCollection<K | KC, V | VC>;
 
-  flatMap<K_, V_>(
-    mapper: (value: V, key: K, iter: this) => ESIterable<[K_,V_]>,
-    context?: any
-  ): /*this*/KeyedIterable<K_,V_>;
+  filter(predicate: typeof Boolean): KeyedCollection<K, $NonMaybeType<V>>;
+  filter(
+    predicate: (value: V, key: K, iter: this) => mixed,
+    context?: mixed
+  ): KeyedCollection<K, V>;
 
-  flatten(depth?: number): /*this*/KeyedIterable<any,any>;
-  flatten(shallow?: boolean): /*this*/KeyedIterable<any,any>;
+  map<M>(
+    mapper: (value: V, key: K, iter: this) => M,
+    context?: mixed
+  ): KeyedCollection<K, M>;
+
+  mapKeys<M>(
+    mapper: (key: K, value: V, iter: this) => M,
+    context?: mixed
+  ): KeyedCollection<M, V>;
+
+  mapEntries<KM, VM>(
+    mapper: (entry: [K, V], index: number, iter: this) => [KM, VM],
+    context?: mixed
+  ): KeyedCollection<KM, VM>;
+
+  flatMap<KM, VM>(
+    mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,
+    context?: mixed
+  ): KeyedCollection<KM, VM>;
+
+  flatten(depth?: number): KeyedCollection<any, any>;
+  flatten(shallow?: boolean): KeyedCollection<any, any>;
 }
 
-declare class IndexedIterable<T> extends Iterable<number,T> {
-  static <T>(iter?: ESIterable<T>): IndexedIterable<T>;
+Collection.Keyed = KeyedCollection
+
+declare class IndexedCollection<+T> extends Collection<number, T> {
+  static <T>(iter?: Iterable<T>): IndexedCollection<T>;
 
+  toJS(): Array<mixed>;
+  toJSON(): Array<T>;
+  toArray(): Array<T>;
   @@iterator(): Iterator<T>;
   toSeq(): IndexedSeq<T>;
-  fromEntrySeq<K,V>(): KeyedSeq<K,V>;
+  fromEntrySeq<K, V>(): KeyedSeq<K, V>;
   interpose(separator: T): this;
-  interleave(...iterables: ESIterable<T>[]): this;
+  interleave(...collections: Iterable<T>[]): this;
   splice(
     index: number,
     removeNum: number,
@@ -242,418 +298,1325 @@ declare class IndexedIterable<T> extends Iterable<number,T> {
   ): this;
 
   zip<A>(
-    a: ESIterable<A>,
-    $?: null
-  ): IndexedIterable<[T,A]>;
-  zip<A,B>(
-    a: ESIterable<A>,
-    b: ESIterable<B>,
-    $?: null
-  ): IndexedIterable<[T,A,B]>;
-  zip<A,B,C>(
-    a: ESIterable<A>,
-    b: ESIterable<B>,
-    c: ESIterable<C>,
-    $?: null
-  ): IndexedIterable<[T,A,B,C]>;
-  zip<A,B,C,D>(
-    a: ESIterable<A>,
-    b: ESIterable<B>,
-    c: ESIterable<C>,
-    d: ESIterable<D>,
-    $?: null
-  ): IndexedIterable<[T,A,B,C,D]>;
-  zip<A,B,C,D,E>(
-    a: ESIterable<A>,
-    b: ESIterable<B>,
-    c: ESIterable<C>,
-    d: ESIterable<D>,
-    e: ESIterable<E>,
-    $?: null
-  ): IndexedIterable<[T,A,B,C,D,E]>;
-
-  zipWith<A,R>(
+    a: Iterable<A>,
+    ..._: []
+  ): IndexedCollection<[T, A]>;
+  zip<A, B>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): IndexedCollection<[T, A, B]>;
+  zip<A, B, C>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): IndexedCollection<[T, A, B, C]>;
+  zip<A, B, C, D>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): IndexedCollection<[T, A, B, C, D]>;
+  zip<A, B, C, D, E>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): IndexedCollection<[T, A, B, C, D, E]>;
+
+  zipAll<A>(
+    a: Iterable<A>,
+    ..._: []
+  ): IndexedCollection<[T|void, A|void]>;
+  zipAll<A, B>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): IndexedCollection<[T|void, A|void, B|void]>;
+  zipAll<A, B, C>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): IndexedCollection<[T|void, A|void, B|void, C|void]>;
+  zipAll<A, B, C, D>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): IndexedCollection<[T|void, A|void, B|void, C|void, D|void]>;
+  zipAll<A, B, C, D, E>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): IndexedCollection<[T|void, A|void, B|void, C|void, D|void, E|void]>;
+
+  zipWith<A, R>(
     zipper: (value: T, a: A) => R,
-    a: ESIterable<A>,
-    $?: null
-  ): IndexedIterable<R>;
-  zipWith<A,B,R>(
+    a: Iterable<A>,
+    ..._: []
+  ): IndexedCollection<R>;
+  zipWith<A, B, R>(
     zipper: (value: T, a: A, b: B) => R,
-    a: ESIterable<A>,
-    b: ESIterable<B>,
-    $?: null
-  ): IndexedIterable<R>;
-  zipWith<A,B,C,R>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): IndexedCollection<R>;
+  zipWith<A, B, C, R>(
     zipper: (value: T, a: A, b: B, c: C) => R,
-    a: ESIterable<A>,
-    b: ESIterable<B>,
-    c: ESIterable<C>,
-    $?: null
-  ): IndexedIterable<R>;
-  zipWith<A,B,C,D,R>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): IndexedCollection<R>;
+  zipWith<A, B, C, D, R>(
     zipper: (value: T, a: A, b: B, c: C, d: D) => R,
-    a: ESIterable<A>,
-    b: ESIterable<B>,
-    c: ESIterable<C>,
-    d: ESIterable<D>,
-    $?: null
-  ): IndexedIterable<R>;
-  zipWith<A,B,C,D,E,R>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): IndexedCollection<R>;
+  zipWith<A, B, C, D, E, R>(
     zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,
-    a: ESIterable<A>,
-    b: ESIterable<B>,
-    c: ESIterable<C>,
-    d: ESIterable<D>,
-    e: ESIterable<E>,
-    $?: null
-  ): IndexedIterable<R>;
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): IndexedCollection<R>;
 
   indexOf(searchValue: T): number;
   lastIndexOf(searchValue: T): number;
   findIndex(
     predicate: (value: T, index: number, iter: this) => mixed,
-    context?: any
+    context?: mixed
   ): number;
   findLastIndex(
     predicate: (value: T, index: number, iter: this) => mixed,
-    context?: any
+    context?: mixed
   ): number;
 
-  concat(...iters: ESIterable<T>[]): this;
+  concat<C>(...iters: Array<Iterable<C> | C>): IndexedCollection<T | C>;
 
-  map<U>(
-    mapper: (value: T, index: number, iter: this) => U,
-    context?: any
-  ): /*this*/IndexedIterable<U>;
+  filter(predicate: typeof Boolean): IndexedCollection<$NonMaybeType<T>>;
+  filter(
+    predicate: (value: T, index: number, iter: this) => mixed,
+    context?: mixed
+  ): IndexedCollection<T>;
 
-  flatMap<U>(
-    mapper: (value: T, index: number, iter: this) => ESIterable<U>,
-    context?: any
-  ): /*this*/IndexedIterable<U>;
+  map<M>(
+    mapper: (value: T, index: number, iter: this) => M,
+    context?: mixed
+  ): IndexedCollection<M>;
 
-  flatten(depth?: number): /*this*/IndexedIterable<any>;
-  flatten(shallow?: boolean): /*this*/IndexedIterable<any>;
+  flatMap<M>(
+    mapper: (value: T, index: number, iter: this) => Iterable<M>,
+    context?: mixed
+  ): IndexedCollection<M>;
+
+  flatten(depth?: number): IndexedCollection<any>;
+  flatten(shallow?: boolean): IndexedCollection<any>;
 }
 
-declare class SetIterable<T> extends Iterable<T,T> {
-  static <T>(iter?: ESIterable<T>): SetIterable<T>;
+declare class SetCollection<+T> extends Collection<T, T> {
+  static <T>(iter?: Iterable<T>): SetCollection<T>;
 
+  toJS(): Array<mixed>;
+  toJSON(): Array<T>;
+  toArray(): Array<T>;
   @@iterator(): Iterator<T>;
   toSeq(): SetSeq<T>;
 
-  concat(...iters: ESIterable<T>[]): this;
-
-  // `map` and `flatMap` cannot be defined further up the hiearchy, because the
-  // implementation for `KeyedIterable` allows the value type to change without
-  // constraining the key type. That does not work for `SetIterable` - the value
-  // and key types *must* match.
-  map<U>(
-    mapper: (value: T, value: T, iter: this) => U,
-    context?: any
-  ): /*this*/SetIterable<U>;
-
-  flatMap<U>(
-    mapper: (value: T, value: T, iter: this) => ESIterable<U>,
-    context?: any
-  ): /*this*/SetIterable<U>;
+  concat<U>(...collections: Iterable<U>[]): SetCollection<T | U>;
 
-  flatten(depth?: number): /*this*/SetIterable<any>;
-  flatten(shallow?: boolean): /*this*/SetIterable<any>;
-}
+  // `filter`, `map` and `flatMap` cannot be defined further up the hierarchy,
+  // because the implementation for `KeyedCollection` allows the value type to
+  // change without constraining the key type. That does not work for
+  // `SetCollection` - the value and key types *must* match.
+  filter(predicate: typeof Boolean): SetCollection<$NonMaybeType<T>>;
+  filter(
+    predicate: (value: T, value: T, iter: this) => mixed,
+    context?: mixed
+  ): SetCollection<T>;
 
-declare class Collection<K,V> extends _Iterable<K,V, typeof KeyedCollection, typeof IndexedCollection, typeof SetCollection> {
-  size: number;
-}
+  map<M>(
+    mapper: (value: T, value: T, iter: this) => M,
+    context?: mixed
+  ): SetCollection<M>;
 
-declare class KeyedCollection<K,V> extends Collection<K,V> mixins KeyedIterable<K,V> {
-  toSeq(): KeyedSeq<K,V>;
-}
+  flatMap<M>(
+    mapper: (value: T, value: T, iter: this) => Iterable<M>,
+    context?: mixed
+  ): SetCollection<M>;
 
-declare class IndexedCollection<T> extends Collection<number,T> mixins IndexedIterable<T> {
-  toSeq(): IndexedSeq<T>;
+  flatten(depth?: number): SetCollection<any>;
+  flatten(shallow?: boolean): SetCollection<any>;
 }
 
-declare class SetCollection<T> extends Collection<T,T> mixins SetIterable<T> {
-  toSeq(): SetSeq<T>;
-}
+declare function isSeq(maybeSeq: mixed): boolean %checks(maybeSeq instanceof Seq);
+declare class Seq<K, +V> extends _Collection<K, V> {
+  static Keyed: typeof KeyedSeq;
+  static Indexed: typeof IndexedSeq;
+  static Set: typeof SetSeq;
 
-declare class Seq<K,V> extends _Iterable<K,V, typeof KeyedSeq, typeof IndexedSeq, typeof SetSeq> {
-  static <K,V>(iter: KeyedSeq<K,V>):   KeyedSeq<K,V>;
-  static <T>  (iter: SetSeq<T>):       SetSeq<K,V>;
-  static <T>  (iter?: ESIterable<T>):  IndexedSeq<T>;
-  static <K,V>(iter: { [key: K]: V }): KeyedSeq<K,V>;
+  static <K, V>(values: KeyedSeq<K, V>): KeyedSeq<K, V>;
+  static <T>(values: SetSeq<T>): SetSeq<K, V>;
+  static <T>(values: Iterable<T>): IndexedSeq<T>;
+  static <K, V>(values?: PlainObjInput<K, V>): KeyedSeq<K, V>;
 
-  static isSeq(maybeSeq: any): boolean;
-  static of<T>(...values: T[]): IndexedSeq<T>;
+  static isSeq: typeof isSeq;
 
-  size: ?number;
+  size: number | void;
   cacheResult(): this;
   toSeq(): this;
 }
 
-declare class KeyedSeq<K,V> extends Seq<K,V> mixins KeyedIterable<K,V> {
-  static <K,V>(iter?: ESIterable<[K,V]>): KeyedSeq<K,V>;
-  static <K,V>(iter?: { [key: K]: V }): KeyedSeq<K,V>;
+declare class KeyedSeq<K, +V> extends Seq<K, V> mixins KeyedCollection<K, V> {
+  static <K, V>(values?: Iterable<[K, V]> | PlainObjInput<K, V>): KeyedSeq<K, V>;
+
+  // Override specialized return types
+  flip(): KeyedSeq<V, K>;
+
+  concat<KC, VC>(...iters: Array<Iterable<[KC, VC]> | PlainObjInput<KC, VC>>): KeyedSeq<K | KC, V | VC>;
+
+  filter(predicate: typeof Boolean): KeyedSeq<K, $NonMaybeType<V>>;
+  filter(
+    predicate: (value: V, key: K, iter: this) => mixed,
+    context?: mixed
+  ): KeyedSeq<K, V>;
+
+  map<M>(
+    mapper: (value: V, key: K, iter: this) => M,
+    context?: mixed
+  ): KeyedSeq<K, M>;
+
+  mapKeys<M>(
+    mapper: (key: K, value: V, iter: this) => M,
+    context?: mixed
+  ): KeyedSeq<M, V>;
+
+  mapEntries<KM, VM>(
+    mapper: (entry: [K, V], index: number, iter: this) => [KM, VM],
+    context?: mixed
+  ): KeyedSeq<KM, VM>;
+
+  flatMap<KM, VM>(
+    mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,
+    context?: mixed
+  ): KeyedSeq<KM, VM>;
+
+  flatten(depth?: number): KeyedSeq<any, any>;
+  flatten(shallow?: boolean): KeyedSeq<any, any>;
 }
 
-declare class IndexedSeq<T> extends Seq<number,T> mixins IndexedIterable<T> {
-  static <T>(iter?: ESIterable<T>): IndexedSeq<T>;
+declare class IndexedSeq<+T> extends Seq<number, T> mixins IndexedCollection<T> {
+  static <T>(values?: Iterable<T>): IndexedSeq<T>;
+
   static of<T>(...values: T[]): IndexedSeq<T>;
+
+  // Override specialized return types
+
+  concat<C>(...iters: Array<Iterable<C> | C>): IndexedSeq<T | C>;
+
+  filter(predicate: typeof Boolean): IndexedSeq<$NonMaybeType<T>>;
+  filter(
+    predicate: (value: T, index: number, iter: this) => mixed,
+    context?: mixed
+  ): IndexedSeq<T>;
+
+  map<M>(
+    mapper: (value: T, index: number, iter: this) => M,
+    context?: mixed
+  ): IndexedSeq<M>;
+
+  flatMap<M>(
+    mapper: (value: T, index: number, iter: this) => Iterable<M>,
+    context?: mixed
+  ): IndexedSeq<M>;
+
+  flatten(depth?: number): IndexedSeq<any>;
+  flatten(shallow?: boolean): IndexedSeq<any>;
+
+  zip<A>(
+    a: Iterable<A>,
+    ..._: []
+  ): IndexedSeq<[T, A]>;
+  zip<A, B>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): IndexedSeq<[T, A, B]>;
+  zip<A, B, C>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): IndexedSeq<[T, A, B, C]>;
+  zip<A, B, C, D>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): IndexedSeq<[T, A, B, C, D]>;
+  zip<A, B, C, D, E>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): IndexedSeq<[T, A, B, C, D, E]>;
+
+  zipAll<A>(
+    a: Iterable<A>,
+    ..._: []
+  ): IndexedSeq<[T|void, A|void]>;
+  zipAll<A, B>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): IndexedSeq<[T|void, A|void, B|void]>;
+  zipAll<A, B, C>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): IndexedSeq<[T|void, A|void, B|void, C|void]>;
+  zipAll<A, B, C, D>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): IndexedSeq<[T|void, A|void, B|void, C|void, D|void]>;
+  zipAll<A, B, C, D, E>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): IndexedSeq<[T|void, A|void, B|void, C|void, D|void, E|void]>;
+
+  zipWith<A, R>(
+    zipper: (value: T, a: A) => R,
+    a: Iterable<A>,
+    ..._: []
+  ): IndexedSeq<R>;
+  zipWith<A, B, R>(
+    zipper: (value: T, a: A, b: B) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): IndexedSeq<R>;
+  zipWith<A, B, C, R>(
+    zipper: (value: T, a: A, b: B, c: C) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): IndexedSeq<R>;
+  zipWith<A, B, C, D, R>(
+    zipper: (value: T, a: A, b: B, c: C, d: D) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): IndexedSeq<R>;
+  zipWith<A, B, C, D, E, R>(
+    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): IndexedSeq<R>;
 }
 
-declare class SetSeq<T> extends Seq<T,T> mixins SetIterable<T> {
-  static <T>(iter?: ESIterable<T>): IndexedSeq<T>;
+declare class SetSeq<+T> extends Seq<T, T> mixins SetCollection<T> {
+  static <T>(values?: Iterable<T>): SetSeq<T>;
+
   static of<T>(...values: T[]): SetSeq<T>;
+
+  // Override specialized return types
+
+  concat<U>(...collections: Iterable<U>[]): SetSeq<T | U>;
+
+  filter(predicate: typeof Boolean): SetSeq<$NonMaybeType<T>>;
+  filter(
+    predicate: (value: T, value: T, iter: this) => mixed,
+    context?: mixed
+  ): SetSeq<T>;
+
+  map<M>(
+    mapper: (value: T, value: T, iter: this) => M,
+    context?: mixed
+  ): SetSeq<M>;
+
+  flatMap<M>(
+    mapper: (value: T, value: T, iter: this) => Iterable<M>,
+    context?: mixed
+  ): SetSeq<M>;
+
+  flatten(depth?: number): SetSeq<any>;
+  flatten(shallow?: boolean): SetSeq<any>;
+}
+
+declare class UpdatableInCollection<K, +V> {
+  setIn<S>(keyPath: [], value: S): S;
+  setIn(keyPath: [K], value: V): this;
+  setIn<K2: $KeyOf<V>, S: $ValOf<V, K2>>(keyPath: [K, K2], value: S): this;
+  setIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, S: $ValOf<$ValOf<V, K2>, K3>>(keyPath: [K, K2, K3], value: S): this;
+  setIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>, S: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>(keyPath: [K, K2, K3, K4], value: S): this;
+  setIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>, S: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>>(keyPath: [K, K2, K3, K4, K5], value: S): this;
+
+  deleteIn(keyPath: []): void;
+  deleteIn(keyPath: [K]): this;
+  deleteIn<K2: $KeyOf<V>>(keyPath: [K, K2]): this;
+  deleteIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>>(keyPath: [K, K2, K3]): this;
+  deleteIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>>(keyPath: [K, K2, K3, K4]): this;
+  deleteIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>>(keyPath: [K, K2, K3, K4, K5]): this;
+
+  removeIn(keyPath: []): void;
+  removeIn(keyPath: [K]): this;
+  removeIn<K2: $KeyOf<V>>(keyPath: [K, K2]): this;
+  removeIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>>(keyPath: [K, K2, K3]): this;
+  removeIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>>(keyPath: [K, K2, K3, K4]): this;
+  removeIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>>(keyPath: [K, K2, K3, K4, K5]): this;
+
+  updateIn<U>(keyPath: [], notSetValue: mixed, updater: (value: this) => U): U;
+  updateIn<U>(keyPath: [], updater: (value: this) => U): U;
+  updateIn<NSV>(keyPath: [K], notSetValue: NSV, updater: (value: V) => V): this;
+  updateIn(keyPath: [K], updater: (value: V) => V): this;
+  updateIn<NSV, K2: $KeyOf<V>, S: $ValOf<V, K2>>(keyPath: [K, K2], notSetValue: NSV, updater: (value: $ValOf<V, K2> | NSV) => S): this;
+  updateIn<K2: $KeyOf<V>, S: $ValOf<V, K2>>(keyPath: [K, K2], updater: (value: $ValOf<V, K2>) => S): this;
+  updateIn<NSV, K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, S: $ValOf<$ValOf<V, K2>, K3>>(keyPath: [K, K2, K3], notSetValue: NSV, updater: (value: $ValOf<$ValOf<V, K2>, K3> | NSV) => S): this;
+  updateIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, S: $ValOf<$ValOf<V, K2>, K3>>(keyPath: [K, K2, K3], updater: (value: $ValOf<$ValOf<V, K2>, K3>) => S): this;
+  updateIn<NSV, K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>, S: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>(keyPath: [K, K2, K3, K4], notSetValue: NSV, updater: (value: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4> | NSV) => S): this;
+  updateIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>, S: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>(keyPath: [K, K2, K3, K4], updater: (value: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>) => S): this;
+  updateIn<NSV, K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>, S: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>>(keyPath: [K, K2, K3, K4, K5], notSetValue: NSV, updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5> | NSV) => S): this;
+  updateIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>, S: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>>(keyPath: [K, K2, K3, K4, K5], updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>) => S): this;
 }
 
-declare class List<T> extends IndexedCollection<T> {
-  static (iterable?: ESIterable<T>): List<T>;
+declare function isList(maybeList: mixed): boolean %checks(maybeList instanceof List);
+declare class List<+T> extends IndexedCollection<T> mixins UpdatableInCollection<number, T> {
+  static (collection?: Iterable<T>): List<T>;
 
-  static isList(maybeList: any): boolean;
   static of<T>(...values: T[]): List<T>;
 
-  set<U>(index: number, value: U): List<T|U>;
+  static isList: typeof isList;
+
+  size: number;
+
+  set<U>(index: number, value: U): List<T | U>;
   delete(index: number): this;
   remove(index: number): this;
-  insert<U>(index: number, value: U): List<T|U>;
+  insert<U>(index: number, value: U): List<T | U>;
   clear(): this;
-  push<U>(...values: U[]): List<T|U>;
+  push<U>(...values: U[]): List<T | U>;
   pop(): this;
-  unshift<U>(...values: U[]): List<T|U>;
+  unshift<U>(...values: U[]): List<T | U>;
   shift(): this;
 
-  update<U>(updater: (value: this) => List<U>): List<U>;
-  update<U>(index: number, updater: (value: T) => U): List<T|U>;
-  update<U>(index: number, notSetValue: U, updater: (value: T) => U): List<T|U>;
+  update<U>(updater: (value: this) => U): U;
+  update<U>(index: number, updater: (value: T) => U): List<T | U>;
+  update<U>(index: number, notSetValue: U, updater: (value: T) => U): List<T | U>;
 
-  merge<U>(...iterables: ESIterable<U>[]): List<T|U>;
+  merge<U>(...collections: Iterable<U>[]): List<T | U>;
 
-  mergeWith<U,V>(
-    merger: (previous: T, next: U, key: number) => V,
-    ...iterables: ESIterable<U>[]
-  ): List<T|U|V>;
+  setSize(size: number): this;
 
-  mergeDeep<U>(...iterables: ESIterable<U>[]): List<T|U>;
+  mergeIn(keyPath: Iterable<mixed>, ...collections: Iterable<mixed>[]): this;
+  mergeDeepIn(keyPath: Iterable<mixed>, ...collections: Iterable<mixed>[]): this;
 
-  mergeDeepWith<U,V>(
-    merger: (previous: T, next: U, key: number) => V,
-    ...iterables: ESIterable<U>[]
-  ): List<T|U|V>;
-
-  setSize(size: number): List<?T>;
-  setIn(keyPath: ESIterable<any>, value: any): List<T>;
-  deleteIn(keyPath: ESIterable<any>, value: any): this;
-  removeIn(keyPath: ESIterable<any>, value: any): this;
+  withMutations(mutator: (mutable: this) => mixed): this;
+  asMutable(): this;
+  wasAltered(): boolean;
+  asImmutable(): this;
 
-  updateIn(keyPath: ESIterable<any>, notSetValue: any, value: any): List<T>;
-  updateIn(keyPath: ESIterable<any>, value: any): List<T>;
+  // Override specialized return types
 
-  mergeIn(keyPath: ESIterable<any>, ...iterables: ESIterable<any>[]): List<T>;
-  mergeDeepIn(keyPath: ESIterable<any>, ...iterables: ESIterable<any>[]): List<T>;
+  concat<C>(...iters: Array<Iterable<C> | C>): List<T | C>;
 
-  withMutations(mutator: (mutable: this) => any): this;
-  asMutable(): this;
-  asImmutable(): this;
+  filter(predicate: typeof Boolean): List<$NonMaybeType<T>>;
+  filter(
+    predicate: (value: T, index: number, iter: this) => mixed,
+    context?: mixed
+  ): List<T>;
 
-  // Overrides that specialize return types
   map<M>(
     mapper: (value: T, index: number, iter: this) => M,
-    context?: any
+    context?: mixed
   ): List<M>;
 
   flatMap<M>(
-    mapper: (value: T, index: number, iter: this) => ESIterable<M>,
-    context?: any
+    mapper: (value: T, index: number, iter: this) => Iterable<M>,
+    context?: mixed
   ): List<M>;
 
-  flatten(depth?: number): /*this*/List<any>;
-  flatten(shallow?: boolean): /*this*/List<any>;
+  flatten(depth?: number): List<any>;
+  flatten(shallow?: boolean): List<any>;
+
+  zip<A>(
+    a: Iterable<A>,
+    ..._: []
+  ): List<[T, A]>;
+  zip<A, B>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): List<[T, A, B]>;
+  zip<A, B, C>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): List<[T, A, B, C]>;
+  zip<A, B, C, D>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): List<[T, A, B, C, D]>;
+  zip<A, B, C, D, E>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): List<[T, A, B, C, D, E]>;
+
+  zipAll<A>(
+    a: Iterable<A>,
+    ..._: []
+  ): List<[T|void, A|void]>;
+  zipAll<A, B>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): List<[T|void, A|void, B|void]>;
+  zipAll<A, B, C>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): List<[T|void, A|void, B|void, C|void]>;
+  zipAll<A, B, C, D>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): List<[T|void, A|void, B|void, C|void, D|void]>;
+  zipAll<A, B, C, D, E>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): List<[T|void, A|void, B|void, C|void, D|void, E|void]>;
+
+  zipWith<A, R>(
+    zipper: (value: T, a: A) => R,
+    a: Iterable<A>,
+    ..._: []
+  ): List<R>;
+  zipWith<A, B, R>(
+    zipper: (value: T, a: A, b: B) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): List<R>;
+  zipWith<A, B, C, R>(
+    zipper: (value: T, a: A, b: B, c: C) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): List<R>;
+  zipWith<A, B, C, D, R>(
+    zipper: (value: T, a: A, b: B, c: C, d: D) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): List<R>;
+  zipWith<A, B, C, D, E, R>(
+    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): List<R>;
 }
 
-declare class Map<K,V> extends KeyedCollection<K,V> {
-  static <K, V>(): Map<K, V>;
-  static <V>(obj?: {[key: string]: V}): Map<string, V>;
-  static <K, V>(iterable?: ESIterable<[K,V]>): Map<K, V>;
+declare function isMap(maybeMap: mixed): boolean %checks(maybeMap instanceof Map);
+declare class Map<K, +V> extends KeyedCollection<K, V> mixins UpdatableInCollection<K, V> {
+  static <K, V>(values?: Iterable<[K, V]> | PlainObjInput<K, V>): Map<K, V>;
 
-  static isMap(maybeMap: any): boolean;
+  static isMap: typeof isMap;
 
-  set<K_, V_>(key: K_, value: V_): Map<K|K_, V|V_>;
+  size: number;
+
+  set<K_, V_>(key: K_, value: V_): Map<K | K_, V | V_>;
   delete(key: K): this;
   remove(key: K): this;
   clear(): this;
 
-  update<K_,V_>(updater: (value: this) => Map<K_,V_>): Map<K_,V_>;
-  update<V_>(key: K, updater: (value: V) => V_): Map<K,V|V_>;
-  update<V_>(key: K, notSetValue: V_, updater: (value: V) => V_): Map<K,V|V_>;
+  deleteAll(keys: Iterable<K>): Map<K, V>;
+  removeAll(keys: Iterable<K>): Map<K, V>;
+
+  update<U>(updater: (value: this) => U): U;
+  update<V_>(key: K, updater: (value: V) => V_): Map<K, V | V_>;
+  update<V_>(key: K, notSetValue: V_, updater: (value: V) => V_): Map<K, V | V_>;
+
+  merge<K_, V_>(
+    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
+  ): Map<K | K_, V | V_>;
+  concat<K_, V_>(
+    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
+  ): Map<K | K_, V | V_>;
+
+  mergeWith<K_, W, X>(
+    merger: (oldVal: V, newVal: W, key: K) => X,
+    ...collections: (Iterable<[K_, W]> | PlainObjInput<K_, W>)[]
+  ): Map<K | K_, V | W | X>;
+
+  mergeDeep<K_, V_>(
+    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
+  ): Map<K | K_, V | V_>;
+
+  mergeDeepWith<K_, V_>(
+    merger: (oldVal: any, newVal: any, key: any) => mixed,
+    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
+  ): Map<K | K_, V | V_>;
+
+  mergeIn(
+    keyPath: Iterable<mixed>,
+    ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
+  ): this;
+  mergeDeepIn(
+    keyPath: Iterable<mixed>,
+    ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
+  ): this;
 
-  merge<K_,V_>(
-    ...iterables: (ESIterable<[K_,V_]> | { [key: K_]: V_ })[]
-  ): Map<K|K_,V|V_>;
+  withMutations(mutator: (mutable: this) => mixed): this;
+  asMutable(): this;
+  wasAltered(): boolean;
+  asImmutable(): this;
 
-  mergeWith<K_,W,X>(
-    merger: (previous: V, next: W, key: number) => X,
-    ...iterables: ESIterable<W>[]
-  ): Map<K,V|W|X>;
+  // Override specialized return types
 
-  mergeDeep<K_,V_>(
-    ...iterables: (ESIterable<[K_,V_]> | { [key: K_]: V_ })[]
-  ): Map<K|K_,V|V_>;
+  flip(): Map<V, K>;
 
-  mergeDeepWith<K_,W,X>(
-    merger: (previous: V, next: W, key: number) => X,
-    ...iterables: ESIterable<W>[]
-  ): Map<K,V|W|X>;
+  filter(predicate: typeof Boolean): Map<K, $NonMaybeType<V>>;
+  filter(
+    predicate: (value: V, key: K, iter: this) => mixed,
+    context?: mixed
+  ): Map<K, V>;
 
-  setIn(keyPath: ESIterable<any>, value: any): Map<K,V>;
-  deleteIn(keyPath: ESIterable<any>, value: any): this;
-  removeIn(keyPath: ESIterable<any>, value: any): this;
+  map<M>(
+    mapper: (value: V, key: K, iter: this) => M,
+    context?: mixed
+  ): Map<K, M>;
+
+  mapKeys<M>(
+    mapper: (key: K, value: V, iter: this) => M,
+    context?: mixed
+  ): Map<M, V>;
+
+  mapEntries<KM, VM>(
+    mapper: (entry: [K, V], index: number, iter: this) => [KM, VM],
+    context?: mixed
+  ): Map<KM, VM>;
+
+  flatMap<KM, VM>(
+    mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,
+    context?: mixed
+  ): Map<KM, VM>;
+
+  flatten(depth?: number): Map<any, any>;
+  flatten(shallow?: boolean): Map<any, any>;
+}
 
-  updateIn(keyPath: ESIterable<any>, notSetValue: any, value: any): Map<K,V>;
-  updateIn(keyPath: ESIterable<any>, value: any): Map<K,V>;
+declare function isOrderedMap(maybeOrderedMap: mixed): boolean %checks(maybeOrderedMap instanceof OrderedMap);
+declare class OrderedMap<K, +V> extends Map<K, V> mixins UpdatableInCollection<K, V> {
+  static <K, V>(values?: Iterable<[K, V]> | PlainObjInput<K, V>): OrderedMap<K, V>;
 
-  mergeIn(keyPath: ESIterable<any>, ...iterables: ESIterable<any>[]): Map<K,V>;
-  mergeDeepIn(keyPath: ESIterable<any>, ...iterables: ESIterable<any>[]): Map<K,V>;
+  static isOrderedMap: typeof isOrderedMap;
 
-  withMutations(mutator: (mutable: this) => any): this;
-  asMutable(): this;
-  asImmutable(): this;
+  size: number;
 
-  // Overrides that specialize return types
+  set<K_, V_>(key: K_, value: V_): OrderedMap<K | K_, V | V_>;
+  delete(key: K): this;
+  remove(key: K): this;
+  clear(): this;
 
-  map<V_>(
-    mapper: (value: V, key: K, iter: this) => V_,
-    context?: any
-  ): Map<K,V_>;
+  update<U>(updater: (value: this) => U): U;
+  update<V_>(key: K, updater: (value: V) => V_): OrderedMap<K, V | V_>;
+  update<V_>(key: K, notSetValue: V_, updater: (value: V) => V_): OrderedMap<K, V | V_>;
+
+  merge<K_, V_>(
+    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
+  ): OrderedMap<K | K_, V | V_>;
+  concat<K_, V_>(
+    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
+  ): OrderedMap<K | K_, V | V_>;
+
+  mergeWith<K_, W, X>(
+    merger: (oldVal: V, newVal: W, key: K) => X,
+    ...collections: (Iterable<[K_, W]> | PlainObjInput<K_, W>)[]
+  ): OrderedMap<K | K_, V | W | X>;
+
+  mergeDeep<K_, V_>(
+    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
+  ): OrderedMap<K | K_, V | V_>;
+
+  mergeDeepWith<K_, V_>(
+    merger: (oldVal: any, newVal: any, key: any) => mixed,
+    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
+  ): OrderedMap<K | K_, V | V_>;
+
+  mergeIn(
+    keyPath: Iterable<mixed>,
+    ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
+  ): this;
+  mergeDeepIn(
+    keyPath: Iterable<mixed>,
+    ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
+  ): this;
 
-  flatMap<K_,V_>(
-    mapper: (value: V, key: K, iter: this) => ESIterable<[K_,V_]>,
-    context?: any
-  ): Map<K_,V_>;
+  withMutations(mutator: (mutable: this) => mixed): this;
+  asMutable(): this;
+  wasAltered(): boolean;
+  asImmutable(): this;
 
-  flip(): Map<V,K>;
+  // Override specialized return types
 
-  mapKeys<K_>(
-    mapper: (key: K, value: V, iter: this) => K_,
-    context?: any
-  ): Map<K_,V>;
+  flip(): OrderedMap<V, K>;
 
-  flatten(depth?: number): /*this*/Map<any,any>;
-  flatten(shallow?: boolean): /*this*/Map<any,any>;
-}
+  filter(predicate: typeof Boolean): OrderedMap<K, $NonMaybeType<V>>;
+  filter(
+    predicate: (value: V, key: K, iter: this) => mixed,
+    context?: mixed
+  ): OrderedMap<K, V>;
 
-// OrderedMaps have nothing that Maps do not have. We do not need to override constructor & other statics
-declare class OrderedMap<K,V> extends Map<K,V> {
-  static isOrderedMap(maybeOrderedMap: any): bool;
+  map<M>(
+    mapper: (value: V, key: K, iter: this) => M,
+    context?: mixed
+  ): OrderedMap<K, M>;
+
+  mapKeys<M>(
+    mapper: (key: K, value: V, iter: this) => M,
+    context?: mixed
+  ): OrderedMap<M, V>;
+
+  mapEntries<KM, VM>(
+    mapper: (entry: [K, V], index: number, iter: this) => [KM, VM],
+    context?: mixed
+  ): OrderedMap<KM, VM>;
+
+  flatMap<KM, VM>(
+    mapper: (value: V, key: K, iter: this) => Iterable<[KM, VM]>,
+    context?: mixed
+  ): OrderedMap<KM, VM>;
+
+  flatten(depth?: number): OrderedMap<any, any>;
+  flatten(shallow?: boolean): OrderedMap<any, any>;
 }
 
-declare class Set<T> extends SetCollection<T> {
-  static <T>(iterable?: ESIterable<T>): Set<T>;
+declare function isSet(maybeSet: mixed): boolean %checks(maybeSet instanceof Set);
+declare class Set<+T> extends SetCollection<T> {
+  static <T>(values?: Iterable<T>): Set<T>;
 
-  static isSet(maybeSet: any): boolean;
   static of<T>(...values: T[]): Set<T>;
-  static fromKeys<T>(iter: ESIterable<[T,any]>): Set<T>;
-  static fromKeys(iter: { [key: string]: any }): Set<string>;
+  static fromKeys<T>(values: Iterable<[T, mixed]> | PlainObjInput<T, mixed>): Set<T>;
 
-  add<U>(value: U): Set<T|U>;
+  static intersect(sets: Iterable<Iterable<T>>): Set<T>;
+  static union(sets: Iterable<Iterable<T>>): Set<T>;
+
+  static isSet: typeof isSet;
+
+  size: number;
+
+  add<U>(value: U): Set<T | U>;
   delete(value: T): this;
   remove(value: T): this;
   clear(): this;
-  union<U>(...iterables: ESIterable<U>[]): Set<T|U>;
-  merge<U>(...iterables: ESIterable<U>[]): Set<T|U>;
-  intersect<U>(...iterables: ESIterable<U>[]): Set<T&U>;
-  subtract<U>(...iterables: ESIterable<U>[]): Set<T>;
+  union<U>(...collections: Iterable<U>[]): Set<T | U>;
+  merge<U>(...collections: Iterable<U>[]): Set<T | U>;
+  concat<U>(...collections: Iterable<U>[]): Set<T | U>;
+  intersect<U>(...collections: Iterable<U>[]): Set<T & U>;
+  subtract(...collections: Iterable<mixed>[]): this;
 
-  withMutations(mutator: (mutable: this) => any): this;
+  withMutations(mutator: (mutable: this) => mixed): this;
   asMutable(): this;
+  wasAltered(): boolean;
   asImmutable(): this;
 
-  // Overrides that specialize return types
+  // Override specialized return types
+
+  filter(predicate: typeof Boolean): Set<$NonMaybeType<T>>;
+  filter(
+    predicate: (value: T, value: T, iter: this) => mixed,
+    context?: mixed
+  ): Set<T>;
 
   map<M>(
     mapper: (value: T, value: T, iter: this) => M,
-    context?: any
+    context?: mixed
   ): Set<M>;
 
   flatMap<M>(
-    mapper: (value: T, value: T, iter: this) => ESIterable<M>,
-    context?: any
+    mapper: (value: T, value: T, iter: this) => Iterable<M>,
+    context?: mixed
   ): Set<M>;
 
-  flatten(depth?: number): /*this*/Set<any>;
-  flatten(shallow?: boolean): /*this*/Set<any>;
+  flatten(depth?: number): Set<any>;
+  flatten(shallow?: boolean): Set<any>;
 }
 
-// OrderedSets have nothing that Sets do not have. We do not need to override constructor & other statics
-declare class OrderedSet<T> extends Set<T> {
-  static isOrderedSet(maybeOrderedSet: any): bool;
+// Overrides except for `isOrderedSet` are for specialized return types
+declare function isOrderedSet(maybeOrderedSet: mixed): boolean %checks(maybeOrderedSet instanceof OrderedSet);
+declare class OrderedSet<+T> extends Set<T> {
+  static <T>(values?: Iterable<T>): OrderedSet<T>;
+
+  static of<T>(...values: T[]): OrderedSet<T>;
+  static fromKeys<T>(values: Iterable<[T, mixed]> | PlainObjInput<T, mixed>): OrderedSet<T>;
+
+  static isOrderedSet: typeof isOrderedSet;
+
+  size: number;
+
+  add<U>(value: U): OrderedSet<T | U>;
+  union<U>(...collections: Iterable<U>[]): OrderedSet<T | U>;
+  merge<U>(...collections: Iterable<U>[]): OrderedSet<T | U>;
+  concat<U>(...collections: Iterable<U>[]): OrderedSet<T | U>;
+  intersect<U>(...collections: Iterable<U>[]): OrderedSet<T & U>;
+
+  filter(predicate: typeof Boolean): OrderedSet<$NonMaybeType<T>>;
+  filter(
+    predicate: (value: T, value: T, iter: this) => mixed,
+    context?: mixed
+  ): OrderedSet<T>;
+
+  map<M>(
+    mapper: (value: T, value: T, iter: this) => M,
+    context?: mixed
+  ): OrderedSet<M>;
+
+  flatMap<M>(
+    mapper: (value: T, value: T, iter: this) => Iterable<M>,
+    context?: mixed
+  ): OrderedSet<M>;
+
+  flatten(depth?: number): OrderedSet<any>;
+  flatten(shallow?: boolean): OrderedSet<any>;
+
+  zip<A>(
+    a: Iterable<A>,
+    ..._: []
+  ): OrderedSet<[T, A]>;
+  zip<A, B>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): OrderedSet<[T, A, B]>;
+  zip<A, B, C>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): OrderedSet<[T, A, B, C]>;
+  zip<A, B, C, D>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): OrderedSet<[T, A, B, C, D]>;
+  zip<A, B, C, D, E>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): OrderedSet<[T, A, B, C, D, E]>;
+
+  zipAll<A>(
+    a: Iterable<A>,
+    ..._: []
+  ): OrderedSet<[T|void, A|void]>;
+  zipAll<A, B>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): OrderedSet<[T|void, A|void, B|void]>;
+  zipAll<A, B, C>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): OrderedSet<[T|void, A|void, B|void, C|void]>;
+  zipAll<A, B, C, D>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): OrderedSet<[T|void, A|void, B|void, C|void, D|void]>;
+  zipAll<A, B, C, D, E>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): OrderedSet<[T|void, A|void, B|void, C|void, D|void, E|void]>;
+
+  zipWith<A, R>(
+    zipper: (value: T, a: A) => R,
+    a: Iterable<A>,
+    ..._: []
+  ): OrderedSet<R>;
+  zipWith<A, B, R>(
+    zipper: (value: T, a: A, b: B) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): OrderedSet<R>;
+  zipWith<A, B, C, R>(
+    zipper: (value: T, a: A, b: B, c: C) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): OrderedSet<R>;
+  zipWith<A, B, C, D, R>(
+    zipper: (value: T, a: A, b: B, c: C, d: D) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): OrderedSet<R>;
+  zipWith<A, B, C, D, E, R>(
+    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): OrderedSet<R>;
 }
 
-declare class Stack<T> extends IndexedCollection<T> {
-  static <T>(iterable?: ESIterable<T>): Stack<T>;
+declare function isStack(maybeStack: mixed): boolean %checks(maybeStack instanceof Stack);
+declare class Stack<+T> extends IndexedCollection<T> {
+  static <T>(collection?: Iterable<T>): Stack<T>;
 
-  static isStack(maybeStack: any): boolean;
+  static isStack(maybeStack: mixed): boolean;
   static of<T>(...values: T[]): Stack<T>;
 
+  static isStack: typeof isStack;
+
+  size: number;
+
   peek(): T;
   clear(): this;
-  unshift<U>(...values: U[]): Stack<T|U>;
-  unshiftAll<U>(iter: ESIterable<U>): Stack<T|U>;
+  unshift<U>(...values: U[]): Stack<T | U>;
+  unshiftAll<U>(iter: Iterable<U>): Stack<T | U>;
   shift(): this;
-  push<U>(...values: U[]): Stack<T|U>;
-  pushAll<U>(iter: ESIterable<U>): Stack<T|U>;
+  push<U>(...values: U[]): Stack<T | U>;
+  pushAll<U>(iter: Iterable<U>): Stack<T | U>;
   pop(): this;
 
-  withMutations(mutator: (mutable: this) => any): this;
+  withMutations(mutator: (mutable: this) => mixed): this;
   asMutable(): this;
+  wasAltered(): boolean;
   asImmutable(): this;
 
-  // Overrides that specialize return types
+  // Override specialized return types
+
+  concat<C>(...iters: Array<Iterable<C> | C>): Stack<T | C>;
+
+  filter(predicate: typeof Boolean): Stack<$NonMaybeType<T>>;
+  filter(
+    predicate: (value: T, index: number, iter: this) => mixed,
+    context?: mixed
+  ): Stack<T>;
+
+  map<M>(
+    mapper: (value: T, index: number, iter: this) => M,
+    context?: mixed
+  ): Stack<M>;
 
-  map<U>(
-    mapper: (value: T, index: number, iter: this) => U,
-    context?: any
-  ): Stack<U>;
+  flatMap<M>(
+    mapper: (value: T, index: number, iter: this) => Iterable<M>,
+    context?: mixed
+  ): Stack<M>;
 
-  flatMap<U>(
-    mapper: (value: T, index: number, iter: this) => ESIterable<U>,
-    context?: any
-  ): Stack<U>;
+  flatten(depth?: number): Stack<any>;
+  flatten(shallow?: boolean): Stack<any>;
 
-  flatten(depth?: number): /*this*/Stack<any>;
-  flatten(shallow?: boolean): /*this*/Stack<any>;
+  zip<A>(
+    a: Iterable<A>,
+    ..._: []
+  ): Stack<[T, A]>;
+  zip<A, B>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): Stack<[T, A, B]>;
+  zip<A, B, C>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): Stack<[T, A, B, C]>;
+  zip<A, B, C, D>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): Stack<[T, A, B, C, D]>;
+  zip<A, B, C, D, E>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): Stack<[T, A, B, C, D, E]>;
+
+  zipAll<A>(
+    a: Iterable<A>,
+    ..._: []
+  ): Stack<[T|void, A|void]>;
+  zipAll<A, B>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): Stack<[T|void, A|void, B|void]>;
+  zipAll<A, B, C>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): Stack<[T|void, A|void, B|void, C|void]>;
+  zipAll<A, B, C, D>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): Stack<[T|void, A|void, B|void, C|void, D|void]>;
+  zipAll<A, B, C, D, E>(
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): Stack<[T|void, A|void, B|void, C|void, D|void, E|void]>;
+
+  zipWith<A, R>(
+    zipper: (value: T, a: A) => R,
+    a: Iterable<A>,
+    ..._: []
+  ): Stack<R>;
+  zipWith<A, B, R>(
+    zipper: (value: T, a: A, b: B) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    ..._: []
+  ): Stack<R>;
+  zipWith<A, B, C, R>(
+    zipper: (value: T, a: A, b: B, c: C) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    ..._: []
+  ): Stack<R>;
+  zipWith<A, B, C, D, R>(
+    zipper: (value: T, a: A, b: B, c: C, d: D) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    ..._: []
+  ): Stack<R>;
+  zipWith<A, B, C, D, E, R>(
+    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,
+    a: Iterable<A>,
+    b: Iterable<B>,
+    c: Iterable<C>,
+    d: Iterable<D>,
+    e: Iterable<E>,
+    ..._: []
+  ): Stack<R>;
 }
 
 declare function Range(start?: number, end?: number, step?: number): IndexedSeq<number>;
 declare function Repeat<T>(value: T, times?: number): IndexedSeq<T>;
 
-//TODO: Once flow can extend normal Objects we can change this back to actually reflect Record behavior.
-// For now fallback to any to not break existing Code
-declare class Record<T: Object> {
-  static <T: Object>(spec: T, name?: string): /*T & Record<T>*/any;
-  get<A>(key: $Keys<T>): A;
-  set<A>(key: $Keys<T>, value: A): /*T & Record<T>*/this;
-  remove(key: $Keys<T>): /*T & Record<T>*/this;
+// The type of a Record factory function.
+type RecordFactory<Values: Object> = Class<RecordInstance<Values>>;
+
+// The type of runtime Record instances.
+type RecordOf<Values: Object> = RecordInstance<Values> & $ReadOnly<Values>;
+
+// The values of a Record instance.
+type _RecordValues<T, R: RecordInstance<T> | T> = R;
+type RecordValues<R> = _RecordValues<*, R>;
+
+declare function isRecord(maybeRecord: any): boolean %checks(maybeRecord instanceof RecordInstance);
+declare class Record {
+  static <Values: Object>(spec: Values, name?: string): typeof RecordInstance;
+  constructor<Values: Object>(spec: Values, name?: string): typeof RecordInstance;
+
+  static isRecord: typeof isRecord;
+
+  static getDescriptiveName(record: RecordInstance<any>): string;
 }
 
-declare function fromJS(json: any, reviver?: (k: any, v: Iterable<any,any>) => any): any;
-declare function is(first: any, second: any): boolean;
+declare class RecordInstance<T: Object = Object> {
+  static (values?: Iterable<[$Keys<T>, $ValOf<T>]> | $Shape<T>): RecordOf<T>;
+  // Note: a constructor can only create an instance of RecordInstance<T>,
+  // it's encouraged to not use `new` when creating Records.
+  constructor (values?: Iterable<[$Keys<T>, $ValOf<T>]> | $Shape<T>): void;
+
+  size: number;
+
+  has(key: string): boolean;
+
+  get<K: $Keys<T>>(key: K, ..._: []): $ElementType<T, K>;
+  get<K: $Keys<T>, NSV>(key: K, notSetValue: NSV): $ElementType<T, K> | NSV;
+
+  hasIn(keyPath: Iterable<mixed>): boolean;
+
+  getIn(keyPath: [], notSetValue?: mixed): this & $ReadOnly<T>;
+  getIn<K: $Keys<T>>(keyPath: [K], notSetValue?: mixed): $ElementType<T, K>;
+  getIn<NSV, K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>>(keyPath: [K, K2], notSetValue: NSV): $ValOf<$ValOf<T, K>, K2> | NSV;
+  getIn<NSV, K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>>(keyPath: [K, K2, K3], notSetValue: NSV): $ValOf<$ValOf<$ValOf<T, K>, K2>, K3> | NSV;
+  getIn<NSV, K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>>(keyPath: [K, K2, K3, K4], notSetValue: NSV): $ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4> | NSV;
+  getIn<NSV, K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>>>(keyPath: [K, K2, K3, K4, K5], notSetValue: NSV): $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>, K5> | NSV;
+
+  equals(other: any): boolean;
+  hashCode(): number;
+
+  set<K: $Keys<T>>(key: K, value: $ElementType<T, K>): this & $ReadOnly<T>;
+  update<K: $Keys<T>>(key: K, updater: (value: $ElementType<T, K>) => $ElementType<T, K>): this & $ReadOnly<T>;
+  merge(...collections: Array<Iterable<[$Keys<T>, $ValOf<T>]> | $Shape<T>>): this & $ReadOnly<T>;
+  mergeDeep(...collections: Array<Iterable<[$Keys<T>, $ValOf<T>]> | $Shape<T>>): this & $ReadOnly<T>;
+
+  mergeWith(
+    merger: (oldVal: $ValOf<T>, newVal: $ValOf<T>, key: $Keys<T>) => $ValOf<T>,
+    ...collections: Array<Iterable<[$Keys<T>, $ValOf<T>]> | $Shape<T>>
+  ): this & $ReadOnly<T>;
+  mergeDeepWith(
+    merger: (oldVal: any, newVal: any, key: any) => any,
+    ...collections: Array<Iterable<[$Keys<T>, $ValOf<T>]> | $Shape<T>>
+  ): this & $ReadOnly<T>;
+
+  delete<K: $Keys<T>>(key: K): this & $ReadOnly<T>;
+  remove<K: $Keys<T>>(key: K): this & $ReadOnly<T>;
+  clear(): this & $ReadOnly<T>;
+
+  setIn<S>(keyPath: [], value: S): S;
+  setIn<K: $Keys<T>, S: $ValOf<T, K>>(keyPath: [K], value: S): this & $ReadOnly<T>;
+  setIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, S: $ValOf<$ValOf<T, K>, K2>>(keyPath: [K, K2], value: S): this & $ReadOnly<T>;
+  setIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, S: $ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>(keyPath: [K, K2, K3], value: S): this & $ReadOnly<T>;
+  setIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>, S: $ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>>(keyPath: [K, K2, K3, K4], value: S): this & $ReadOnly<T>;
+  setIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>>, S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>, K5>>(keyPath: [K, K2, K3, K4, K5], value: S): this & $ReadOnly<T>;
+
+  deleteIn(keyPath: []): void;
+  deleteIn<K: $Keys<T>>(keyPath: [K]): this & $ReadOnly<T>;
+  deleteIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>>(keyPath: [K, K2]): this & $ReadOnly<T>;
+  deleteIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>>(keyPath: [K, K2, K3]): this & $ReadOnly<T>;
+  deleteIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>>(keyPath: [K, K2, K3, K4]): this & $ReadOnly<T>;
+  deleteIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>>>(keyPath: [K, K2, K3, K4, K5]): this & $ReadOnly<T>;
+
+  removeIn(keyPath: []): void;
+  removeIn<K: $Keys<T>>(keyPath: [K]): this & $ReadOnly<T>;
+  removeIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>>(keyPath: [K, K2]): this & $ReadOnly<T>;
+  removeIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>>(keyPath: [K, K2, K3]): this & $ReadOnly<T>;
+  removeIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>>(keyPath: [K, K2, K3, K4]): this & $ReadOnly<T>;
+  removeIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>>>(keyPath: [K, K2, K3, K4, K5]): this & $ReadOnly<T>;
+
+  updateIn<U>(keyPath: [], notSetValue: mixed, updater: (value: this & T) => U): U;
+  updateIn<U>(keyPath: [], updater: (value: this & T) => U): U;
+  updateIn<NSV, K: $Keys<T>, S: $ValOf<T, K>>(keyPath: [K], notSetValue: NSV, updater: (value: $ValOf<T, K>) => S): this & $ReadOnly<T>;
+  updateIn<K: $Keys<T>, S: $ValOf<T, K>>(keyPath: [K], updater: (value: $ValOf<T, K>) => S): this & $ReadOnly<T>;
+  updateIn<NSV, K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, S: $ValOf<$ValOf<T, K>, K2>>(keyPath: [K, K2], notSetValue: NSV, updater: (value: $ValOf<$ValOf<T, K>, K2> | NSV) => S): this & $ReadOnly<T>;
+  updateIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, S: $ValOf<$ValOf<T, K>, K2>>(keyPath: [K, K2], updater: (value: $ValOf<$ValOf<T, K>, K2>) => S): this & $ReadOnly<T>;
+  updateIn<NSV, K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, S: $ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>(keyPath: [K, K2, K3], notSetValue: NSV, updater: (value: $ValOf<$ValOf<$ValOf<T, K>, K2>, K3> | NSV) => S): this & $ReadOnly<T>;
+  updateIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, S: $ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>(keyPath: [K, K2, K3], updater: (value: $ValOf<$ValOf<$ValOf<T, K>, K2>, K3>) => S): this & $ReadOnly<T>;
+  updateIn<NSV, K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>, S: $ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>>(keyPath: [K, K2, K3, K4], notSetValue: NSV, updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4> | NSV) => S): this & $ReadOnly<T>;
+  updateIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>, S: $ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>>(keyPath: [K, K2, K3, K4], updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>) => S): this & $ReadOnly<T>;
+  updateIn<NSV, K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>>, S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>, K5>>(keyPath: [K, K2, K3, K4, K5], notSetValue: NSV, updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>, K5> | NSV) => S): this & $ReadOnly<T>;
+  updateIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>>, S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>, K5>>(keyPath: [K, K2, K3, K4, K5], updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>, K5>) => S): this & $ReadOnly<T>;
+
+  mergeIn(keyPath: Iterable<mixed>, ...collections: Array<any>): this & $ReadOnly<T>;
+  mergeDeepIn(keyPath: Iterable<mixed>, ...collections: Array<any>): this & $ReadOnly<T>;
+
+  toSeq(): KeyedSeq<$Keys<T>, any>;
+
+  toJS(): { [key: $Keys<T>]: mixed };
+  toJSON(): T;
+  toObject(): T;
+
+  withMutations(mutator: (mutable: this & T) => mixed): this & $ReadOnly<T>;
+  asMutable(): this & $ReadOnly<T>;
+  wasAltered(): boolean;
+  asImmutable(): this & $ReadOnly<T>;
+
+  @@iterator(): Iterator<[$Keys<T>, $ValOf<T>]>;
+}
+
+declare function fromJS(
+  jsValue: mixed,
+  reviver?: (
+    key: string | number,
+    sequence: KeyedCollection<string, mixed> | IndexedCollection<mixed>,
+    path?: Array<string | number>
+  ) => mixed
+): mixed;
+
+declare function is(first: mixed, second: mixed): boolean;
+declare function hash(value: mixed): number;
+
+declare function get<C: Object, K: $Keys<C>>(collection: C, key: K, notSetValue: mixed): $ValOf<C, K>;
+declare function get<C, K: $KeyOf<C>, NSV>(collection: C, key: K, notSetValue: NSV): $ValOf<C, K> | NSV;
+
+declare function has(collection: Object, key: mixed): boolean;
+declare function remove<C>(collection: C, key: $KeyOf<C>): C;
+declare function set<C, K: $KeyOf<C>, V: $ValOf<C, K>>(collection: C, key: K, value: V): C;
+declare function update<C, K: $KeyOf<C>, V: $ValOf<C, K>, NSV>(collection: C, key: K, notSetValue: NSV, updater: ($ValOf<C, K> | NSV) => V): C;
+declare function update<C, K: $KeyOf<C>, V: $ValOf<C, K>>(collection: C, key: K, updater: ($ValOf<C, K>) => V): C;
+
+declare function getIn<C>(collection: C, keyPath: [], notSetValue?: mixed): C;
+declare function getIn<C, K: $KeyOf<C>, NSV>(collection: C, keyPath: [K], notSetValue: NSV): $ValOf<C, K> | NSV;
+declare function getIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, NSV>(collection: C, keyPath: [K, K2], notSetValue: NSV): $ValOf<$ValOf<C, K>, K2> | NSV;
+declare function getIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, NSV>(collection: C, keyPath: [K, K2, K3], notSetValue: NSV): $ValOf<$ValOf<$ValOf<C, K>, K2>, K3> | NSV;
+declare function getIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>>, NSV>(collection: C, keyPath: [K, K2, K3, K4], notSetValue: NSV): $ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4> | NSV;
+declare function getIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>>, NSV>(collection: C, keyPath: [K, K2, K3, K4, K5], notSetValue: NSV): $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>, K5> | NSV;
+
+declare function hasIn(collection: Object, keyPath: Iterable<mixed>): boolean;
+
+declare function removeIn<C>(collection: C, keyPath: []): void;
+declare function removeIn<C, K: $KeyOf<C>>(collection: C, keyPath: [K]): C;
+declare function removeIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C>>>(collection: C, keyPath: [K, K2]): C;
+declare function removeIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C>>, K3: $KeyOf<$ValOf<$ValOf<C>, K2>>>(collection: C, keyPath: [K, K2, K3]): C;
+declare function removeIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C>>, K3: $KeyOf<$ValOf<$ValOf<C>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<C>, K2>, K3>>>(collection: C, keyPath: [K, K2, K3, K4]): C;
+declare function removeIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C>>, K3: $KeyOf<$ValOf<$ValOf<C>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<C>, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<C>, K2>, K3>, K4>>>(collection: C, keyPath: [K, K2, K3, K4, K5]): C;
+
+declare function setIn<S>(collection: Object, keyPath: [], value: S): S;
+declare function setIn<C, K: $KeyOf<C>, S: $ValOf<C, K>>(collection: C, keyPath: [K], value: S): C;
+declare function setIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, S: $ValOf<$ValOf<C, K>, K2>>(collection: C, keyPath: [K, K2], value: S): C;
+declare function setIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, S: $ValOf<$ValOf<$ValOf<C, K>, K2>, K3>>(collection: C, keyPath: [K, K2, K3], value: S): C;
+declare function setIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>>, S: $ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>>(collection: C, keyPath: [K, K2, K3, K4], value: S): C;
+declare function setIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>>, S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>, K5>>(collection: C, keyPath: [K, K2, K3, K4, K5], value: S): C;
+
+declare function updateIn<C, S>(collection: C, keyPath: [], notSetValue: mixed, updater: (value: C) => S): S;
+declare function updateIn<C, S>(collection: C, keyPath: [], updater: (value: C) => S): S;
+declare function updateIn<C, K: $KeyOf<C>, S: $ValOf<C, K>, NSV>(collection: C, keyPath: [K], notSetValue: NSV, updater: (value: $ValOf<C, K> | NSV) => S): C;
+declare function updateIn<C, K: $KeyOf<C>, S: $ValOf<C, K>>(collection: C, keyPath: [K], updater: (value: $ValOf<C, K>) => S): C;
+declare function updateIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, S: $ValOf<$ValOf<C, K>, K2>, NSV>(collection: C, keyPath: [K, K2], notSetValue: NSV, updater: (value: $ValOf<$ValOf<C, K>, K2> | NSV) => S): C;
+declare function updateIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, S: $ValOf<$ValOf<C, K>, K2>>(collection: C, keyPath: [K, K2], updater: (value: $ValOf<$ValOf<C, K>, K2>) => S): C;
+declare function updateIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, S: $ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, NSV>(collection: C, keyPath: [K, K2, K3], notSetValue: NSV, updater: (value: $ValOf<$ValOf<$ValOf<C, K>, K2>, K3> | NSV) => S): C;
+declare function updateIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, S: $ValOf<$ValOf<$ValOf<C, K>, K2>, K3>>(collection: C, keyPath: [K, K2, K3], updater: (value: $ValOf<$ValOf<$ValOf<C, K>, K2>, K3>) => S): C;
+declare function updateIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>>, S: $ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>, NSV>(collection: C, keyPath: [K, K2, K3, K4], notSetValue: NSV, updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4> | NSV) => S): C;
+declare function updateIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>>, S: $ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>>(collection: C, keyPath: [K, K2, K3, K4], updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>) => S): C;
+declare function updateIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>>, S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>, K5>, NSV>(collection: C, keyPath: [K, K2, K3, K4, K5], notSetValue: NSV, updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>, K5> | NSV) => S): C;
+declare function updateIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>, K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>, K4: $KeyOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>>, K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>>, S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>, K5>>(collection: C, keyPath: [K, K2, K3, K4, K5], updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<C, K>, K2>, K3>, K4>, K5>) => S): C;
+
+declare function merge<C>(
+  collection: C,
+  ...collections: Array<$IterableOf<C> | $Shape<RecordValues<C>> | PlainObjInput<$KeyOf<C>, $ValOf<C>>>
+): C;
+declare function mergeWith<C>(
+  merger: (oldVal: $ValOf<C>, newVal: $ValOf<C>, key: $KeyOf<C>) => $ValOf<C>,
+  collection: C,
+  ...collections: Array<$IterableOf<C> | $Shape<RecordValues<C>> | PlainObjInput<$KeyOf<C>, $ValOf<C>>>
+): C;
+declare function mergeDeep<C>(
+  collection: C,
+  ...collections: Array<$IterableOf<C> | $Shape<RecordValues<C>> | PlainObjInput<$KeyOf<C>, $ValOf<C>>>
+): C;
+declare function mergeDeepWith<C>(
+  merger: (oldVal: any, newVal: any, key: any) => mixed,
+  collection: C,
+  ...collections: Array<$IterableOf<C> | $Shape<RecordValues<C>> | PlainObjInput<$KeyOf<C>, $ValOf<C>>>
+): C;
 
 export {
-  Iterable,
   Collection,
   Seq,
 
-  // These classes do not actually exist under these names. But it is useful to
-  // have the types available.
-  KeyedIterable,
-  IndexedIterable,
-  SetIterable,
-  KeyedCollection,
-  IndexedCollection,
-  SetCollection,
-  KeyedSeq,
-  IndexedSeq,
-  SetSeq,
+  List,
+  Map,
+  OrderedMap,
+  OrderedSet,
+  Range,
+  Repeat,
+  Record,
+  Set,
+  Stack,
+
+  fromJS,
+  is,
+  hash,
+
+  isImmutable,
+  isCollection,
+  isKeyed,
+  isIndexed,
+  isAssociative,
+  isOrdered,
+  isRecord,
+  isValueObject,
+
+  get,
+  has,
+  remove,
+  set,
+  update,
+  getIn,
+  hasIn,
+  removeIn,
+  setIn,
+  updateIn,
+  merge,
+  mergeWith,
+  mergeDeep,
+  mergeDeepWith,
+}
+
+export default {
+  Collection,
+  Seq,
 
   List,
   Map,
@@ -667,4 +1630,45 @@ export {
 
   fromJS,
   is,
+  hash,
+
+  isImmutable,
+  isCollection,
+  isKeyed,
+  isIndexed,
+  isAssociative,
+  isOrdered,
+  isRecord,
+  isValueObject,
+
+  get,
+  has,
+  remove,
+  set,
+  update,
+  getIn,
+  hasIn,
+  removeIn,
+  setIn,
+  updateIn,
+  merge,
+  mergeWith,
+  mergeDeep,
+  mergeDeepWith,
+}
+
+export type {
+  KeyedCollection,
+  IndexedCollection,
+  SetCollection,
+  KeyedSeq,
+  IndexedSeq,
+  SetSeq,
+  RecordFactory,
+  RecordOf,
+  RecordInstance,
+  ValueObject,
+
+  $KeyOf,
+  $ValOf,
 }