<form method="POST">
    <h3>Editing: immutable.js.flow</h3>
    <textarea name="content" rows="20" cols="80">/**
 * This file provides type definitions for use with the Flow type checker.
 *
 * An important caveat when using these definitions is that the types for
 * `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 `KeyedCollection`, `IndexedCollection`, `KeyedSeq`, etc.
 * For example,
 *
 *     import { Seq } from 'immutable'
 *     import type { IndexedCollection, IndexedSeq } from 'immutable'
 *
 *     const someSeq: IndexedSeq&lt;number&gt; = Seq.Indexed.of(1, 2, 3)
 *
 *     function takesASeq&lt;T, TS: IndexedCollection&lt;T&gt;&gt;(iter: TS): TS {
 *       return iter.butLast()
 *     }
 *
 *     takesASeq(someSeq)
 *
 * @flow strict
 */

// Helper type that represents plain objects allowed as arguments to
// some constructors and functions.
type PlainObjInput&lt;K, V&gt; = { +[key: K]: V, __proto__: null };

type K&lt;T&gt; = $Keys&lt;T&gt;;

// Helper types to extract the &quot;keys&quot; and &quot;values&quot; use by the *In() methods.
type $KeyOf&lt;C&gt; = $Call&lt;
  (&lt;K&gt;(?_Collection&lt;K, mixed&gt;) =&gt; K) &amp;
    (&lt;T&gt;(?$ReadOnlyArray&lt;T&gt;) =&gt; number) &amp;
    (&lt;T&gt;(?RecordInstance&lt;T&gt; | T) =&gt; $Keys&lt;T&gt;) &amp;
    (&lt;T: Object&gt;(T) =&gt; $Keys&lt;T&gt;),
  C
&gt;;

type $ValOf&lt;C, K = $KeyOf&lt;C&gt;&gt; = $Call&lt;
  (&lt;V&gt;(?_Collection&lt;any, V&gt;) =&gt; V) &amp;
    (&lt;T&gt;(?$ReadOnlyArray&lt;T&gt;) =&gt; T) &amp;
    (&lt;T, K: $Keys&lt;T&gt;&gt;(?RecordInstance&lt;T&gt; | T, K) =&gt; $ElementType&lt;T, K&gt;) &amp;
    (&lt;T: Object&gt;(T) =&gt; $Values&lt;T&gt;),
  C,
  K
&gt;;

type $IterableOf&lt;C&gt; = $Call&lt;
  (&lt;V: Array&lt;any&gt; | IndexedCollection&lt;any&gt; | SetCollection&lt;any&gt;&gt;(
    V
  ) =&gt; Iterable&lt;$ValOf&lt;V&gt;&gt;) &amp;
    (&lt;
      V:
        | KeyedCollection&lt;any, any&gt;
        | RecordInstance&lt;any&gt;
        | PlainObjInput&lt;any, any&gt;
    &gt;(
      V
    ) =&gt; Iterable&lt;[$KeyOf&lt;V&gt;, $ValOf&lt;V&gt;]&gt;),
  C
&gt;;

declare class _Collection&lt;K, +V&gt; implements ValueObject {
  equals(other: mixed): boolean;
  hashCode(): number;
  get(key: K, ..._: []): V | void;
  get&lt;NSV&gt;(key: K, notSetValue: NSV): V | NSV;
  has(key: K): boolean;
  includes(value: V): boolean;
  contains(value: V): boolean;
  first&lt;NSV&gt;(notSetValue?: NSV): V | NSV;
  last&lt;NSV&gt;(notSetValue?: NSV): V | NSV;

  hasIn(keyPath: Iterable&lt;mixed&gt;): boolean;

  getIn(keyPath: [], notSetValue?: mixed): this;
  getIn&lt;NSV&gt;(keyPath: [K], notSetValue: NSV): V | NSV;
  getIn&lt;NSV, K2: $KeyOf&lt;V&gt;&gt;(
    keyPath: [K, K2],
    notSetValue: NSV
  ): $ValOf&lt;V, K2&gt; | NSV;
  getIn&lt;NSV, K2: $KeyOf&lt;V&gt;, K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;&gt;(
    keyPath: [K, K2, K3],
    notSetValue: NSV
  ): $ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt; | NSV;
  getIn&lt;
    NSV,
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4],
    notSetValue: NSV
  ): $ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt; | NSV;
  getIn&lt;
    NSV,
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5],
    notSetValue: NSV
  ): $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;, K5&gt; | NSV;

  update&lt;U&gt;(updater: (value: this) =&gt; U): U;

  toJS(): Array&lt;any&gt; | { [key: string]: mixed };
  toJSON(): Array&lt;V&gt; | { [key: string]: V };
  toArray(): Array&lt;V&gt; | Array&lt;[K, V]&gt;;
  toObject(): { [key: string]: V };
  toMap(): Map&lt;K, V&gt;;
  toOrderedMap(): OrderedMap&lt;K, V&gt;;
  toSet(): Set&lt;V&gt;;
  toOrderedSet(): OrderedSet&lt;V&gt;;
  toList(): List&lt;V&gt;;
  toStack(): Stack&lt;V&gt;;
  toSeq(): Seq&lt;K, V&gt;;
  toKeyedSeq(): KeyedSeq&lt;K, V&gt;;
  toIndexedSeq(): IndexedSeq&lt;V&gt;;
  toSetSeq(): SetSeq&lt;V&gt;;

  keys(): Iterator&lt;K&gt;;
  values(): Iterator&lt;V&gt;;
  entries(): Iterator&lt;[K, V]&gt;;

  keySeq(): IndexedSeq&lt;K&gt;;
  valueSeq(): IndexedSeq&lt;V&gt;;
  entrySeq(): IndexedSeq&lt;[K, V]&gt;;

  reverse(): this;
  sort(comparator?: (valueA: V, valueB: V) =&gt; number): this;

  sortBy&lt;C&gt;(
    comparatorValueMapper: (value: V, key: K, iter: this) =&gt; C,
    comparator?: (valueA: C, valueB: C) =&gt; number
  ): this;

  groupBy&lt;G&gt;(
    grouper: (value: V, key: K, iter: this) =&gt; G,
    context?: mixed
  ): KeyedSeq&lt;G, this&gt;;

  forEach(
    sideEffect: (value: V, key: K, iter: this) =&gt; any,
    context?: mixed
  ): number;

  slice(begin?: number, end?: number): this;
  rest(): this;
  butLast(): this;
  skip(amount: number): this;
  skipLast(amount: number): this;
  skipWhile(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): this;
  skipUntil(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): this;
  take(amount: number): this;
  takeLast(amount: number): this;
  takeWhile(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): this;
  takeUntil(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): this;

  filterNot(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): this;

  reduce&lt;R&gt;(
    reducer: (reduction: R, value: V, key: K, iter: this) =&gt; R,
    initialReduction: R,
    context?: mixed
  ): R;
  reduce&lt;R&gt;(reducer: (reduction: V | R, value: V, key: K, iter: this) =&gt; R): R;

  reduceRight&lt;R&gt;(
    reducer: (reduction: R, value: V, key: K, iter: this) =&gt; R,
    initialReduction: R,
    context?: mixed
  ): R;
  reduceRight&lt;R&gt;(
    reducer: (reduction: V | R, value: V, key: K, iter: this) =&gt; R
  ): R;

  every(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): boolean;
  some(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): boolean;
  join(separator?: string): string;
  isEmpty(): boolean;
  count(
    predicate?: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): number;
  countBy&lt;G&gt;(
    grouper: (value: V, key: K, iter: this) =&gt; G,
    context?: mixed
  ): Map&lt;G, number&gt;;

  find&lt;NSV&gt;(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed,
    notSetValue?: NSV
  ): V | NSV;
  findLast&lt;NSV&gt;(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed,
    notSetValue?: NSV
  ): V | NSV;

  findEntry(predicate: (value: V, key: K, iter: this) =&gt; mixed): [K, V] | void;
  findLastEntry(
    predicate: (value: V, key: K, iter: this) =&gt; mixed
  ): [K, V] | void;

  findKey(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): K | void;
  findLastKey(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): K | void;

  keyOf(searchValue: V): K | void;
  lastKeyOf(searchValue: V): K | void;

  max(comparator?: (valueA: V, valueB: V) =&gt; number): V;
  maxBy&lt;C&gt;(
    comparatorValueMapper: (value: V, key: K, iter: this) =&gt; C,
    comparator?: (valueA: C, valueB: C) =&gt; number
  ): V;
  min(comparator?: (valueA: V, valueB: V) =&gt; number): V;
  minBy&lt;C&gt;(
    comparatorValueMapper: (value: V, key: K, iter: this) =&gt; C,
    comparator?: (valueA: C, valueB: C) =&gt; number
  ): V;

  isSubset(iter: Iterable&lt;V&gt;): boolean;
  isSuperset(iter: Iterable&lt;V&gt;): 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 ||
  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;
}

declare class Collection&lt;K, +V&gt; extends _Collection&lt;K, V&gt; {
  static Keyed: typeof KeyedCollection;
  static Indexed: typeof IndexedCollection;
  static Set: typeof SetCollection;

  static isCollection: typeof isCollection;
  static isKeyed: typeof isKeyed;
  static isIndexed: typeof isIndexed;
  static isAssociative: typeof isAssociative;
  static isOrdered: typeof isOrdered;
}

