Tryag File Manager

/var/www/html/tpid-padi/node_modules/immutable/dist/immutable.js.flow

/**
 * 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<number> = Seq.Indexed.of(1, 2, 3)
 *
 * function takesASeq<T, TS: IndexedCollection<T>>(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<K, V> = { +[key: K]: V, __proto__: null };

type K<T> = $Keys<T>;

// 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>) &
 (<T: Object>(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>) &
 (<T: Object>(T) => $Values<T>),
 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
>;

const PairSorting: $ReadOnly<{ LeftThenRight: number, RightThenLeft: number }> =
 {
 LeftThenRight: -1,
 RightThenLeft: +1,
 };

type Comparator<T> = (left: T, right: T) => number;

declare class _Collection<K, +V> implements ValueObject {
 equals(other: mixed): boolean;
 hashCode(): number;
 get(key: K, ..._: []): V | void;
 get<NSV>(key: K, notSetValue: NSV): V | NSV;
 has(key: K): boolean;
 includes(value: V): boolean;
 contains(value: V): boolean;
 first<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(updater: (value: this) => U): U;

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

keys(): Iterator<K>;
 values(): Iterator<V>;
 entries(): Iterator<[K, V]>;

keySeq(): IndexedSeq<K>;
 valueSeq(): IndexedSeq<V>;
 entrySeq(): IndexedSeq<[K, V]>;

reverse(): this;
 sort(comparator?: Comparator<V>): this;

sortBy<C>(
 comparatorValueMapper: (value: V, key: K, iter: this) => C,
 comparator?: Comparator<C>
 ): this;

groupBy<G>(
 grouper: (value: V, key: K, iter: this) => G,
 context?: mixed
 ): KeyedSeq<G, this>;

forEach(
    sideEffect: (value: V, key: K, iter: this) => 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) => 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;

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

reduce<R>(
 reducer: (reduction: R, value: V, key: K, iter: this) => R,
 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
 ): 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;
 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>;

find<NSV>(
 predicate: (value: V, key: K, iter: this) => mixed,
 context?: mixed,
 notSetValue?: NSV
 ): V | NSV;
 findLast<NSV>(
 predicate: (value: V, key: K, iter: this) => mixed,
 context?: mixed,
 notSetValue?: NSV
 ): 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;

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;

max(comparator?: Comparator<V>): V;
 maxBy<C>(
 comparatorValueMapper: (value: V, key: K, iter: this) => C,
 comparator?: Comparator<C>
 ): V;
 min(comparator?: Comparator<V>): V;
 minBy<C>(
 comparatorValueMapper: (value: V, key: K, iter: this) => C,
 comparator?: Comparator<C>
 ): V;

isSubset(iter: Iterable<V>): boolean;
 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 ||
  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<K, +V> extends _Collection<K, V> {
 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<K, +V> extends Collection<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<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>;

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

map<M>(
 mapper: (value: V, key: K, iter: this) => M,
 context?: mixed
 ): KeyedCollection<K, M>;

mapKeys<M>(
 mapper: (key: K, value: V, iter: this) => M,
 context?: mixed
 ): KeyedCollection<M, V>;

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

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

flatten(depth?: number): KeyedCollection<any, any>;
 flatten(shallow?: boolean): KeyedCollection<any, any>;
}

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;

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

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

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

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>;

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

map<M>(
 mapper: (value: T, index: number, iter: this) => M,
 context?: mixed
 ): IndexedCollection<M>;

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

flatten(depth?: number): IndexedCollection<any>;
 flatten(shallow?: boolean): IndexedCollection<any>;
}

declare class SetCollection<+T> extends Collection<T, T> {
 static <T>(iter?: Iterable<T>): SetCollection<T>;

toJS(): Array<mixed>;
 toJSON(): Array<T>;
 toArray(): Array<T>;
 @@iterator(): Iterator<T>;
 toSeq(): SetSeq<T>;

concat(...collections: Iterable[]): 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>;

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

map<M>(
 mapper: (value: T, value: T, iter: this) => M,
 context?: mixed
 ): SetCollection<M>;

flatMap<M>(
 mapper: (value: T, value: T, iter: this) => Iterable<M>,
 context?: mixed
 ): SetCollection<M>;

flatten(depth?: number): SetCollection<any>;
 flatten(shallow?: boolean): SetCollection<any>;
}

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>(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 | void;
  cacheResult(): this;
  toSeq(): this;
}

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

// Override specialized return types
 flip(): KeyedSeq<V, K>;

concat<KC, VC>(
 ...iters: Array<Iterable<[KC, VC]> | PlainObjInput<KC, VC>>
 ): KeyedSeq<K | KC, V | VC>;

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

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

map<M>(
 mapper: (value: V, key: K, iter: this) => M,
 context?: mixed
 ): KeyedSeq<K, M>;

mapKeys<M>(
 mapper: (key: K, value: V, iter: this) => M,
 context?: mixed
 ): KeyedSeq<M, V>;

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

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

flatten(depth?: number): KeyedSeq<any, any>;
 flatten(shallow?: boolean): KeyedSeq<any, any>;
}

declare class IndexedSeq<+T>
 extends Seq<number, T>
 mixins 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>;

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

map<M>(
 mapper: (value: T, index: number, iter: this) => M,
 context?: mixed
 ): IndexedSeq<M>;

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

flatten(depth?: number): IndexedSeq<any>;
 flatten(shallow?: boolean): IndexedSeq<any>;

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

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

declare class SetSeq<+T> extends Seq<T, T> mixins SetCollection<T> {
 static <T>(values?: Iterable<T>): SetSeq<T>;

static of<T>(...values: T[]): SetSeq<T>;

// Override specialized return types

concat(...collections: Iterable[]): SetSeq<T | U>;

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

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

map<M>(
 mapper: (value: T, value: T, iter: this) => M,
 context?: mixed
 ): SetSeq<M>;

flatMap<M>(
 mapper: (value: T, value: T, iter: this) => Iterable<M>,
 context?: mixed
 ): SetSeq<M>;

flatten(depth?: number): SetSeq<any>;
 flatten(shallow?: boolean): SetSeq<any>;
}

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

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

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

updateIn(keyPath: [], notSetValue: mixed, updater: (value: this) => U): U;
 updateIn(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(index: number, value: U): List<T | U>;
 delete(index: number): this;
 remove(index: number): this;
 insert(index: number, value: U): List<T | U>;
 clear(): this;
 push(...values: U[]): List<T | U>;
 pop(): this;
 unshift(...values: U[]): List<T | U>;
 shift(): this;

update(updater: (value: this) => U): U;
 update(index: number, updater: (value: T) => U): List<T | U>;
 update(
 index: number,
 notSetValue: U,
 updater: (value: T) => U
 ): List<T | U>;

merge(...collections: Iterable[]): List<T | U>;

setSize(size: number): 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>;

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

map<M>(
 mapper: (value: T, index: number, iter: this) => M,
 context?: mixed
 ): List<M>;

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

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, ..._: []): List<[T, A, B]>;
 zip<A, B, C>(
 a: Iterable<A>,
 b: Iterable,
 c: Iterable<C>,
 ..._: []
 ): List<[T, A, B, C]>;
 zip<A, B, C, D>(
 a: Iterable<A>,
 b: Iterable,
 c: Iterable<C>,
 d: Iterable<D>,
 ..._: []
 ): List<[T, A, B, C, D]>;
 zip<A, B, C, D, E>(
 a: Iterable<A>,
 b: Iterable,
 c: Iterable<C>,
 d: Iterable<D>,
 e: Iterable<E>,
 ..._: []
 ): List<[T, A, B, C, D, E]>;

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

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;
 clear(): this;

deleteAll(keys: Iterable<K>): Map<K, V>;
 removeAll(keys: Iterable<K>): Map<K, V>;

update(updater: (value: this) => U): U;
 update<V_>(key: K, updater: (value: V) => V_): Map<K, V | V_>;
 update<V_>(
 key: K,
 notSetValue: V_,
 updater: (value: V) => V_
 ): Map<K, V | V_>;

merge<K_, V_>(
 ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
 ): Map<K | K_, V | V_>;
 concat<K_, V_>(
 ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
 ): Map<K | K_, V | V_>;

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

mergeDeep<K_, V_>(
 ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
 ): Map<K | K_, V | V_>;

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

mergeIn(
 keyPath: Iterable<mixed>,
 ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
 ): this;
 mergeDeepIn(
 keyPath: Iterable<mixed>,
 ...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
 ): this;

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>;

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

map<M>(
 mapper: (value: V, key: K, iter: this) => M,
 context?: mixed
 ): Map<K, M>;

mapKeys<M>(
 mapper: (key: K, value: V, iter: this) => M,
 context?: mixed
 ): Map<M, V>;

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

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

flatten(depth?: number): Map<any, any>;
 flatten(shallow?: boolean): Map<any, any>;
}

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;
 clear(): this;

update(updater: (value: this) => U): U;
 update<V_>(key: K, updater: (value: V) => V_): OrderedMap<K, V | V_>;
 update<V_>(
 key: K,
 notSetValue: V_,
 updater: (value: V) => V_
 ): OrderedMap<K, V | V_>;

merge<K_, V_>(
 ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
 ): OrderedMap<K | K_, V | V_>;
 concat<K_, V_>(
 ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
 ): OrderedMap<K | K_, V | V_>;

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

mergeDeep<K_, V_>(
 ...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
 ): OrderedMap<K | K_, V | V_>;

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

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>;

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

map<M>(
 mapper: (value: V, key: K, iter: this) => M,
 context?: mixed
 ): OrderedMap<K, M>;

mapKeys<M>(
 mapper: (key: K, value: V, iter: this) => M,
 context?: mixed
 ): OrderedMap<M, V>;

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

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

flatten(depth?: number): OrderedMap<any, any>;
 flatten(shallow?: boolean): OrderedMap<any, any>;
}

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

static of<T>(...values: T[]): Set<T>;
 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(value: U): Set<T | U>;
 delete(value: T): this;
 remove(value: T): this;
 clear(): this;
 union(...collections: Iterable[]): Set<T | U>;
 merge(...collections: Iterable[]): Set<T | U>;
 concat(...collections: Iterable[]): Set<T | U>;
 intersect(...collections: Iterable[]): 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>;

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

map<M>(
 mapper: (value: T, value: T, iter: this) => M,
 context?: mixed
 ): Set<M>;

flatMap<M>(
 mapper: (value: T, value: T, iter: this) => Iterable<M>,
 context?: mixed
 ): Set<M>;

flatten(depth?: number): Set<any>;
 flatten(shallow?: boolean): Set<any>;
}

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

static of<T>(...values: T[]): OrderedSet<T>;
 static fromKeys<T>(
 values: Iterable<[T, mixed]> | PlainObjInput<T, mixed>
 ): OrderedSet<T>;

static isOrderedSet: typeof isOrderedSet;

size: number;

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

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

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

map<M>(
 mapper: (value: T, value: T, iter: this) => M,
 context?: mixed
 ): OrderedSet<M>;

flatMap<M>(
 mapper: (value: T, value: T, iter: this) => Iterable<M>,
 context?: mixed
 ): OrderedSet<M>;

flatten(depth?: number): OrderedSet<any>;
 flatten(shallow?: boolean): OrderedSet<any>;

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

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

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

static isStack(maybeStack: mixed): boolean;
 static of<T>(...values: T[]): Stack<T>;

static isStack: typeof isStack;

size: number;

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

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
 ): Stack<M>;

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

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, ..._: []): Stack<[T, A, B]>;
 zip<A, B, C>(
 a: Iterable<A>,
 b: Iterable,
 c: Iterable<C>,
 ..._: []
 ): Stack<[T, A, B, C]>;
 zip<A, B, C, D>(
 a: Iterable<A>,
 b: Iterable,
 c: Iterable<C>,
 d: Iterable<D>,
 ..._: []
 ): Stack<[T, A, B, C, D]>;
 zip<A, B, C, D, E>(
 a: Iterable<A>,
 b: Iterable,
 c: Iterable<C>,
 d: Iterable<D>,
 e: Iterable<E>,
 ..._: []
 ): Stack<[T, A, B, C, D, E]>;

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,
 ..._: []
 ): Stack<R>;
 zipWith<A, B, C, R>(
 zipper: (value: T, a: A, b: B, c: C) => R,
 a: Iterable<A>,
 b: Iterable,
 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,
 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,
 c: Iterable<C>,
 d: Iterable<D>,
 e: Iterable<E>,
 ..._: []
 ): Stack<R>;
}

declare function Range(
 start?: number,
 end?: number,
 step?: number
): IndexedSeq<number>;
declare function Repeat<T>(value: T, times?: number): IndexedSeq<T>;

// The type of a Record factory function.
type RecordFactory<Values: Object> = Class<RecordInstance<Values>>;

// The type of runtime Record instances.
type RecordOf<Values: Object> = RecordInstance<Values> & $ReadOnly<Values>;

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

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

static isRecord: typeof isRecord;

static getDescriptiveName(record: RecordInstance<any>): string;
}

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

size: number;

has(key: string): boolean;

get<K: $Keys<T>>(key: K, ..._: []): $ElementType<T, K>;
 get<K: $Keys<T>, NSV>(key: K, notSetValue: NSV): $ElementType<T, K> | NSV;

hasIn(keyPath: Iterable<mixed>): boolean;

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

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

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

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

delete<K: $Keys<T>>(key: K): this & $ReadOnly<T>;
 remove<K: $Keys<T>>(key: K): this & $ReadOnly<T>;
 clear(): this & $ReadOnly<T>;

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

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

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

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

mergeIn(
 keyPath: Iterable<mixed>,
 ...collections: Array<any>
 ): this & $ReadOnly<T>;
 mergeDeepIn(
 keyPath: Iterable<mixed>,
 ...collections: Array<any>
 ): this & $ReadOnly<T>;

toSeq(): KeyedSeq<$Keys<T>, any>;

toJS(): { [key: $Keys<T>]: mixed };
 toJSON(): T;
 toObject(): T;

withMutations(mutator: (mutable: this & T) => mixed): this & $ReadOnly<T>;
 asMutable(): this & $ReadOnly<T>;
 wasAltered(): boolean;
 asImmutable(): this & $ReadOnly<T>;

@@iterator(): Iterator<[$Keys<T>, $ValOf<T>]>;
}

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

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

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

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

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

declare function hasIn(collection: Object, keyPath: Iterable<mixed>): boolean;

declare function removeIn<C>(collection: C, keyPath: []): void;
declare function removeIn<C, K: $KeyOf<C>>(collection: C, keyPath: [K]): C;
declare function removeIn<C, K: $KeyOf<C>, K2: $KeyOf<$ValOf<C, K>>>(
 collection: C,
 keyPath: [K, K2]
): C;
declare function removeIn<
 C,
 K: $KeyOf<C>,
 K2: $KeyOf<$ValOf<C, K>>,
 K3: $KeyOf<$ValOf<$ValOf<C, K>, K2>>
>(
 collection: C,
 keyPath: [K, K2, K3]
): C;
declare function removeIn<
 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>>
>(
 collection: C,
 keyPath: [K, K2, K3, K4]
): C;
declare function removeIn<
 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>>
>(
 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,
  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,
  PairSorting,
  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 {
  Comparator,
  KeyedCollection,
  IndexedCollection,
  SetCollection,
  KeyedSeq,
  IndexedSeq,
  SetSeq,
  RecordFactory,
  RecordOf,
  RecordInstance,
  ValueObject,
  $KeyOf,
  $ValOf,
};