immutable 4.0.0-rc.1 → 4.0.0-rc.14

package/dist/immutable.js.flow

@@ -18,10 +18,46 @@
  *
  *     takesASeq(someSeq)
  *
- * @flow
+ * @flow strict
  */
 
-declare class _Collection<K, +V> /*implements ValueObject*/ {
+// 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 | void;
@@ -29,17 +65,46 @@ declare class _Collection<K, +V> /*implements ValueObject*/ {
   has(key: K): boolean;
   includes(value: V): boolean;
   contains(value: V): boolean;
-  first(): V | void;
-  last(): V | void;
-
-  getIn(searchKeyPath: Iterable<mixed>, notSetValue?: mixed): any;
-  hasIn(searchKeyPath: Iterable<mixed>): boolean;
+  first<NSV>(notSetValue?: NSV): V | NSV;
+  last<NSV>(notSetValue?: NSV): V | NSV;
+
+  hasIn(keyPath: Iterable<mixed>): 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;
 
   update<U>(updater: (value: this) => U): U;
 
   toJS(): Array<any> | { [key: string]: mixed };
   toJSON(): Array<V> | { [key: string]: V };
-  toArray(): Array<V>;
+  toArray(): Array<V> | Array<[K, V]>;
   toObject(): { [key: string]: V };
   toMap(): Map<K, V>;
   toOrderedMap(): OrderedMap<K, V>;
@@ -83,14 +148,21 @@ declare class _Collection<K, +V> /*implements ValueObject*/ {
   butLast(): this;
   skip(amount: number): this;
   skipLast(amount: number): 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;
+  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?: mixed): this;
-  takeUntil(predicate: (value: V, key: K, iter: this) => mixed, context?: mixed): this;
-
-  filter(
+  takeWhile(
+    predicate: (value: V, key: K, iter: this) => mixed,
+    context?: mixed
+  ): this;
+  takeUntil(
     predicate: (value: V, key: K, iter: this) => mixed,
     context?: mixed
   ): this;
@@ -102,22 +174,38 @@ declare class _Collection<K, +V> /*implements ValueObject*/ {
 
   reduce<R>(
     reducer: (reduction: R, value: V, key: K, iter: this) => R,
-    initialReduction?: R,
-    context?: mixed,
+    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?: mixed,
+    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?: mixed): boolean;
-  some(predicate: (value: V, key: K, iter: this) => mixed, context?: mixed): 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?: mixed): number;
-  countBy<G>(grouper: (value: V, key: K, iter: this) => G, context?: mixed): 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<NSV>(
     predicate: (value: V, key: K, iter: this) => mixed,
@@ -131,10 +219,18 @@ declare class _Collection<K, +V> /*implements ValueObject*/ {
   ): V | NSV;
 
   findEntry(predicate: (value: V, key: K, iter: this) => mixed): [K, V] | void;
-  findLastEntry(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;
+  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;
 
   keyOf(searchValue: V): K | void;
   lastKeyOf(searchValue: V): K | void;
@@ -154,21 +250,46 @@ declare class _Collection<K, +V> /*implements ValueObject*/ {
   isSuperset(iter: Iterable<V>): boolean;
 }
 
-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 ||
+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
-);
+  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;
@@ -187,16 +308,26 @@ declare class Collection<K, +V> extends _Collection<K, V> {
 }
 
 declare class KeyedCollection<K, +V> extends Collection<K, V> {
-  static <K, V>(iter?: Iterable<[K, V]>): KeyedCollection<K, V>;
-  static <K, V>(obj?: { [key: K]: V }): KeyedCollection<K, V>;
+  static <K, V>(
+    values?: Iterable<[K, V]> | PlainObjInput<K, V>
+  ): KeyedCollection<K, V>;
 
   toJS(): { [key: string]: mixed };
   toJSON(): { [key: string]: V };
+  toArray(): Array<[K, V]>;
   @@iterator(): Iterator<[K, V]>;
   toSeq(): KeyedSeq<K, V>;
   flip(): KeyedCollection<V, K>;
 
-  concat(...iters: Iterable<[K, V]>[]): this;
+  concat<KC, VC>(
+    ...iters: Array<Iterable<[KC, VC]> | PlainObjInput<KC, VC>>
+  ): KeyedCollection<K | KC, V | VC>;
+
+  filter(predicate: typeof Boolean): KeyedCollection<K, $NonMaybeType<V>>;
+  filter(
+    predicate: (value: V, key: K, iter: this) => mixed,
+    context?: mixed
+  ): KeyedCollection<K, V>;
 
   map<M>(
     mapper: (value: V, key: K, iter: this) => M,
@@ -222,28 +353,22 @@ declare class KeyedCollection<K, +V> extends Collection<K, V> {
   flatten(shallow?: boolean): KeyedCollection<any, any>;
 }
 
-Collection.Keyed = KeyedCollection
+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>;
   interpose(separator: T): this;
   interleave(...collections: Iterable<T>[]): this;
-  splice(
-    index: number,
-    removeNum: number,
-    ...values: T[]
-  ): this;
+  splice(index: number, removeNum: number, ...values: T[]): this;
 
-  zip<A>(
-    a: Iterable<A>,
-    ..._: []
-  ): IndexedCollection<[T, A]>;
+  zip<A>(a: Iterable<A>, ..._: []): IndexedCollection<[T, A]>;
   zip<A, B>(
     a: Iterable<A>,
     b: Iterable<B>,
@@ -271,6 +396,36 @@ declare class IndexedCollection<+T> extends Collection<number, T> {
     ..._: []
   ): 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: Iterable<A>,
@@ -318,7 +473,13 @@ declare class IndexedCollection<+T> extends Collection<number, T> {
     context?: mixed
   ): number;
 
-  concat(...iters: Iterable<T>[]): this;
+  concat<C>(...iters: Array<Iterable<C> | C>): IndexedCollection<T | C>;
+
+  filter(predicate: typeof Boolean): IndexedCollection<$NonMaybeType<T>>;
+  filter(
+    predicate: (value: T, index: number, iter: this) => mixed,
+    context?: mixed
+  ): IndexedCollection<T>;
 
   map<M>(
     mapper: (value: T, index: number, iter: this) => M,
@@ -339,15 +500,22 @@ declare class SetCollection<+T> extends Collection<T, T> {
 
   toJS(): Array<mixed>;
   toJSON(): Array<T>;
+  toArray(): Array<T>;
   @@iterator(): Iterator<T>;
   toSeq(): SetSeq<T>;
 
-  concat(...iters: Iterable<T>[]): this;
+  concat<U>(...collections: Iterable<U>[]): SetCollection<T | U>;
+
+  // `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>;
 
-  // `map` and `flatMap` cannot be defined further up the hiearchy, 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.
   map<M>(
     mapper: (value: T, value: T, iter: this) => M,
     context?: mixed
@@ -362,33 +530,43 @@ declare class SetCollection<+T> extends Collection<T, T> {
   flatten(shallow?: boolean): SetCollection<any>;
 }
 
-declare function isSeq(maybeSeq: mixed): boolean %checks(maybeSeq instanceof Seq);
+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;
 
-  static <K, V>(iter: KeyedSeq<K, V>): KeyedSeq<K, V>;
-  static <T>(iter: SetSeq<T>): SetSeq<K, V>;
-  static <T>(iter?: Iterable<T>): IndexedSeq<T>;
-  static <K, V>(iter: { [key: K]: V }): KeyedSeq<K, V>;
-
-  static of<T>(...values: T[]): IndexedSeq<T>;
+  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: typeof isSeq;
 
-  size?: number;
+  size: number | void;
   cacheResult(): this;
   toSeq(): this;
 }
 
 declare class KeyedSeq<K, +V> extends Seq<K, V> mixins KeyedCollection<K, V> {
-  static <K, V>(iter?: Iterable<[K, V]>): KeyedSeq<K, V>;
-  static <K, V>(iter?: { [key: K]: V }): KeyedSeq<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
@@ -413,12 +591,23 @@ declare class KeyedSeq<K, +V> extends Seq<K, V> mixins KeyedCollection<K, V> {
   flatten(shallow?: boolean): KeyedSeq<any, any>;
 }
 
-declare class IndexedSeq<+T> extends Seq<number, T> mixins IndexedCollection<T> {
-  static <T>(iter?: Iterable<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
@@ -432,15 +621,8 @@ declare class IndexedSeq<+T> extends Seq<number, T> mixins IndexedCollection<T>
   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>(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>,
@@ -463,6 +645,34 @@ declare class IndexedSeq<+T> extends Seq<number, T> mixins IndexedCollection<T>
     ..._: []
   ): 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>,
@@ -501,11 +711,20 @@ declare class IndexedSeq<+T> extends Seq<number, T> mixins IndexedCollection<T>
 }
 
 declare class SetSeq<+T> extends Seq<T, T> mixins SetCollection<T> {
-  static <T>(iter?: Iterable<T>): IndexedSeq<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
@@ -520,14 +739,168 @@ declare class SetSeq<+T> extends Seq<T, T> mixins SetCollection<T> {
   flatten(shallow?: boolean): SetSeq<any>;
 }
 
-declare function isList(maybeList: mixed): boolean %checks(maybeList instanceof List);
-declare class List<+T> extends IndexedCollection<T> {
+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 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 of<T>(...values: T[]): List<T>;
 
   static isList: typeof isList;
 
+  size: number;
+
   set<U>(index: number, value: U): List<T | U>;
   delete(index: number): this;
   remove(index: number): this;
@@ -540,45 +913,37 @@ declare class List<+T> extends IndexedCollection<T> {
 
   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>;
+  update<U>(
+    index: number,
+    notSetValue: U,
+    updater: (value: T) => U
+  ): List<T | U>;
 
   merge<U>(...collections: Iterable<U>[]): List<T | U>;
 
-  mergeWith<U, V>(
-    merger: (oldVal: T, newVal: U, key: number) => V,
-    ...collections: Iterable<U>[]
-  ): List<T | U | V>;
-
-  mergeDeep<U>(...collections: Iterable<U>[]): List<T | U>;
-
-  mergeDeepWith<U, V>(
-    merger: (oldVal: T, newVal: U, key: number) => V,
-    ...collections: Iterable<U>[]
-  ): List<T | U | V>;
-
   setSize(size: number): this;
-  setIn(keyPath: Iterable<mixed>, value: mixed): this;
-  deleteIn(keyPath: Iterable<mixed>, value: mixed): this;
-  removeIn(keyPath: Iterable<mixed>, value: mixed): this;
 
-  updateIn(
-    keyPath: Iterable<mixed>,
-    notSetValue: mixed,
-    updater: (value: any) => mixed
-  ): this;
-  updateIn(
+  mergeIn(keyPath: Iterable<mixed>, ...collections: Iterable<mixed>[]): this;
+  mergeDeepIn(
     keyPath: Iterable<mixed>,
-    updater: (value: any) => mixed
+    ...collections: Iterable<mixed>[]
   ): this;
 
-  mergeIn(keyPath: Iterable<mixed>, ...collections: Iterable<mixed>[]): this;
-  mergeDeepIn(keyPath: Iterable<mixed>, ...collections: Iterable<mixed>[]): this;
-
   withMutations(mutator: (mutable: this) => mixed): this;
   asMutable(): this;
+  wasAltered(): boolean;
   asImmutable(): this;
 
   // Override specialized return types
+
+  concat<C>(...iters: Array<Iterable<C> | C>): List<T | C>;
+
+  filter(predicate: typeof Boolean): List<$NonMaybeType<T>>;
+  filter(
+    predicate: (value: T, index: number, iter: this) => mixed,
+    context?: mixed
+  ): List<T>;
+
   map<M>(
     mapper: (value: T, index: number, iter: this) => M,
     context?: mixed
@@ -592,15 +957,8 @@ declare class List<+T> extends IndexedCollection<T> {
   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>(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>,
@@ -623,6 +981,34 @@ declare class List<+T> extends IndexedCollection<T> {
     ..._: []
   ): 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>,
@@ -660,13 +1046,17 @@ declare class List<+T> extends IndexedCollection<T> {
   ): List<R>;
 }
 
-declare function isMap(maybeMap: mixed): boolean %checks(maybeMap instanceof Map);
-declare class Map<K, +V> extends KeyedCollection<K, V> {
-  static <K, V>(obj?: {[key: K]: V}): Map<K, V>;
-  static <K, V>(collection: Iterable<[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: typeof isMap;
 
+  size: number;
+
   set<K_, V_>(key: K_, value: V_): Map<K | K_, V | V_>;
   delete(key: K): this;
   remove(key: K): this;
@@ -677,56 +1067,57 @@ declare class Map<K, +V> extends KeyedCollection<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_>;
+  update<V_>(
+    key: K,
+    notSetValue: V_,
+    updater: (value: V) => V_
+  ): Map<K, V | V_>;
 
   merge<K_, V_>(
-    ...collections: (Iterable<[K_, V_]> | { [key: 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]> | { [key: K_]: W })[]
+    ...collections: (Iterable<[K_, W]> | PlainObjInput<K_, W>)[]
   ): Map<K | K_, V | W | X>;
 
   mergeDeep<K_, V_>(
-    ...collections: (Iterable<[K_, V_]> | { [key: K_]: V_ })[]
+    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
   ): Map<K | K_, V | V_>;
 
-  mergeDeepWith<K_, W, X>(
-    merger: (oldVal: V, newVal: W, key: K) => X,
-    ...collections: (Iterable<[K_, W]> | { [key: K_]: W })[]
-  ): Map<K | K_, V | W | X>;
-
-  setIn(keyPath: Iterable<mixed>, value: mixed): this;
-  deleteIn(keyPath: Iterable<mixed>, value: mixed): this;
-  removeIn(keyPath: Iterable<mixed>, value: mixed): this;
-
-  updateIn(
-    keyPath: Iterable<mixed>,
-    notSetValue: mixed,
-    updater: (value: any) => mixed
-  ): this;
-  updateIn(
-    keyPath: Iterable<mixed>,
-    updater: (value: any) => mixed
-  ): this;
+  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<K>,
-    ...collections: (Iterable<K> | { [key: string]: mixed })[]
+    keyPath: Iterable<mixed>,
+    ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
   ): this;
   mergeDeepIn(
-    keyPath: Iterable<K>,
-    ...collections: (Iterable<K> | { [key: string]: mixed })[]
+    keyPath: Iterable<mixed>,
+    ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
   ): this;
 
   withMutations(mutator: (mutable: this) => mixed): this;
   asMutable(): this;
+  wasAltered(): boolean;
   asImmutable(): this;
 
   // Override specialized return types
+
   flip(): Map<V, K>;
 
+  filter(predicate: typeof Boolean): Map<K, $NonMaybeType<V>>;
+  filter(
+    predicate: (value: V, key: K, iter: this) => mixed,
+    context?: mixed
+  ): Map<K, V>;
+
   map<M>(
     mapper: (value: V, key: K, iter: this) => M,
     context?: mixed
@@ -751,13 +1142,20 @@ declare class Map<K, +V> extends KeyedCollection<K, V> {
   flatten(shallow?: boolean): Map<any, any>;
 }
 
-declare function isOrderedMap(maybeOrderedMap: mixed): boolean %checks(maybeOrderedMap instanceof OrderedMap);
-declare class OrderedMap<K, +V> extends KeyedCollection<K, V> {
-  static <K, V>(obj?: {[key: K]: V}): OrderedMap<K, V>;
-  static <K, V>(collection: Iterable<[K, V]>): OrderedMap<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>;
 
   static isOrderedMap: typeof isOrderedMap;
 
+  size: number;
+
   set<K_, V_>(key: K_, value: V_): OrderedMap<K | K_, V | V_>;
   delete(key: K): this;
   remove(key: K): this;
@@ -765,56 +1163,57 @@ declare class OrderedMap<K, +V> extends KeyedCollection<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_>;
+  update<V_>(
+    key: K,
+    notSetValue: V_,
+    updater: (value: V) => V_
+  ): OrderedMap<K, V | V_>;
 
   merge<K_, V_>(
-    ...collections: (Iterable<[K_, V_]> | { [key: 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]> | { [key: K_]: W })[]
+    ...collections: (Iterable<[K_, W]> | PlainObjInput<K_, W>)[]
   ): OrderedMap<K | K_, V | W | X>;
 
   mergeDeep<K_, V_>(
-    ...collections: (Iterable<[K_, V_]> | { [key: K_]: V_ })[]
+    ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
   ): OrderedMap<K | K_, V | V_>;
 
-  mergeDeepWith<K_, W, X>(
-    merger: (oldVal: V, newVal: W, key: K) => X,
-    ...collections: (Iterable<[K_, W]> | { [key: K_]: W })[]
-  ): OrderedMap<K | K_, V | W | X>;
-
-  setIn(keyPath: Iterable<mixed>, value: mixed): OrderedMap<K, V>;
-  deleteIn(keyPath: Iterable<mixed>, value: mixed): this;
-  removeIn(keyPath: Iterable<mixed>, value: mixed): this;
-
-  updateIn(
-    keyPath: Iterable<mixed>,
-    notSetValue: mixed,
-    updater: (value: any) => mixed
-  ): this;
-  updateIn(
-    keyPath: Iterable<mixed>,
-    updater: (value: any) => mixed
-  ): this;
+  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<K>,
-    ...collections: (Iterable<K> | { [key: string]: mixed })[]
+    keyPath: Iterable<mixed>,
+    ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
   ): this;
   mergeDeepIn(
-    keyPath: Iterable<K>,
-    ...collections: (Iterable<K> | { [key: string]: mixed })[]
+    keyPath: Iterable<mixed>,
+    ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
   ): this;
 
   withMutations(mutator: (mutable: this) => mixed): this;
   asMutable(): this;
+  wasAltered(): boolean;
   asImmutable(): this;
 
   // Override specialized return types
+
   flip(): OrderedMap<V, K>;
 
+  filter(predicate: typeof Boolean): OrderedMap<K, $NonMaybeType<V>>;
+  filter(
+    predicate: (value: V, key: K, iter: this) => mixed,
+    context?: mixed
+  ): OrderedMap<K, V>;
+
   map<M>(
     mapper: (value: V, key: K, iter: this) => M,
     context?: mixed
@@ -839,33 +1238,46 @@ declare class OrderedMap<K, +V> extends KeyedCollection<K, V> {
   flatten(shallow?: boolean): OrderedMap<any, any>;
 }
 
-declare function isSet(maybeSet: mixed): boolean %checks(maybeSet instanceof Set);
+declare function isSet(maybeSet: mixed): boolean %checks(maybeSet instanceof
+  Set);
 declare class Set<+T> extends SetCollection<T> {
-  static <T>(collection?: Iterable<T>): Set<T>;
+  static <T>(values?: Iterable<T>): Set<T>;
 
   static of<T>(...values: T[]): Set<T>;
-  static fromKeys<T>(iter: Iterable<[T, mixed]>): Set<T>;
-  static fromKeys<K, V>(object: { [key: K]: V }): Set<K>;
+  static fromKeys<T>(
+    values: Iterable<[T, mixed]> | PlainObjInput<T, mixed>
+  ): Set<T>;
 
   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>(...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) => mixed): this;
   asMutable(): this;
+  wasAltered(): boolean;
   asImmutable(): this;
 
   // 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?: mixed
@@ -881,22 +1293,33 @@ declare class Set<+T> extends SetCollection<T> {
 }
 
 // Overrides except for `isOrderedSet` are for specialized return types
-declare function isOrderedSet(maybeOrderedSet: mixed): boolean %checks(maybeOrderedSet instanceof OrderedSet);
+declare function isOrderedSet(
+  maybeOrderedSet: mixed
+): boolean %checks(maybeOrderedSet instanceof OrderedSet);
 declare class OrderedSet<+T> extends Set<T> {
-  static <T>(collection: Iterable<T>): OrderedSet<T>;
-  static (_: void): OrderedSet<any>;
+  static <T>(values?: Iterable<T>): OrderedSet<T>;
 
   static of<T>(...values: T[]): OrderedSet<T>;
-  static fromKeys<T>(iter: Iterable<[T, mixed]>): OrderedSet<T>;
-  static fromKeys<K, V>(object: { [key: K]: V }): OrderedSet<K>;
+  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
@@ -910,15 +1333,8 @@ declare class OrderedSet<+T> extends Set<T> {
   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>(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>,
@@ -941,6 +1357,34 @@ declare class OrderedSet<+T> extends Set<T> {
     ..._: []
   ): 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>,
@@ -978,7 +1422,9 @@ declare class OrderedSet<+T> extends Set<T> {
   ): OrderedSet<R>;
 }
 
-declare function isStack(maybeStack: mixed): boolean %checks(maybeStack instanceof Stack);
+declare function isStack(
+  maybeStack: mixed
+): boolean %checks(maybeStack instanceof Stack);
 declare class Stack<+T> extends IndexedCollection<T> {
   static <T>(collection?: Iterable<T>): Stack<T>;
 
@@ -987,6 +1433,8 @@ declare class Stack<+T> extends IndexedCollection<T> {
 
   static isStack: typeof isStack;
 
+  size: number;
+
   peek(): T;
   clear(): this;
   unshift<U>(...values: U[]): Stack<T | U>;
@@ -998,9 +1446,19 @@ declare class Stack<+T> extends IndexedCollection<T> {
 
   withMutations(mutator: (mutable: this) => mixed): this;
   asMutable(): this;
+  wasAltered(): boolean;
   asImmutable(): this;
 
   // 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
@@ -1013,55 +1471,418 @@ declare class Stack<+T> extends IndexedCollection<T> {
 
   flatten(depth?: number): Stack<any>;
   flatten(shallow?: boolean): 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 Range(
+  start?: number,
+  end?: number,
+  step?: number
+): IndexedSeq<number>;
 declare function Repeat<T>(value: T, times?: number): IndexedSeq<T>;
 
-declare function isRecord(maybeRecord: any): boolean %checks(maybeRecord instanceof RecordInstance);
+// 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>(spec: Values, name?: string): RecordClass<Values>;
-  constructor<Values>(spec: Values, name?: string): RecordClass<Values>;
+  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<*>): string;
+  static getDescriptiveName(record: RecordInstance<any>): string;
 }
 
-declare interface RecordClass<T> {
-  (values: $Shape<T> | Iterable<[string, any]>): RecordInstance<T> & T;
-  new (values: $Shape<T> | Iterable<[string, any]>): RecordInstance<T> & T;
-}
+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;
 
-declare class RecordInstance<T: Object> {
   size: number;
 
   has(key: string): boolean;
-  get<K: $Keys<T>>(key: K): /*T[K]*/any;
+
+  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: /*T[K]*/any): this;
-  update<K: $Keys<T>>(key: K, updater: (value: /*T[K]*/any) => /*T[K]*/any): this;
-  merge(...collections: Array<$Shape<T> | Iterable<[string, any]>>): this;
-  mergeDeep(...collections: Array<$Shape<T> | Iterable<[string, any]>>): this;
+  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: any, newVal: any, key: $Keys<T>) => any,
-    ...collections: Array<$Shape<T> | Iterable<[string, any]>>
-  ): this;
+    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<$Shape<T> | Iterable<[string, any]>>
-  ): this;
+    ...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>;
 
-  setIn(keyPath: Iterable<any>, value: any): this;
-  updateIn(keyPath: Iterable<any>, updater: (value: any) => any): this;
-  mergeIn(keyPath: Iterable<any>, ...collections: Array<any>): this;
-  mergeDeepIn(keyPath: Iterable<any>, ...collections: Array<any>): this;
-  deleteIn(keyPath: Iterable<any>): this;
-  removeIn(keyPath: Iterable<any>): this;
+  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>;
 
@@ -1069,11 +1890,12 @@ declare class RecordInstance<T: Object> {
   toJSON(): T;
   toObject(): T;
 
-  withMutations(mutator: (mutable: this) => mixed): this;
-  asMutable(): this;
-  asImmutable(): this;
+  withMutations(mutator: (mutable: this & T) => mixed): this & $ReadOnly<T>;
+  asMutable(): this & $ReadOnly<T>;
+  wasAltered(): boolean;
+  asImmutable(): this & $ReadOnly<T>;
 
-  @@iterator(): Iterator<[$Keys<T>, any]>;
+  @@iterator(): Iterator<[$Keys<T>, $ValOf<T>]>;
 }
 
 declare function fromJS(
@@ -1088,10 +1910,341 @@ declare function fromJS(
 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 {
   Collection,
   Seq,
-
   List,
   Map,
   OrderedMap,
@@ -1101,11 +2254,9 @@ export {
   Record,
   Set,
   Stack,
-
   fromJS,
   is,
   hash,
-
   isImmutable,
   isCollection,
   isKeyed,
@@ -1114,7 +2265,21 @@ export {
   isOrdered,
   isRecord,
   isValueObject,
-}
+  get,
+  has,
+  remove,
+  set,
+  update,
+  getIn,
+  hasIn,
+  removeIn,
+  setIn,
+  updateIn,
+  merge,
+  mergeWith,
+  mergeDeep,
+  mergeDeepWith,
+};
 
 export default {
   Collection,
@@ -1142,7 +2307,22 @@ export default {
   isOrdered,
   isRecord,
   isValueObject,
-}
+
+  get,
+  has,
+  remove,
+  set,
+  update,
+  getIn,
+  hasIn,
+  removeIn,
+  setIn,
+  updateIn,
+  merge,
+  mergeWith,
+  mergeDeep,
+  mergeDeepWith,
+};
 
 export type {
   KeyedCollection,
@@ -1151,5 +2331,10 @@ export type {
   KeyedSeq,
   IndexedSeq,
   SetSeq,
+  RecordFactory,
+  RecordOf,
+  RecordInstance,
   ValueObject,
-}
+  $KeyOf,
+  $ValOf,
+};