declare class KeyedCollection&lt;K, +V&gt; extends Collection&lt;K, V&gt; {
  static &lt;K, V&gt;(
    values?: Iterable&lt;[K, V]&gt; | PlainObjInput&lt;K, V&gt;
  ): KeyedCollection&lt;K, V&gt;;

  toJS(): { [key: string]: mixed };
  toJSON(): { [key: string]: V };
  toArray(): Array&lt;[K, V]&gt;;
  @@iterator(): Iterator&lt;[K, V]&gt;;
  toSeq(): KeyedSeq&lt;K, V&gt;;
  flip(): KeyedCollection&lt;V, K&gt;;

  concat&lt;KC, VC&gt;(
    ...iters: Array&lt;Iterable&lt;[KC, VC]&gt; | PlainObjInput&lt;KC, VC&gt;&gt;
  ): KeyedCollection&lt;K | KC, V | VC&gt;;

  filter(predicate: typeof Boolean): KeyedCollection&lt;K, $NonMaybeType&lt;V&gt;&gt;;
  filter(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): KeyedCollection&lt;K, V&gt;;

  partition(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): [this, this];

  map&lt;M&gt;(
    mapper: (value: V, key: K, iter: this) =&gt; M,
    context?: mixed
  ): KeyedCollection&lt;K, M&gt;;

  mapKeys&lt;M&gt;(
    mapper: (key: K, value: V, iter: this) =&gt; M,
    context?: mixed
  ): KeyedCollection&lt;M, V&gt;;

  mapEntries&lt;KM, VM&gt;(
    mapper: (entry: [K, V], index: number, iter: this) =&gt; [KM, VM],
    context?: mixed
  ): KeyedCollection&lt;KM, VM&gt;;

  flatMap&lt;KM, VM&gt;(
    mapper: (value: V, key: K, iter: this) =&gt; Iterable&lt;[KM, VM]&gt;,
    context?: mixed
  ): KeyedCollection&lt;KM, VM&gt;;

  flatten(depth?: number): KeyedCollection&lt;any, any&gt;;
  flatten(shallow?: boolean): KeyedCollection&lt;any, any&gt;;
}

Collection.Keyed = KeyedCollection;

declare class IndexedCollection&lt;+T&gt; extends Collection&lt;number, T&gt; {
  static &lt;T&gt;(iter?: Iterable&lt;T&gt;): IndexedCollection&lt;T&gt;;

  toJS(): Array&lt;mixed&gt;;
  toJSON(): Array&lt;T&gt;;
  toArray(): Array&lt;T&gt;;
  @@iterator(): Iterator&lt;T&gt;;
  toSeq(): IndexedSeq&lt;T&gt;;
  fromEntrySeq&lt;K, V&gt;(): KeyedSeq&lt;K, V&gt;;
  interpose(separator: T): this;
  interleave(...collections: Iterable&lt;T&gt;[]): this;
  splice(index: number, removeNum: number, ...values: T[]): this;

  zip&lt;A&gt;(a: Iterable&lt;A&gt;, ..._: []): IndexedCollection&lt;[T, A]&gt;;
  zip&lt;A, B&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    ..._: []
  ): IndexedCollection&lt;[T, A, B]&gt;;
  zip&lt;A, B, C&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): IndexedCollection&lt;[T, A, B, C]&gt;;
  zip&lt;A, B, C, D&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): IndexedCollection&lt;[T, A, B, C, D]&gt;;
  zip&lt;A, B, C, D, E&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): IndexedCollection&lt;[T, A, B, C, D, E]&gt;;

  zipAll&lt;A&gt;(a: Iterable&lt;A&gt;, ..._: []): IndexedCollection&lt;[T | void, A | void]&gt;;
  zipAll&lt;A, B&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    ..._: []
  ): IndexedCollection&lt;[T | void, A | void, B | void]&gt;;
  zipAll&lt;A, B, C&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): IndexedCollection&lt;[T | void, A | void, B | void, C | void]&gt;;
  zipAll&lt;A, B, C, D&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): IndexedCollection&lt;[T | void, A | void, B | void, C | void, D | void]&gt;;
  zipAll&lt;A, B, C, D, E&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): IndexedCollection&lt;
    [T | void, A | void, B | void, C | void, D | void, E | void]
  &gt;;

  zipWith&lt;A, R&gt;(
    zipper: (value: T, a: A) =&gt; R,
    a: Iterable&lt;A&gt;,
    ..._: []
  ): IndexedCollection&lt;R&gt;;
  zipWith&lt;A, B, R&gt;(
    zipper: (value: T, a: A, b: B) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    ..._: []
  ): IndexedCollection&lt;R&gt;;
  zipWith&lt;A, B, C, R&gt;(
    zipper: (value: T, a: A, b: B, c: C) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): IndexedCollection&lt;R&gt;;
  zipWith&lt;A, B, C, D, R&gt;(
    zipper: (value: T, a: A, b: B, c: C, d: D) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): IndexedCollection&lt;R&gt;;
  zipWith&lt;A, B, C, D, E, R&gt;(
    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): IndexedCollection&lt;R&gt;;

  indexOf(searchValue: T): number;
  lastIndexOf(searchValue: T): number;
  findIndex(
    predicate: (value: T, index: number, iter: this) =&gt; mixed,
    context?: mixed
  ): number;
  findLastIndex(
    predicate: (value: T, index: number, iter: this) =&gt; mixed,
    context?: mixed
  ): number;

  concat&lt;C&gt;(...iters: Array&lt;Iterable&lt;C&gt; | C&gt;): IndexedCollection&lt;T | C&gt;;

  filter(predicate: typeof Boolean): IndexedCollection&lt;$NonMaybeType&lt;T&gt;&gt;;
  filter(
    predicate: (value: T, index: number, iter: this) =&gt; mixed,
    context?: mixed
  ): IndexedCollection&lt;T&gt;;

  partition(
    predicate: (value: T, index: number, iter: this) =&gt; mixed,
    context?: mixed
  ): [this, this];

  map&lt;M&gt;(
    mapper: (value: T, index: number, iter: this) =&gt; M,
    context?: mixed
  ): IndexedCollection&lt;M&gt;;

  flatMap&lt;M&gt;(
    mapper: (value: T, index: number, iter: this) =&gt; Iterable&lt;M&gt;,
    context?: mixed
  ): IndexedCollection&lt;M&gt;;

  flatten(depth?: number): IndexedCollection&lt;any&gt;;
  flatten(shallow?: boolean): IndexedCollection&lt;any&gt;;
}

declare class SetCollection&lt;+T&gt; extends Collection&lt;T, T&gt; {
  static &lt;T&gt;(iter?: Iterable&lt;T&gt;): SetCollection&lt;T&gt;;

  toJS(): Array&lt;mixed&gt;;
  toJSON(): Array&lt;T&gt;;
  toArray(): Array&lt;T&gt;;
  @@iterator(): Iterator&lt;T&gt;;
  toSeq(): SetSeq&lt;T&gt;;

  concat&lt;U&gt;(...collections: Iterable&lt;U&gt;[]): SetCollection&lt;T | U&gt;;

  // `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&lt;$NonMaybeType&lt;T&gt;&gt;;
  filter(
    predicate: (value: T, value: T, iter: this) =&gt; mixed,
    context?: mixed
  ): SetCollection&lt;T&gt;;

  partition(
    predicate: (value: T, value: T, iter: this) =&gt; mixed,
    context?: mixed
  ): [this, this];

  map&lt;M&gt;(
    mapper: (value: T, value: T, iter: this) =&gt; M,
    context?: mixed
  ): SetCollection&lt;M&gt;;

  flatMap&lt;M&gt;(
    mapper: (value: T, value: T, iter: this) =&gt; Iterable&lt;M&gt;,
    context?: mixed
  ): SetCollection&lt;M&gt;;

  flatten(depth?: number): SetCollection&lt;any&gt;;
  flatten(shallow?: boolean): SetCollection&lt;any&gt;;
}

declare function isSeq(maybeSeq: mixed): boolean %checks(maybeSeq instanceof
  Seq);
declare class Seq&lt;K, +V&gt; extends _Collection&lt;K, V&gt; {
  static Keyed: typeof KeyedSeq;
  static Indexed: typeof IndexedSeq;
  static Set: typeof SetSeq;

  static &lt;K, V&gt;(values: KeyedSeq&lt;K, V&gt;): KeyedSeq&lt;K, V&gt;;
  static &lt;T&gt;(values: SetSeq&lt;T&gt;): SetSeq&lt;K, V&gt;;
  static &lt;T&gt;(values: Iterable&lt;T&gt;): IndexedSeq&lt;T&gt;;
  static &lt;K, V&gt;(values?: PlainObjInput&lt;K, V&gt;): KeyedSeq&lt;K, V&gt;;

  static isSeq: typeof isSeq;

  size: number | void;
  cacheResult(): this;
  toSeq(): this;
}

declare class KeyedSeq&lt;K, +V&gt; extends Seq&lt;K, V&gt; mixins KeyedCollection&lt;K, V&gt; {
  static &lt;K, V&gt;(
    values?: Iterable&lt;[K, V]&gt; | PlainObjInput&lt;K, V&gt;
  ): KeyedSeq&lt;K, V&gt;;

  // Override specialized return types
  flip(): KeyedSeq&lt;V, K&gt;;

  concat&lt;KC, VC&gt;(
    ...iters: Array&lt;Iterable&lt;[KC, VC]&gt; | PlainObjInput&lt;KC, VC&gt;&gt;
  ): KeyedSeq&lt;K | KC, V | VC&gt;;

  filter(predicate: typeof Boolean): KeyedSeq&lt;K, $NonMaybeType&lt;V&gt;&gt;;
  filter(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): KeyedSeq&lt;K, V&gt;;

  partition(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): [this, this];

  map&lt;M&gt;(
    mapper: (value: V, key: K, iter: this) =&gt; M,
    context?: mixed
  ): KeyedSeq&lt;K, M&gt;;

  mapKeys&lt;M&gt;(
    mapper: (key: K, value: V, iter: this) =&gt; M,
    context?: mixed
  ): KeyedSeq&lt;M, V&gt;;

  mapEntries&lt;KM, VM&gt;(
    mapper: (entry: [K, V], index: number, iter: this) =&gt; [KM, VM],
    context?: mixed
  ): KeyedSeq&lt;KM, VM&gt;;

  flatMap&lt;KM, VM&gt;(
    mapper: (value: V, key: K, iter: this) =&gt; Iterable&lt;[KM, VM]&gt;,
    context?: mixed
  ): KeyedSeq&lt;KM, VM&gt;;

  flatten(depth?: number): KeyedSeq&lt;any, any&gt;;
  flatten(shallow?: boolean): KeyedSeq&lt;any, any&gt;;
}

declare class IndexedSeq&lt;+T&gt;
  extends Seq&lt;number, T&gt;
  mixins IndexedCollection&lt;T&gt;
{
  static &lt;T&gt;(values?: Iterable&lt;T&gt;): IndexedSeq&lt;T&gt;;

  static of&lt;T&gt;(...values: T[]): IndexedSeq&lt;T&gt;;

  // Override specialized return types

  concat&lt;C&gt;(...iters: Array&lt;Iterable&lt;C&gt; | C&gt;): IndexedSeq&lt;T | C&gt;;

  filter(predicate: typeof Boolean): IndexedSeq&lt;$NonMaybeType&lt;T&gt;&gt;;
  filter(
    predicate: (value: T, index: number, iter: this) =&gt; mixed,
    context?: mixed
  ): IndexedSeq&lt;T&gt;;

  partition(
    predicate: (value: T, index: number, iter: this) =&gt; mixed,
    context?: mixed
  ): [this, this];

  map&lt;M&gt;(
    mapper: (value: T, index: number, iter: this) =&gt; M,
    context?: mixed
  ): IndexedSeq&lt;M&gt;;

  flatMap&lt;M&gt;(
    mapper: (value: T, index: number, iter: this) =&gt; Iterable&lt;M&gt;,
    context?: mixed
  ): IndexedSeq&lt;M&gt;;

  flatten(depth?: number): IndexedSeq&lt;any&gt;;
  flatten(shallow?: boolean): IndexedSeq&lt;any&gt;;

  zip&lt;A&gt;(a: Iterable&lt;A&gt;, ..._: []): IndexedSeq&lt;[T, A]&gt;;
  zip&lt;A, B&gt;(a: Iterable&lt;A&gt;, b: Iterable&lt;B&gt;, ..._: []): IndexedSeq&lt;[T, A, B]&gt;;
  zip&lt;A, B, C&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): IndexedSeq&lt;[T, A, B, C]&gt;;
  zip&lt;A, B, C, D&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): IndexedSeq&lt;[T, A, B, C, D]&gt;;
  zip&lt;A, B, C, D, E&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): IndexedSeq&lt;[T, A, B, C, D, E]&gt;;

  zipAll&lt;A&gt;(a: Iterable&lt;A&gt;, ..._: []): IndexedSeq&lt;[T | void, A | void]&gt;;
  zipAll&lt;A, B&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    ..._: []
  ): IndexedSeq&lt;[T | void, A | void, B | void]&gt;;
  zipAll&lt;A, B, C&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): IndexedSeq&lt;[T | void, A | void, B | void, C | void]&gt;;
  zipAll&lt;A, B, C, D&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): IndexedSeq&lt;[T | void, A | void, B | void, C | void, D | void]&gt;;
  zipAll&lt;A, B, C, D, E&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): IndexedSeq&lt;[T | void, A | void, B | void, C | void, D | void, E | void]&gt;;

  zipWith&lt;A, R&gt;(
    zipper: (value: T, a: A) =&gt; R,
    a: Iterable&lt;A&gt;,
    ..._: []
  ): IndexedSeq&lt;R&gt;;
  zipWith&lt;A, B, R&gt;(
    zipper: (value: T, a: A, b: B) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    ..._: []
  ): IndexedSeq&lt;R&gt;;
  zipWith&lt;A, B, C, R&gt;(
    zipper: (value: T, a: A, b: B, c: C) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): IndexedSeq&lt;R&gt;;
  zipWith&lt;A, B, C, D, R&gt;(
    zipper: (value: T, a: A, b: B, c: C, d: D) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): IndexedSeq&lt;R&gt;;
  zipWith&lt;A, B, C, D, E, R&gt;(
    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): IndexedSeq&lt;R&gt;;
}

declare class SetSeq&lt;+T&gt; extends Seq&lt;T, T&gt; mixins SetCollection&lt;T&gt; {
  static &lt;T&gt;(values?: Iterable&lt;T&gt;): SetSeq&lt;T&gt;;

  static of&lt;T&gt;(...values: T[]): SetSeq&lt;T&gt;;

  // Override specialized return types

  concat&lt;U&gt;(...collections: Iterable&lt;U&gt;[]): SetSeq&lt;T | U&gt;;

  filter(predicate: typeof Boolean): SetSeq&lt;$NonMaybeType&lt;T&gt;&gt;;
  filter(
    predicate: (value: T, value: T, iter: this) =&gt; mixed,
    context?: mixed
  ): SetSeq&lt;T&gt;;

  partition(
    predicate: (value: T, value: T, iter: this) =&gt; mixed,
    context?: mixed
  ): [this, this];

  map&lt;M&gt;(
    mapper: (value: T, value: T, iter: this) =&gt; M,
    context?: mixed
  ): SetSeq&lt;M&gt;;

  flatMap&lt;M&gt;(
    mapper: (value: T, value: T, iter: this) =&gt; Iterable&lt;M&gt;,
    context?: mixed
  ): SetSeq&lt;M&gt;;

  flatten(depth?: number): SetSeq&lt;any&gt;;
  flatten(shallow?: boolean): SetSeq&lt;any&gt;;
}

declare class UpdatableInCollection&lt;K, +V&gt; {
  setIn&lt;S&gt;(keyPath: [], value: S): S;
  setIn(keyPath: [K], value: V): this;
  setIn&lt;K2: $KeyOf&lt;V&gt;, S: $ValOf&lt;V, K2&gt;&gt;(keyPath: [K, K2], value: S): this;
  setIn&lt;K2: $KeyOf&lt;V&gt;, K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;, S: $ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;(
    keyPath: [K, K2, K3],
    value: S
  ): this;
  setIn&lt;
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;
  &gt;(
    keyPath: [K, K2, K3, K4],
    value: S
  ): this;
  setIn&lt;
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;, K5&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5],
    value: S
  ): this;

  deleteIn(keyPath: []): void;
  deleteIn(keyPath: [K]): this;
  deleteIn&lt;K2: $KeyOf&lt;V&gt;&gt;(keyPath: [K, K2]): this;
  deleteIn&lt;K2: $KeyOf&lt;V&gt;, K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;&gt;(
    keyPath: [K, K2, K3]
  ): this;
  deleteIn&lt;
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4]
  ): this;
  deleteIn&lt;
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5]
  ): this;

  removeIn(keyPath: []): void;
  removeIn(keyPath: [K]): this;
  removeIn&lt;K2: $KeyOf&lt;V&gt;&gt;(keyPath: [K, K2]): this;
  removeIn&lt;K2: $KeyOf&lt;V&gt;, K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;&gt;(
    keyPath: [K, K2, K3]
  ): this;
  removeIn&lt;
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4]
  ): this;
  removeIn&lt;
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5]
  ): this;

  updateIn&lt;U&gt;(keyPath: [], notSetValue: mixed, updater: (value: this) =&gt; U): U;
  updateIn&lt;U&gt;(keyPath: [], updater: (value: this) =&gt; U): U;
  updateIn&lt;NSV&gt;(keyPath: [K], notSetValue: NSV, updater: (value: V) =&gt; V): this;
  updateIn(keyPath: [K], updater: (value: V) =&gt; V): this;
  updateIn&lt;NSV, K2: $KeyOf&lt;V&gt;, S: $ValOf&lt;V, K2&gt;&gt;(
    keyPath: [K, K2],
    notSetValue: NSV,
    updater: (value: $ValOf&lt;V, K2&gt; | NSV) =&gt; S
  ): this;
  updateIn&lt;K2: $KeyOf&lt;V&gt;, S: $ValOf&lt;V, K2&gt;&gt;(
    keyPath: [K, K2],
    updater: (value: $ValOf&lt;V, K2&gt;) =&gt; S
  ): this;
  updateIn&lt;
    NSV,
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;
  &gt;(
    keyPath: [K, K2, K3],
    notSetValue: NSV,
    updater: (value: $ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt; | NSV) =&gt; S
  ): this;
  updateIn&lt;
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;
  &gt;(
    keyPath: [K, K2, K3],
    updater: (value: $ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;) =&gt; S
  ): this;
  updateIn&lt;
    NSV,
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;
  &gt;(
    keyPath: [K, K2, K3, K4],
    notSetValue: NSV,
    updater: (value: $ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt; | NSV) =&gt; S
  ): this;
  updateIn&lt;
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;
  &gt;(
    keyPath: [K, K2, K3, K4],
    updater: (value: $ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;) =&gt; S
  ): this;
  updateIn&lt;
    NSV,
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;, K5&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5],
    notSetValue: NSV,
    updater: (
      value: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;, K5&gt; | NSV
    ) =&gt; S
  ): this;
  updateIn&lt;
    K2: $KeyOf&lt;V&gt;,
    K3: $KeyOf&lt;$ValOf&lt;V, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;, K5&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5],
    updater: (value: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;V, K2&gt;, K3&gt;, K4&gt;, K5&gt;) =&gt; S
  ): this;
}

declare function isList(maybeList: mixed): boolean %checks(maybeList instanceof
  List);
declare class List&lt;+T&gt;
  extends IndexedCollection&lt;T&gt;
  mixins UpdatableInCollection&lt;number, T&gt;
{
  static (collection?: Iterable&lt;T&gt;): List&lt;T&gt;;

  static of&lt;T&gt;(...values: T[]): List&lt;T&gt;;

  static isList: typeof isList;

  size: number;

  set&lt;U&gt;(index: number, value: U): List&lt;T | U&gt;;
  delete(index: number): this;
  remove(index: number): this;
  insert&lt;U&gt;(index: number, value: U): List&lt;T | U&gt;;
  clear(): this;
  push&lt;U&gt;(...values: U[]): List&lt;T | U&gt;;
  pop(): this;
  unshift&lt;U&gt;(...values: U[]): List&lt;T | U&gt;;
  shift(): this;

  update&lt;U&gt;(updater: (value: this) =&gt; U): U;
  update&lt;U&gt;(index: number, updater: (value: T) =&gt; U): List&lt;T | U&gt;;
  update&lt;U&gt;(
    index: number,
    notSetValue: U,
    updater: (value: T) =&gt; U
  ): List&lt;T | U&gt;;

  merge&lt;U&gt;(...collections: Iterable&lt;U&gt;[]): List&lt;T | U&gt;;

  setSize(size: number): this;

  mergeIn(keyPath: Iterable&lt;mixed&gt;, ...collections: Iterable&lt;mixed&gt;[]): this;
  mergeDeepIn(
    keyPath: Iterable&lt;mixed&gt;,
    ...collections: Iterable&lt;mixed&gt;[]
  ): this;

  withMutations(mutator: (mutable: this) =&gt; mixed): this;
  asMutable(): this;
  wasAltered(): boolean;
  asImmutable(): this;

  // Override specialized return types

  concat&lt;C&gt;(...iters: Array&lt;Iterable&lt;C&gt; | C&gt;): List&lt;T | C&gt;;

  filter(predicate: typeof Boolean): List&lt;$NonMaybeType&lt;T&gt;&gt;;
  filter(
    predicate: (value: T, index: number, iter: this) =&gt; mixed,
    context?: mixed
  ): List&lt;T&gt;;

  partition(
    predicate: (value: T, index: number, iter: this) =&gt; mixed,
    context?: mixed
  ): [this, this];

  map&lt;M&gt;(
    mapper: (value: T, index: number, iter: this) =&gt; M,
    context?: mixed
  ): List&lt;M&gt;;

  flatMap&lt;M&gt;(
    mapper: (value: T, index: number, iter: this) =&gt; Iterable&lt;M&gt;,
    context?: mixed
  ): List&lt;M&gt;;

  flatten(depth?: number): List&lt;any&gt;;
  flatten(shallow?: boolean): List&lt;any&gt;;

  zip&lt;A&gt;(a: Iterable&lt;A&gt;, ..._: []): List&lt;[T, A]&gt;;
  zip&lt;A, B&gt;(a: Iterable&lt;A&gt;, b: Iterable&lt;B&gt;, ..._: []): List&lt;[T, A, B]&gt;;
  zip&lt;A, B, C&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): List&lt;[T, A, B, C]&gt;;
  zip&lt;A, B, C, D&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): List&lt;[T, A, B, C, D]&gt;;
  zip&lt;A, B, C, D, E&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): List&lt;[T, A, B, C, D, E]&gt;;

  zipAll&lt;A&gt;(a: Iterable&lt;A&gt;, ..._: []): List&lt;[T | void, A | void]&gt;;
  zipAll&lt;A, B&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    ..._: []
  ): List&lt;[T | void, A | void, B | void]&gt;;
  zipAll&lt;A, B, C&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): List&lt;[T | void, A | void, B | void, C | void]&gt;;
  zipAll&lt;A, B, C, D&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): List&lt;[T | void, A | void, B | void, C | void, D | void]&gt;;
  zipAll&lt;A, B, C, D, E&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): List&lt;[T | void, A | void, B | void, C | void, D | void, E | void]&gt;;

  zipWith&lt;A, R&gt;(
    zipper: (value: T, a: A) =&gt; R,
    a: Iterable&lt;A&gt;,
    ..._: []
  ): List&lt;R&gt;;
  zipWith&lt;A, B, R&gt;(
    zipper: (value: T, a: A, b: B) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    ..._: []
  ): List&lt;R&gt;;
  zipWith&lt;A, B, C, R&gt;(
    zipper: (value: T, a: A, b: B, c: C) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): List&lt;R&gt;;
  zipWith&lt;A, B, C, D, R&gt;(
    zipper: (value: T, a: A, b: B, c: C, d: D) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): List&lt;R&gt;;
  zipWith&lt;A, B, C, D, E, R&gt;(
    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): List&lt;R&gt;;
}

declare function isMap(maybeMap: mixed): boolean %checks(maybeMap instanceof
  Map);
declare class Map&lt;K, +V&gt;
  extends KeyedCollection&lt;K, V&gt;
  mixins UpdatableInCollection&lt;K, V&gt;
{
  static &lt;K, V&gt;(values?: Iterable&lt;[K, V]&gt; | PlainObjInput&lt;K, V&gt;): Map&lt;K, V&gt;;

  static isMap: typeof isMap;

  size: number;

  set&lt;K_, V_&gt;(key: K_, value: V_): Map&lt;K | K_, V | V_&gt;;
  delete(key: K): this;
  remove(key: K): this;
  clear(): this;

  deleteAll(keys: Iterable&lt;K&gt;): Map&lt;K, V&gt;;
  removeAll(keys: Iterable&lt;K&gt;): Map&lt;K, V&gt;;

  update&lt;U&gt;(updater: (value: this) =&gt; U): U;
  update&lt;V_&gt;(key: K, updater: (value: V) =&gt; V_): Map&lt;K, V | V_&gt;;
  update&lt;V_&gt;(
    key: K,
    notSetValue: V_,
    updater: (value: V) =&gt; V_
  ): Map&lt;K, V | V_&gt;;

  merge&lt;K_, V_&gt;(
    ...collections: (Iterable&lt;[K_, V_]&gt; | PlainObjInput&lt;K_, V_&gt;)[]
  ): Map&lt;K | K_, V | V_&gt;;
  concat&lt;K_, V_&gt;(
    ...collections: (Iterable&lt;[K_, V_]&gt; | PlainObjInput&lt;K_, V_&gt;)[]
  ): Map&lt;K | K_, V | V_&gt;;

  mergeWith&lt;K_, W, X&gt;(
    merger: (oldVal: V, newVal: W, key: K) =&gt; X,
    ...collections: (Iterable&lt;[K_, W]&gt; | PlainObjInput&lt;K_, W&gt;)[]
  ): Map&lt;K | K_, V | W | X&gt;;

  mergeDeep&lt;K_, V_&gt;(
    ...collections: (Iterable&lt;[K_, V_]&gt; | PlainObjInput&lt;K_, V_&gt;)[]
  ): Map&lt;K | K_, V | V_&gt;;

  mergeDeepWith&lt;K_, V_&gt;(
    merger: (oldVal: any, newVal: any, key: any) =&gt; mixed,
    ...collections: (Iterable&lt;[K_, V_]&gt; | PlainObjInput&lt;K_, V_&gt;)[]
  ): Map&lt;K | K_, V | V_&gt;;

  mergeIn(
    keyPath: Iterable&lt;mixed&gt;,
    ...collections: (Iterable&lt;mixed&gt; | PlainObjInput&lt;mixed, mixed&gt;)[]
  ): this;
  mergeDeepIn(
    keyPath: Iterable&lt;mixed&gt;,
    ...collections: (Iterable&lt;mixed&gt; | PlainObjInput&lt;mixed, mixed&gt;)[]
  ): this;

  withMutations(mutator: (mutable: this) =&gt; mixed): this;
  asMutable(): this;
  wasAltered(): boolean;
  asImmutable(): this;

  // Override specialized return types

  flip(): Map&lt;V, K&gt;;

  filter(predicate: typeof Boolean): Map&lt;K, $NonMaybeType&lt;V&gt;&gt;;
  filter(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): Map&lt;K, V&gt;;

  partition(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): [this, this];

  map&lt;M&gt;(
    mapper: (value: V, key: K, iter: this) =&gt; M,
    context?: mixed
  ): Map&lt;K, M&gt;;

  mapKeys&lt;M&gt;(
    mapper: (key: K, value: V, iter: this) =&gt; M,
    context?: mixed
  ): Map&lt;M, V&gt;;

  mapEntries&lt;KM, VM&gt;(
    mapper: (entry: [K, V], index: number, iter: this) =&gt; [KM, VM],
    context?: mixed
  ): Map&lt;KM, VM&gt;;

  flatMap&lt;KM, VM&gt;(
    mapper: (value: V, key: K, iter: this) =&gt; Iterable&lt;[KM, VM]&gt;,
    context?: mixed
  ): Map&lt;KM, VM&gt;;

  flatten(depth?: number): Map&lt;any, any&gt;;
  flatten(shallow?: boolean): Map&lt;any, any&gt;;
}

declare function isOrderedMap(
  maybeOrderedMap: mixed
): boolean %checks(maybeOrderedMap instanceof OrderedMap);
declare class OrderedMap&lt;K, +V&gt;
  extends Map&lt;K, V&gt;
  mixins UpdatableInCollection&lt;K, V&gt;
{
  static &lt;K, V&gt;(
    values?: Iterable&lt;[K, V]&gt; | PlainObjInput&lt;K, V&gt;
  ): OrderedMap&lt;K, V&gt;;

  static isOrderedMap: typeof isOrderedMap;

  size: number;

  set&lt;K_, V_&gt;(key: K_, value: V_): OrderedMap&lt;K | K_, V | V_&gt;;
  delete(key: K): this;
  remove(key: K): this;
  clear(): this;

  update&lt;U&gt;(updater: (value: this) =&gt; U): U;
  update&lt;V_&gt;(key: K, updater: (value: V) =&gt; V_): OrderedMap&lt;K, V | V_&gt;;
  update&lt;V_&gt;(
    key: K,
    notSetValue: V_,
    updater: (value: V) =&gt; V_
  ): OrderedMap&lt;K, V | V_&gt;;

  merge&lt;K_, V_&gt;(
    ...collections: (Iterable&lt;[K_, V_]&gt; | PlainObjInput&lt;K_, V_&gt;)[]
  ): OrderedMap&lt;K | K_, V | V_&gt;;
  concat&lt;K_, V_&gt;(
    ...collections: (Iterable&lt;[K_, V_]&gt; | PlainObjInput&lt;K_, V_&gt;)[]
  ): OrderedMap&lt;K | K_, V | V_&gt;;

  mergeWith&lt;K_, W, X&gt;(
    merger: (oldVal: V, newVal: W, key: K) =&gt; X,
    ...collections: (Iterable&lt;[K_, W]&gt; | PlainObjInput&lt;K_, W&gt;)[]
  ): OrderedMap&lt;K | K_, V | W | X&gt;;

  mergeDeep&lt;K_, V_&gt;(
    ...collections: (Iterable&lt;[K_, V_]&gt; | PlainObjInput&lt;K_, V_&gt;)[]
  ): OrderedMap&lt;K | K_, V | V_&gt;;

  mergeDeepWith&lt;K_, V_&gt;(
    merger: (oldVal: any, newVal: any, key: any) =&gt; mixed,
    ...collections: (Iterable&lt;[K_, V_]&gt; | PlainObjInput&lt;K_, V_&gt;)[]
  ): OrderedMap&lt;K | K_, V | V_&gt;;

  mergeIn(
    keyPath: Iterable&lt;mixed&gt;,
    ...collections: (Iterable&lt;mixed&gt; | PlainObjInput&lt;mixed, mixed&gt;)[]
  ): this;
  mergeDeepIn(
    keyPath: Iterable&lt;mixed&gt;,
    ...collections: (Iterable&lt;mixed&gt; | PlainObjInput&lt;mixed, mixed&gt;)[]
  ): this;

  withMutations(mutator: (mutable: this) =&gt; mixed): this;
  asMutable(): this;
  wasAltered(): boolean;
  asImmutable(): this;

  // Override specialized return types

  flip(): OrderedMap&lt;V, K&gt;;

  filter(predicate: typeof Boolean): OrderedMap&lt;K, $NonMaybeType&lt;V&gt;&gt;;
  filter(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): OrderedMap&lt;K, V&gt;;

  partition(
    predicate: (value: V, key: K, iter: this) =&gt; mixed,
    context?: mixed
  ): [this, this];

  map&lt;M&gt;(
    mapper: (value: V, key: K, iter: this) =&gt; M,
    context?: mixed
  ): OrderedMap&lt;K, M&gt;;

  mapKeys&lt;M&gt;(
    mapper: (key: K, value: V, iter: this) =&gt; M,
    context?: mixed
  ): OrderedMap&lt;M, V&gt;;

  mapEntries&lt;KM, VM&gt;(
    mapper: (entry: [K, V], index: number, iter: this) =&gt; [KM, VM],
    context?: mixed
  ): OrderedMap&lt;KM, VM&gt;;

  flatMap&lt;KM, VM&gt;(
    mapper: (value: V, key: K, iter: this) =&gt; Iterable&lt;[KM, VM]&gt;,
    context?: mixed
  ): OrderedMap&lt;KM, VM&gt;;

  flatten(depth?: number): OrderedMap&lt;any, any&gt;;
  flatten(shallow?: boolean): OrderedMap&lt;any, any&gt;;
}

declare function isSet(maybeSet: mixed): boolean %checks(maybeSet instanceof
  Set);
declare class Set&lt;+T&gt; extends SetCollection&lt;T&gt; {
  static &lt;T&gt;(values?: Iterable&lt;T&gt;): Set&lt;T&gt;;

  static of&lt;T&gt;(...values: T[]): Set&lt;T&gt;;
  static fromKeys&lt;T&gt;(
    values: Iterable&lt;[T, mixed]&gt; | PlainObjInput&lt;T, mixed&gt;
  ): Set&lt;T&gt;;

  static intersect(sets: Iterable&lt;Iterable&lt;T&gt;&gt;): Set&lt;T&gt;;
  static union(sets: Iterable&lt;Iterable&lt;T&gt;&gt;): Set&lt;T&gt;;

  static isSet: typeof isSet;

  size: number;

  add&lt;U&gt;(value: U): Set&lt;T | U&gt;;
  delete(value: T): this;
  remove(value: T): this;
  clear(): this;
  union&lt;U&gt;(...collections: Iterable&lt;U&gt;[]): Set&lt;T | U&gt;;
  merge&lt;U&gt;(...collections: Iterable&lt;U&gt;[]): Set&lt;T | U&gt;;
  concat&lt;U&gt;(...collections: Iterable&lt;U&gt;[]): Set&lt;T | U&gt;;
  intersect&lt;U&gt;(...collections: Iterable&lt;U&gt;[]): Set&lt;T &amp; U&gt;;
  subtract(...collections: Iterable&lt;mixed&gt;[]): this;

  withMutations(mutator: (mutable: this) =&gt; mixed): this;
  asMutable(): this;
  wasAltered(): boolean;
  asImmutable(): this;

  // Override specialized return types

  filter(predicate: typeof Boolean): Set&lt;$NonMaybeType&lt;T&gt;&gt;;
  filter(
    predicate: (value: T, value: T, iter: this) =&gt; mixed,
    context?: mixed
  ): Set&lt;T&gt;;

  partition(
    predicate: (value: T, value: T, iter: this) =&gt; mixed,
    context?: mixed
  ): [this, this];

  map&lt;M&gt;(
    mapper: (value: T, value: T, iter: this) =&gt; M,
    context?: mixed
  ): Set&lt;M&gt;;

  flatMap&lt;M&gt;(
    mapper: (value: T, value: T, iter: this) =&gt; Iterable&lt;M&gt;,
    context?: mixed
  ): Set&lt;M&gt;;

  flatten(depth?: number): Set&lt;any&gt;;
  flatten(shallow?: boolean): Set&lt;any&gt;;
}

// Overrides except for `isOrderedSet` are for specialized return types
declare function isOrderedSet(
  maybeOrderedSet: mixed
): boolean %checks(maybeOrderedSet instanceof OrderedSet);
declare class OrderedSet&lt;+T&gt; extends Set&lt;T&gt; {
  static &lt;T&gt;(values?: Iterable&lt;T&gt;): OrderedSet&lt;T&gt;;

  static of&lt;T&gt;(...values: T[]): OrderedSet&lt;T&gt;;
  static fromKeys&lt;T&gt;(
    values: Iterable&lt;[T, mixed]&gt; | PlainObjInput&lt;T, mixed&gt;
  ): OrderedSet&lt;T&gt;;

  static isOrderedSet: typeof isOrderedSet;

  size: number;

  add&lt;U&gt;(value: U): OrderedSet&lt;T | U&gt;;
  union&lt;U&gt;(...collections: Iterable&lt;U&gt;[]): OrderedSet&lt;T | U&gt;;
  merge&lt;U&gt;(...collections: Iterable&lt;U&gt;[]): OrderedSet&lt;T | U&gt;;
  concat&lt;U&gt;(...collections: Iterable&lt;U&gt;[]): OrderedSet&lt;T | U&gt;;
  intersect&lt;U&gt;(...collections: Iterable&lt;U&gt;[]): OrderedSet&lt;T &amp; U&gt;;

  filter(predicate: typeof Boolean): OrderedSet&lt;$NonMaybeType&lt;T&gt;&gt;;
  filter(
    predicate: (value: T, value: T, iter: this) =&gt; mixed,
    context?: mixed
  ): OrderedSet&lt;T&gt;;

  partition(
    predicate: (value: T, value: T, iter: this) =&gt; mixed,
    context?: mixed
  ): [this, this];

  map&lt;M&gt;(
    mapper: (value: T, value: T, iter: this) =&gt; M,
    context?: mixed
  ): OrderedSet&lt;M&gt;;

  flatMap&lt;M&gt;(
    mapper: (value: T, value: T, iter: this) =&gt; Iterable&lt;M&gt;,
    context?: mixed
  ): OrderedSet&lt;M&gt;;

  flatten(depth?: number): OrderedSet&lt;any&gt;;
  flatten(shallow?: boolean): OrderedSet&lt;any&gt;;

  zip&lt;A&gt;(a: Iterable&lt;A&gt;, ..._: []): OrderedSet&lt;[T, A]&gt;;
  zip&lt;A, B&gt;(a: Iterable&lt;A&gt;, b: Iterable&lt;B&gt;, ..._: []): OrderedSet&lt;[T, A, B]&gt;;
  zip&lt;A, B, C&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): OrderedSet&lt;[T, A, B, C]&gt;;
  zip&lt;A, B, C, D&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): OrderedSet&lt;[T, A, B, C, D]&gt;;
  zip&lt;A, B, C, D, E&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): OrderedSet&lt;[T, A, B, C, D, E]&gt;;

  zipAll&lt;A&gt;(a: Iterable&lt;A&gt;, ..._: []): OrderedSet&lt;[T | void, A | void]&gt;;
  zipAll&lt;A, B&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    ..._: []
  ): OrderedSet&lt;[T | void, A | void, B | void]&gt;;
  zipAll&lt;A, B, C&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): OrderedSet&lt;[T | void, A | void, B | void, C | void]&gt;;
  zipAll&lt;A, B, C, D&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): OrderedSet&lt;[T | void, A | void, B | void, C | void, D | void]&gt;;
  zipAll&lt;A, B, C, D, E&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): OrderedSet&lt;[T | void, A | void, B | void, C | void, D | void, E | void]&gt;;

  zipWith&lt;A, R&gt;(
    zipper: (value: T, a: A) =&gt; R,
    a: Iterable&lt;A&gt;,
    ..._: []
  ): OrderedSet&lt;R&gt;;
  zipWith&lt;A, B, R&gt;(
    zipper: (value: T, a: A, b: B) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    ..._: []
  ): OrderedSet&lt;R&gt;;
  zipWith&lt;A, B, C, R&gt;(
    zipper: (value: T, a: A, b: B, c: C) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): OrderedSet&lt;R&gt;;
  zipWith&lt;A, B, C, D, R&gt;(
    zipper: (value: T, a: A, b: B, c: C, d: D) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): OrderedSet&lt;R&gt;;
  zipWith&lt;A, B, C, D, E, R&gt;(
    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): OrderedSet&lt;R&gt;;
}

declare function isStack(
  maybeStack: mixed
): boolean %checks(maybeStack instanceof Stack);
declare class Stack&lt;+T&gt; extends IndexedCollection&lt;T&gt; {
  static &lt;T&gt;(collection?: Iterable&lt;T&gt;): Stack&lt;T&gt;;

  static isStack(maybeStack: mixed): boolean;
  static of&lt;T&gt;(...values: T[]): Stack&lt;T&gt;;

  static isStack: typeof isStack;

  size: number;

  peek(): T;
  clear(): this;
  unshift&lt;U&gt;(...values: U[]): Stack&lt;T | U&gt;;
  unshiftAll&lt;U&gt;(iter: Iterable&lt;U&gt;): Stack&lt;T | U&gt;;
  shift(): this;
  push&lt;U&gt;(...values: U[]): Stack&lt;T | U&gt;;
  pushAll&lt;U&gt;(iter: Iterable&lt;U&gt;): Stack&lt;T | U&gt;;
  pop(): this;

  withMutations(mutator: (mutable: this) =&gt; mixed): this;
  asMutable(): this;
  wasAltered(): boolean;
  asImmutable(): this;

  // Override specialized return types

  concat&lt;C&gt;(...iters: Array&lt;Iterable&lt;C&gt; | C&gt;): Stack&lt;T | C&gt;;

  filter(predicate: typeof Boolean): Stack&lt;$NonMaybeType&lt;T&gt;&gt;;
  filter(
    predicate: (value: T, index: number, iter: this) =&gt; mixed,
    context?: mixed
  ): Stack&lt;T&gt;;

  map&lt;M&gt;(
    mapper: (value: T, index: number, iter: this) =&gt; M,
    context?: mixed
  ): Stack&lt;M&gt;;

  flatMap&lt;M&gt;(
    mapper: (value: T, index: number, iter: this) =&gt; Iterable&lt;M&gt;,
    context?: mixed
  ): Stack&lt;M&gt;;

  flatten(depth?: number): Stack&lt;any&gt;;
  flatten(shallow?: boolean): Stack&lt;any&gt;;

  zip&lt;A&gt;(a: Iterable&lt;A&gt;, ..._: []): Stack&lt;[T, A]&gt;;
  zip&lt;A, B&gt;(a: Iterable&lt;A&gt;, b: Iterable&lt;B&gt;, ..._: []): Stack&lt;[T, A, B]&gt;;
  zip&lt;A, B, C&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): Stack&lt;[T, A, B, C]&gt;;
  zip&lt;A, B, C, D&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): Stack&lt;[T, A, B, C, D]&gt;;
  zip&lt;A, B, C, D, E&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): Stack&lt;[T, A, B, C, D, E]&gt;;

  zipAll&lt;A&gt;(a: Iterable&lt;A&gt;, ..._: []): Stack&lt;[T | void, A | void]&gt;;
  zipAll&lt;A, B&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    ..._: []
  ): Stack&lt;[T | void, A | void, B | void]&gt;;
  zipAll&lt;A, B, C&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): Stack&lt;[T | void, A | void, B | void, C | void]&gt;;
  zipAll&lt;A, B, C, D&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): Stack&lt;[T | void, A | void, B | void, C | void, D | void]&gt;;
  zipAll&lt;A, B, C, D, E&gt;(
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): Stack&lt;[T | void, A | void, B | void, C | void, D | void, E | void]&gt;;

  zipWith&lt;A, R&gt;(
    zipper: (value: T, a: A) =&gt; R,
    a: Iterable&lt;A&gt;,
    ..._: []
  ): Stack&lt;R&gt;;
  zipWith&lt;A, B, R&gt;(
    zipper: (value: T, a: A, b: B) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    ..._: []
  ): Stack&lt;R&gt;;
  zipWith&lt;A, B, C, R&gt;(
    zipper: (value: T, a: A, b: B, c: C) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    ..._: []
  ): Stack&lt;R&gt;;
  zipWith&lt;A, B, C, D, R&gt;(
    zipper: (value: T, a: A, b: B, c: C, d: D) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    ..._: []
  ): Stack&lt;R&gt;;
  zipWith&lt;A, B, C, D, E, R&gt;(
    zipper: (value: T, a: A, b: B, c: C, d: D, e: E) =&gt; R,
    a: Iterable&lt;A&gt;,
    b: Iterable&lt;B&gt;,
    c: Iterable&lt;C&gt;,
    d: Iterable&lt;D&gt;,
    e: Iterable&lt;E&gt;,
    ..._: []
  ): Stack&lt;R&gt;;
}

declare function Range(
  start?: number,
  end?: number,
  step?: number
): IndexedSeq&lt;number&gt;;
declare function Repeat&lt;T&gt;(value: T, times?: number): IndexedSeq&lt;T&gt;;

// The type of a Record factory function.
type RecordFactory&lt;Values: Object&gt; = Class&lt;RecordInstance&lt;Values&gt;&gt;;

// The type of runtime Record instances.
type RecordOf&lt;Values: Object&gt; = RecordInstance&lt;Values&gt; &amp; $ReadOnly&lt;Values&gt;;

// The values of a Record instance.
type _RecordValues&lt;T, R: RecordInstance&lt;T&gt; | T&gt; = R;
type RecordValues&lt;R&gt; = _RecordValues&lt;*, R&gt;;

declare function isRecord(
  maybeRecord: any
): boolean %checks(maybeRecord instanceof RecordInstance);
declare class Record {
  static &lt;Values: Object&gt;(spec: Values, name?: string): typeof RecordInstance;
  constructor&lt;Values: Object&gt;(
    spec: Values,
    name?: string
  ): typeof RecordInstance;

  static isRecord: typeof isRecord;

  static getDescriptiveName(record: RecordInstance&lt;any&gt;): string;
}

declare class RecordInstance&lt;T: Object = Object&gt; {
  static (values?: Iterable&lt;[$Keys&lt;T&gt;, $ValOf&lt;T&gt;]&gt; | $Shape&lt;T&gt;): RecordOf&lt;T&gt;;
  // Note: a constructor can only create an instance of RecordInstance&lt;T&gt;,
  // it's encouraged to not use `new` when creating Records.
  constructor(values?: Iterable&lt;[$Keys&lt;T&gt;, $ValOf&lt;T&gt;]&gt; | $Shape&lt;T&gt;): void;

  size: number;

  has(key: string): boolean;

  get&lt;K: $Keys&lt;T&gt;&gt;(key: K, ..._: []): $ElementType&lt;T, K&gt;;
  get&lt;K: $Keys&lt;T&gt;, NSV&gt;(key: K, notSetValue: NSV): $ElementType&lt;T, K&gt; | NSV;

  hasIn(keyPath: Iterable&lt;mixed&gt;): boolean;

  getIn(keyPath: [], notSetValue?: mixed): this &amp; $ReadOnly&lt;T&gt;;
  getIn&lt;K: $Keys&lt;T&gt;&gt;(keyPath: [K], notSetValue?: mixed): $ElementType&lt;T, K&gt;;
  getIn&lt;NSV, K: $Keys&lt;T&gt;, K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;&gt;(
    keyPath: [K, K2],
    notSetValue: NSV
  ): $ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt; | NSV;
  getIn&lt;
    NSV,
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3],
    notSetValue: NSV
  ): $ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt; | NSV;
  getIn&lt;
    NSV,
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4],
    notSetValue: NSV
  ): $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt; | NSV;
  getIn&lt;
    NSV,
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5],
    notSetValue: NSV
  ): $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt; | NSV;

  equals(other: any): boolean;
  hashCode(): number;

  set&lt;K: $Keys&lt;T&gt;&gt;(key: K, value: $ElementType&lt;T, K&gt;): this &amp; $ReadOnly&lt;T&gt;;
  update&lt;K: $Keys&lt;T&gt;&gt;(
    key: K,
    updater: (value: $ElementType&lt;T, K&gt;) =&gt; $ElementType&lt;T, K&gt;
  ): this &amp; $ReadOnly&lt;T&gt;;
  merge(
    ...collections: Array&lt;Iterable&lt;[$Keys&lt;T&gt;, $ValOf&lt;T&gt;]&gt; | $Shape&lt;T&gt;&gt;
  ): this &amp; $ReadOnly&lt;T&gt;;
  mergeDeep(
    ...collections: Array&lt;Iterable&lt;[$Keys&lt;T&gt;, $ValOf&lt;T&gt;]&gt; | $Shape&lt;T&gt;&gt;
  ): this &amp; $ReadOnly&lt;T&gt;;

  mergeWith(
    merger: (oldVal: $ValOf&lt;T&gt;, newVal: $ValOf&lt;T&gt;, key: $Keys&lt;T&gt;) =&gt; $ValOf&lt;T&gt;,
    ...collections: Array&lt;Iterable&lt;[$Keys&lt;T&gt;, $ValOf&lt;T&gt;]&gt; | $Shape&lt;T&gt;&gt;
  ): this &amp; $ReadOnly&lt;T&gt;;
  mergeDeepWith(
    merger: (oldVal: any, newVal: any, key: any) =&gt; any,
    ...collections: Array&lt;Iterable&lt;[$Keys&lt;T&gt;, $ValOf&lt;T&gt;]&gt; | $Shape&lt;T&gt;&gt;
  ): this &amp; $ReadOnly&lt;T&gt;;

  delete&lt;K: $Keys&lt;T&gt;&gt;(key: K): this &amp; $ReadOnly&lt;T&gt;;
  remove&lt;K: $Keys&lt;T&gt;&gt;(key: K): this &amp; $ReadOnly&lt;T&gt;;
  clear(): this &amp; $ReadOnly&lt;T&gt;;

  setIn&lt;S&gt;(keyPath: [], value: S): S;
  setIn&lt;K: $Keys&lt;T&gt;, S: $ValOf&lt;T, K&gt;&gt;(
    keyPath: [K],
    value: S
  ): this &amp; $ReadOnly&lt;T&gt;;
  setIn&lt;K: $Keys&lt;T&gt;, K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;, S: $ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;(
    keyPath: [K, K2],
    value: S
  ): this &amp; $ReadOnly&lt;T&gt;;
  setIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;
  &gt;(
    keyPath: [K, K2, K3],
    value: S
  ): this &amp; $ReadOnly&lt;T&gt;;
  setIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;
  &gt;(
    keyPath: [K, K2, K3, K4],
    value: S
  ): this &amp; $ReadOnly&lt;T&gt;;
  setIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5],
    value: S
  ): this &amp; $ReadOnly&lt;T&gt;;

  deleteIn(keyPath: []): void;
  deleteIn&lt;K: $Keys&lt;T&gt;&gt;(keyPath: [K]): this &amp; $ReadOnly&lt;T&gt;;
  deleteIn&lt;K: $Keys&lt;T&gt;, K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;&gt;(
    keyPath: [K, K2]
  ): this &amp; $ReadOnly&lt;T&gt;;
  deleteIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3]
  ): this &amp; $ReadOnly&lt;T&gt;;
  deleteIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4]
  ): this &amp; $ReadOnly&lt;T&gt;;
  deleteIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5]
  ): this &amp; $ReadOnly&lt;T&gt;;

  removeIn(keyPath: []): void;
  removeIn&lt;K: $Keys&lt;T&gt;&gt;(keyPath: [K]): this &amp; $ReadOnly&lt;T&gt;;
  removeIn&lt;K: $Keys&lt;T&gt;, K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;&gt;(
    keyPath: [K, K2]
  ): this &amp; $ReadOnly&lt;T&gt;;
  removeIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3]
  ): this &amp; $ReadOnly&lt;T&gt;;
  removeIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4]
  ): this &amp; $ReadOnly&lt;T&gt;;
  removeIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5]
  ): this &amp; $ReadOnly&lt;T&gt;;

  updateIn&lt;U&gt;(
    keyPath: [],
    notSetValue: mixed,
    updater: (value: this &amp; T) =&gt; U
  ): U;
  updateIn&lt;U&gt;(keyPath: [], updater: (value: this &amp; T) =&gt; U): U;
  updateIn&lt;NSV, K: $Keys&lt;T&gt;, S: $ValOf&lt;T, K&gt;&gt;(
    keyPath: [K],
    notSetValue: NSV,
    updater: (value: $ValOf&lt;T, K&gt;) =&gt; S
  ): this &amp; $ReadOnly&lt;T&gt;;
  updateIn&lt;K: $Keys&lt;T&gt;, S: $ValOf&lt;T, K&gt;&gt;(
    keyPath: [K],
    updater: (value: $ValOf&lt;T, K&gt;) =&gt; S
  ): this &amp; $ReadOnly&lt;T&gt;;
  updateIn&lt;
    NSV,
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;
  &gt;(
    keyPath: [K, K2],
    notSetValue: NSV,
    updater: (value: $ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt; | NSV) =&gt; S
  ): this &amp; $ReadOnly&lt;T&gt;;
  updateIn&lt;K: $Keys&lt;T&gt;, K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;, S: $ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;(
    keyPath: [K, K2],
    updater: (value: $ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;) =&gt; S
  ): this &amp; $ReadOnly&lt;T&gt;;
  updateIn&lt;
    NSV,
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;
  &gt;(
    keyPath: [K, K2, K3],
    notSetValue: NSV,
    updater: (value: $ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt; | NSV) =&gt; S
  ): this &amp; $ReadOnly&lt;T&gt;;
  updateIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;
  &gt;(
    keyPath: [K, K2, K3],
    updater: (value: $ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;) =&gt; S
  ): this &amp; $ReadOnly&lt;T&gt;;
  updateIn&lt;
    NSV,
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;
  &gt;(
    keyPath: [K, K2, K3, K4],
    notSetValue: NSV,
    updater: (
      value: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt; | NSV
    ) =&gt; S
  ): this &amp; $ReadOnly&lt;T&gt;;
  updateIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;
  &gt;(
    keyPath: [K, K2, K3, K4],
    updater: (value: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;) =&gt; S
  ): this &amp; $ReadOnly&lt;T&gt;;
  updateIn&lt;
    NSV,
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5],
    notSetValue: NSV,
    updater: (
      value: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt; | NSV
    ) =&gt; S
  ): this &amp; $ReadOnly&lt;T&gt;;
  updateIn&lt;
    K: $Keys&lt;T&gt;,
    K2: $KeyOf&lt;$ValOf&lt;T, K&gt;&gt;,
    K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;&gt;,
    K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;&gt;,
    K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;&gt;,
    S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt;
  &gt;(
    keyPath: [K, K2, K3, K4, K5],
    updater: (
      value: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;T, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt;
    ) =&gt; S
  ): this &amp; $ReadOnly&lt;T&gt;;

  mergeIn(
    keyPath: Iterable&lt;mixed&gt;,
    ...collections: Array&lt;any&gt;
  ): this &amp; $ReadOnly&lt;T&gt;;
  mergeDeepIn(
    keyPath: Iterable&lt;mixed&gt;,
    ...collections: Array&lt;any&gt;
  ): this &amp; $ReadOnly&lt;T&gt;;

  toSeq(): KeyedSeq&lt;$Keys&lt;T&gt;, any&gt;;

  toJS(): { [key: $Keys&lt;T&gt;]: mixed };
  toJSON(): T;
  toObject(): T;

  withMutations(mutator: (mutable: this &amp; T) =&gt; mixed): this &amp; $ReadOnly&lt;T&gt;;
  asMutable(): this &amp; $ReadOnly&lt;T&gt;;
  wasAltered(): boolean;
  asImmutable(): this &amp; $ReadOnly&lt;T&gt;;

  @@iterator(): Iterator&lt;[$Keys&lt;T&gt;, $ValOf&lt;T&gt;]&gt;;
}

declare function fromJS(
  jsValue: mixed,
  reviver?: (
    key: string | number,
    sequence: KeyedCollection&lt;string, mixed&gt; | IndexedCollection&lt;mixed&gt;,
    path?: Array&lt;string | number&gt;
  ) =&gt; mixed
): Collection&lt;mixed, mixed&gt;;

declare function is(first: mixed, second: mixed): boolean;
declare function hash(value: mixed): number;

declare function get&lt;C: Object, K: $Keys&lt;C&gt;&gt;(
  collection: C,
  key: K,
  notSetValue: mixed
): $ValOf&lt;C, K&gt;;
declare function get&lt;C, K: $KeyOf&lt;C&gt;, NSV&gt;(
  collection: C,
  key: K,
  notSetValue: NSV
): $ValOf&lt;C, K&gt; | NSV;

declare function has(collection: Object, key: mixed): boolean;
declare function remove&lt;C&gt;(collection: C, key: $KeyOf&lt;C&gt;): C;
declare function set&lt;C, K: $KeyOf&lt;C&gt;, V: $ValOf&lt;C, K&gt;&gt;(
  collection: C,
  key: K,
  value: V
): C;
declare function update&lt;C, K: $KeyOf&lt;C&gt;, V: $ValOf&lt;C, K&gt;, NSV&gt;(
  collection: C,
  key: K,
  notSetValue: NSV,
  updater: ($ValOf&lt;C, K&gt; | NSV) =&gt; V
): C;
declare function update&lt;C, K: $KeyOf&lt;C&gt;, V: $ValOf&lt;C, K&gt;&gt;(
  collection: C,
  key: K,
  updater: ($ValOf&lt;C, K&gt;) =&gt; V
): C;

declare function getIn&lt;C&gt;(collection: C, keyPath: [], notSetValue?: mixed): C;
declare function getIn&lt;C, K: $KeyOf&lt;C&gt;, NSV&gt;(
  collection: C,
  keyPath: [K],
  notSetValue: NSV
): $ValOf&lt;C, K&gt; | NSV;
declare function getIn&lt;C, K: $KeyOf&lt;C&gt;, K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;, NSV&gt;(
  collection: C,
  keyPath: [K, K2],
  notSetValue: NSV
): $ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt; | NSV;
declare function getIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  NSV
&gt;(
  collection: C,
  keyPath: [K, K2, K3],
  notSetValue: NSV
): $ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt; | NSV;
declare function getIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;&gt;,
  NSV
&gt;(
  collection: C,
  keyPath: [K, K2, K3, K4],
  notSetValue: NSV
): $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt; | NSV;
declare function getIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;&gt;,
  K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;&gt;,
  NSV
&gt;(
  collection: C,
  keyPath: [K, K2, K3, K4, K5],
  notSetValue: NSV
): $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt; | NSV;

declare function hasIn(collection: Object, keyPath: Iterable&lt;mixed&gt;): boolean;

declare function removeIn&lt;C&gt;(collection: C, keyPath: []): void;
declare function removeIn&lt;C, K: $KeyOf&lt;C&gt;&gt;(collection: C, keyPath: [K]): C;
declare function removeIn&lt;C, K: $KeyOf&lt;C&gt;, K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;&gt;(
  collection: C,
  keyPath: [K, K2]
): C;
declare function removeIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;
&gt;(
  collection: C,
  keyPath: [K, K2, K3]
): C;
declare function removeIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;&gt;
&gt;(
  collection: C,
  keyPath: [K, K2, K3, K4]
): C;
declare function removeIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;&gt;,
  K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;&gt;
&gt;(
  collection: C,
  keyPath: [K, K2, K3, K4, K5]
): C;

declare function setIn&lt;S&gt;(collection: Object, keyPath: [], value: S): S;
declare function setIn&lt;C, K: $KeyOf&lt;C&gt;, S: $ValOf&lt;C, K&gt;&gt;(
  collection: C,
  keyPath: [K],
  value: S
): C;
declare function setIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;
&gt;(
  collection: C,
  keyPath: [K, K2],
  value: S
): C;
declare function setIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;
&gt;(
  collection: C,
  keyPath: [K, K2, K3],
  value: S
): C;
declare function setIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;
&gt;(
  collection: C,
  keyPath: [K, K2, K3, K4],
  value: S
): C;
declare function setIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;&gt;,
  K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt;
&gt;(
  collection: C,
  keyPath: [K, K2, K3, K4, K5],
  value: S
): C;

declare function updateIn&lt;C, S&gt;(
  collection: C,
  keyPath: [],
  notSetValue: mixed,
  updater: (value: C) =&gt; S
): S;
declare function updateIn&lt;C, S&gt;(
  collection: C,
  keyPath: [],
  updater: (value: C) =&gt; S
): S;
declare function updateIn&lt;C, K: $KeyOf&lt;C&gt;, S: $ValOf&lt;C, K&gt;, NSV&gt;(
  collection: C,
  keyPath: [K],
  notSetValue: NSV,
  updater: (value: $ValOf&lt;C, K&gt; | NSV) =&gt; S
): C;
declare function updateIn&lt;C, K: $KeyOf&lt;C&gt;, S: $ValOf&lt;C, K&gt;&gt;(
  collection: C,
  keyPath: [K],
  updater: (value: $ValOf&lt;C, K&gt;) =&gt; S
): C;
declare function updateIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;,
  NSV
&gt;(
  collection: C,
  keyPath: [K, K2],
  notSetValue: NSV,
  updater: (value: $ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt; | NSV) =&gt; S
): C;
declare function updateIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;
&gt;(
  collection: C,
  keyPath: [K, K2],
  updater: (value: $ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;) =&gt; S
): C;
declare function updateIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;,
  NSV
&gt;(
  collection: C,
  keyPath: [K, K2, K3],
  notSetValue: NSV,
  updater: (value: $ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt; | NSV) =&gt; S
): C;
declare function updateIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;
&gt;(
  collection: C,
  keyPath: [K, K2, K3],
  updater: (value: $ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;) =&gt; S
): C;
declare function updateIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;,
  NSV
&gt;(
  collection: C,
  keyPath: [K, K2, K3, K4],
  notSetValue: NSV,
  updater: (value: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt; | NSV) =&gt; S
): C;
declare function updateIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;
&gt;(
  collection: C,
  keyPath: [K, K2, K3, K4],
  updater: (value: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;) =&gt; S
): C;
declare function updateIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;&gt;,
  K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt;,
  NSV
&gt;(
  collection: C,
  keyPath: [K, K2, K3, K4, K5],
  notSetValue: NSV,
  updater: (
    value: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt; | NSV
  ) =&gt; S
): C;
declare function updateIn&lt;
  C,
  K: $KeyOf&lt;C&gt;,
  K2: $KeyOf&lt;$ValOf&lt;C, K&gt;&gt;,
  K3: $KeyOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;&gt;,
  K4: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;&gt;,
  K5: $KeyOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;&gt;,
  S: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt;
&gt;(
  collection: C,
  keyPath: [K, K2, K3, K4, K5],
  updater: (
    value: $ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;$ValOf&lt;C, K&gt;, K2&gt;, K3&gt;, K4&gt;, K5&gt;
  ) =&gt; S
): C;

declare function merge&lt;C&gt;(
  collection: C,
  ...collections: Array&lt;
    | $IterableOf&lt;C&gt;
    | $Shape&lt;RecordValues&lt;C&gt;&gt;
    | PlainObjInput&lt;$KeyOf&lt;C&gt;, $ValOf&lt;C&gt;&gt;
  &gt;
): C;
declare function mergeWith&lt;C&gt;(
  merger: (oldVal: $ValOf&lt;C&gt;, newVal: $ValOf&lt;C&gt;, key: $KeyOf&lt;C&gt;) =&gt; $ValOf&lt;C&gt;,
  collection: C,
  ...collections: Array&lt;
    | $IterableOf&lt;C&gt;
    | $Shape&lt;RecordValues&lt;C&gt;&gt;
    | PlainObjInput&lt;$KeyOf&lt;C&gt;, $ValOf&lt;C&gt;&gt;
  &gt;
): C;
declare function mergeDeep&lt;C&gt;(
  collection: C,
  ...collections: Array&lt;
    | $IterableOf&lt;C&gt;
    | $Shape&lt;RecordValues&lt;C&gt;&gt;
    | PlainObjInput&lt;$KeyOf&lt;C&gt;, $ValOf&lt;C&gt;&gt;
  &gt;
): C;
declare function mergeDeepWith&lt;C&gt;(
  merger: (oldVal: any, newVal: any, key: any) =&gt; mixed,
  collection: C,
  ...collections: Array&lt;
    | $IterableOf&lt;C&gt;
    | $Shape&lt;RecordValues&lt;C&gt;&gt;
    | PlainObjInput&lt;$KeyOf&lt;C&gt;, $ValOf&lt;C&gt;&gt;
  &gt;
): C;

export {
  Collection,
  Seq,
  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,
  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 type {
  KeyedCollection,
  IndexedCollection,
  SetCollection,
  KeyedSeq,
  IndexedSeq,
  SetSeq,
  RecordFactory,
  RecordOf,
  RecordInstance,
  ValueObject,
  $KeyOf,
  $ValOf,
};
</textarea><br>
    <input type="submit" value="Save">
</form>