Monaxys
/
Test_Me
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Studying all day long)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
31 MiB
Tree: 1ba7100de7
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '1ba7100de7'
${ noResults }
Test_Me/node_modules/immutable/dist/immutable.js.flow

2348 lines
60 KiB
Raw Normal View History Unescape

Init commit
2 years ago
/**
* 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
>;
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<U>(updater: (value: this) => U): U;
toJS(): Array<any> | { [key: string]: mixed };
toJSON(): Array<V> | { [key: string]: V };
toArray(): Array<V> | Array<[K, V]>;
toObject(): { [key: string]: V };
toMap(): Map<K, V>;
toOrderedMap(): 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?: (valueA: V, valueB: V) => number): this;
sortBy<C>(
comparatorValueMapper: (value: V, key: K, iter: this) => C,
comparator?: (valueA: C, valueB: C) => number
): 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?: (valueA: V, valueB: V) => number): V;
maxBy<C>(
comparatorValueMapper: (value: V, key: K, iter: this) => C,
comparator?: (valueA: C, valueB: C) => number
): V;
min(comparator?: (valueA: V, valueB: V) => number): V;
minBy<C>(
comparatorValueMapper: (value: V, key: K, iter: this) => C,
comparator?: (valueA: C, valueB: C) => number
): 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>;
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<B>,
..._: []
): IndexedCollection<[T, A, B]>;
zip<A, B, C>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): IndexedCollection<[T, A, B, C]>;
zip<A, B, C, D>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): IndexedCollection<[T, A, B, C, D]>;
zip<A, B, C, D, E>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): IndexedCollection<[T, A, B, C, D, E]>;
zipAll<A>(a: Iterable<A>, ..._: []): IndexedCollection<[T | void, A | void]>;
zipAll<A, B>(
a: Iterable<A>,
b: Iterable<B>,
..._: []
): IndexedCollection<[T | void, A | void, B | void]>;
zipAll<A, B, C>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): IndexedCollection<[T | void, A | void, B | void, C | void]>;
zipAll<A, B, C, D>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): IndexedCollection<[T | void, A | void, B | void, C | void, D | void]>;
zipAll<A, B, C, D, E>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): IndexedCollection<
[T | void, A | void, B | void, C | void, D | void, E | void]
>;
zipWith<A, R>(
zipper: (value: T, a: A) => R,
a: Iterable<A>,
..._: []
): IndexedCollection<R>;
zipWith<A, B, R>(
zipper: (value: T, a: A, b: B) => R,
a: Iterable<A>,
b: Iterable<B>,
..._: []
): IndexedCollection<R>;
zipWith<A, B, C, R>(
zipper: (value: T, a: A, b: B, c: C) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): IndexedCollection<R>;
zipWith<A, B, C, D, R>(
zipper: (value: T, a: A, b: B, c: C, d: D) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): IndexedCollection<R>;
zipWith<A, B, C, D, E, R>(
zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): IndexedCollection<R>;
indexOf(searchValue: T): number;
lastIndexOf(searchValue: T): number;
findIndex(
predicate: (value: T, index: number, iter: this) => mixed,
context?: 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>;
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<U>(...collections: Iterable<U>[]): SetCollection<T | U>;
// `filter`, `map` and `flatMap` cannot be defined further up the hierarchy,
// because the implementation for `KeyedCollection` allows the value type to
// change without constraining the key type. That does not work for
// `SetCollection` - the value and key types *must* match.
filter(predicate: typeof Boolean): SetCollection<$NonMaybeType<T>>;
filter(
predicate: (value: T, value: T, iter: this) => mixed,
context?: mixed
): SetCollection<T>;
map<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>;
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>;
map<M>(
mapper: (value: T, index: number, iter: this) => M,
context?: mixed
): IndexedSeq<M>;
flatMap<M>(
mapper: (value: T, index: number, iter: this) => Iterable<M>,
context?: mixed
): IndexedSeq<M>;
flatten(depth?: number): IndexedSeq<any>;
flatten(shallow?: boolean): IndexedSeq<any>;
zip<A>(a: Iterable<A>, ..._: []): IndexedSeq<[T, A]>;
zip<A, B>(a: Iterable<A>, b: Iterable<B>, ..._: []): IndexedSeq<[T, A, B]>;
zip<A, B, C>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): IndexedSeq<[T, A, B, C]>;
zip<A, B, C, D>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): IndexedSeq<[T, A, B, C, D]>;
zip<A, B, C, D, E>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): IndexedSeq<[T, A, B, C, D, E]>;
zipAll<A>(a: Iterable<A>, ..._: []): IndexedSeq<[T | void, A | void]>;
zipAll<A, B>(
a: Iterable<A>,
b: Iterable<B>,
..._: []
): IndexedSeq<[T | void, A | void, B | void]>;
zipAll<A, B, C>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): IndexedSeq<[T | void, A | void, B | void, C | void]>;
zipAll<A, B, C, D>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): IndexedSeq<[T | void, A | void, B | void, C | void, D | void]>;
zipAll<A, B, C, D, E>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): IndexedSeq<[T | void, A | void, B | void, C | void, D | void, E | void]>;
zipWith<A, R>(
zipper: (value: T, a: A) => R,
a: Iterable<A>,
..._: []
): IndexedSeq<R>;
zipWith<A, B, R>(
zipper: (value: T, a: A, b: B) => R,
a: Iterable<A>,
b: Iterable<B>,
..._: []
): IndexedSeq<R>;
zipWith<A, B, C, R>(
zipper: (value: T, a: A, b: B, c: C) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): IndexedSeq<R>;
zipWith<A, B, C, D, R>(
zipper: (value: T, a: A, b: B, c: C, d: D) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): IndexedSeq<R>;
zipWith<A, B, C, D, E, R>(
zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): IndexedSeq<R>;
}
declare class SetSeq<+T> extends Seq<T, T> mixins SetCollection<T> {
static <T>(values?: Iterable<T>): SetSeq<T>;
static of<T>(...values: T[]): SetSeq<T>;
// Override specialized return types
concat<U>(...collections: Iterable<U>[]): SetSeq<T | U>;
filter(predicate: typeof Boolean): SetSeq<$NonMaybeType<T>>;
filter(
predicate: (value: T, value: T, iter: this) => mixed,
context?: mixed
): SetSeq<T>;
map<M>(
mapper: (value: T, value: T, iter: this) => M,
context?: mixed
): SetSeq<M>;
flatMap<M>(
mapper: (value: T, value: T, iter: this) => Iterable<M>,
context?: mixed
): SetSeq<M>;
flatten(depth?: number): SetSeq<any>;
flatten(shallow?: boolean): SetSeq<any>;
}
declare class UpdatableInCollection<K, +V> {
setIn<S>(keyPath: [], value: S): S;
setIn(keyPath: [K], value: V): this;
setIn<K2: $KeyOf<V>, S: $ValOf<V, K2>>(keyPath: [K, K2], value: S): this;
setIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>, S: $ValOf<$ValOf<V, K2>, K3>>(
keyPath: [K, K2, K3],
value: S
): this;
setIn<
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,
S: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>
>(
keyPath: [K, K2, K3, K4],
value: S
): this;
setIn<
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,
K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>,
S: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>
>(
keyPath: [K, K2, K3, K4, K5],
value: S
): this;
deleteIn(keyPath: []): void;
deleteIn(keyPath: [K]): this;
deleteIn<K2: $KeyOf<V>>(keyPath: [K, K2]): this;
deleteIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>>(
keyPath: [K, K2, K3]
): this;
deleteIn<
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>
>(
keyPath: [K, K2, K3, K4]
): this;
deleteIn<
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,
K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>
>(
keyPath: [K, K2, K3, K4, K5]
): this;
removeIn(keyPath: []): void;
removeIn(keyPath: [K]): this;
removeIn<K2: $KeyOf<V>>(keyPath: [K, K2]): this;
removeIn<K2: $KeyOf<V>, K3: $KeyOf<$ValOf<V, K2>>>(
keyPath: [K, K2, K3]
): this;
removeIn<
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>
>(
keyPath: [K, K2, K3, K4]
): this;
removeIn<
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,
K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>
>(
keyPath: [K, K2, K3, K4, K5]
): this;
updateIn<U>(keyPath: [], notSetValue: mixed, updater: (value: this) => U): U;
updateIn<U>(keyPath: [], updater: (value: this) => U): U;
updateIn<NSV>(keyPath: [K], notSetValue: NSV, updater: (value: V) => V): this;
updateIn(keyPath: [K], updater: (value: V) => V): this;
updateIn<NSV, K2: $KeyOf<V>, S: $ValOf<V, K2>>(
keyPath: [K, K2],
notSetValue: NSV,
updater: (value: $ValOf<V, K2> | NSV) => S
): this;
updateIn<K2: $KeyOf<V>, S: $ValOf<V, K2>>(
keyPath: [K, K2],
updater: (value: $ValOf<V, K2>) => S
): this;
updateIn<
NSV,
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
S: $ValOf<$ValOf<V, K2>, K3>
>(
keyPath: [K, K2, K3],
notSetValue: NSV,
updater: (value: $ValOf<$ValOf<V, K2>, K3> | NSV) => S
): this;
updateIn<
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
S: $ValOf<$ValOf<V, K2>, K3>
>(
keyPath: [K, K2, K3],
updater: (value: $ValOf<$ValOf<V, K2>, K3>) => S
): this;
updateIn<
NSV,
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,
S: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>
>(
keyPath: [K, K2, K3, K4],
notSetValue: NSV,
updater: (value: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4> | NSV) => S
): this;
updateIn<
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,
S: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>
>(
keyPath: [K, K2, K3, K4],
updater: (value: $ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>) => S
): this;
updateIn<
NSV,
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,
K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>,
S: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>
>(
keyPath: [K, K2, K3, K4, K5],
notSetValue: NSV,
updater: (
value: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5> | NSV
) => S
): this;
updateIn<
K2: $KeyOf<V>,
K3: $KeyOf<$ValOf<V, K2>>,
K4: $KeyOf<$ValOf<$ValOf<V, K2>, K3>>,
K5: $KeyOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>>,
S: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>
>(
keyPath: [K, K2, K3, K4, K5],
updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<V, K2>, K3>, K4>, K5>) => S
): this;
}
declare function isList(maybeList: mixed): boolean %checks(maybeList instanceof
List);
declare class List<+T>
extends IndexedCollection<T>
mixins UpdatableInCollection<number, T>
{
static (collection?: Iterable<T>): List<T>;
static of<T>(...values: T[]): List<T>;
static isList: typeof isList;
size: number;
set<U>(index: number, value: U): List<T | U>;
delete(index: number): this;
remove(index: number): this;
insert<U>(index: number, value: U): List<T | U>;
clear(): this;
push<U>(...values: U[]): List<T | U>;
pop(): this;
unshift<U>(...values: U[]): List<T | U>;
shift(): this;
update<U>(updater: (value: this) => U): U;
update<U>(index: number, updater: (value: T) => U): List<T | U>;
update<U>(
index: number,
notSetValue: U,
updater: (value: T) => U
): List<T | U>;
merge<U>(...collections: Iterable<U>[]): 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>;
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<B>, ..._: []): List<[T, A, B]>;
zip<A, B, C>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): List<[T, A, B, C]>;
zip<A, B, C, D>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): List<[T, A, B, C, D]>;
zip<A, B, C, D, E>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): List<[T, A, B, C, D, E]>;
zipAll<A>(a: Iterable<A>, ..._: []): List<[T | void, A | void]>;
zipAll<A, B>(
a: Iterable<A>,
b: Iterable<B>,
..._: []
): List<[T | void, A | void, B | void]>;
zipAll<A, B, C>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): List<[T | void, A | void, B | void, C | void]>;
zipAll<A, B, C, D>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): List<[T | void, A | void, B | void, C | void, D | void]>;
zipAll<A, B, C, D, E>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): List<[T | void, A | void, B | void, C | void, D | void, E | void]>;
zipWith<A, R>(
zipper: (value: T, a: A) => R,
a: Iterable<A>,
..._: []
): List<R>;
zipWith<A, B, R>(
zipper: (value: T, a: A, b: B) => R,
a: Iterable<A>,
b: Iterable<B>,
..._: []
): List<R>;
zipWith<A, B, C, R>(
zipper: (value: T, a: A, b: B, c: C) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): List<R>;
zipWith<A, B, C, D, R>(
zipper: (value: T, a: A, b: B, c: C, d: D) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): List<R>;
zipWith<A, B, C, D, E, R>(
zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): List<R>;
}
declare 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<U>(updater: (value: this) => U): U;
update<V_>(key: K, updater: (value: V) => V_): Map<K, V | V_>;
update<V_>(
key: K,
notSetValue: V_,
updater: (value: V) => V_
): Map<K, V | V_>;
merge<K_, V_>(
...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
): Map<K | K_, V | V_>;
concat<K_, V_>(
...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
): Map<K | K_, V | V_>;
mergeWith<K_, W, X>(
merger: (oldVal: V, newVal: W, key: K) => X,
...collections: (Iterable<[K_, W]> | PlainObjInput<K_, W>)[]
): Map<K | K_, V | W | X>;
mergeDeep<K_, V_>(
...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
): Map<K | K_, V | V_>;
mergeDeepWith<K_, V_>(
merger: (oldVal: any, newVal: any, key: any) => mixed,
...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
): Map<K | K_, V | V_>;
mergeIn(
keyPath: Iterable<mixed>,
...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
): this;
mergeDeepIn(
keyPath: Iterable<mixed>,
...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
): this;
withMutations(mutator: (mutable: this) => mixed): this;
asMutable(): this;
wasAltered(): boolean;
asImmutable(): this;
// Override specialized return types
flip(): Map<V, K>;
filter(predicate: typeof Boolean): Map<K, $NonMaybeType<V>>;
filter(
predicate: (value: V, key: K, iter: this) => mixed,
context?: mixed
): Map<K, V>;
map<M>(
mapper: (value: V, key: K, iter: this) => M,
context?: mixed
): 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<U>(updater: (value: this) => U): U;
update<V_>(key: K, updater: (value: V) => V_): OrderedMap<K, V | V_>;
update<V_>(
key: K,
notSetValue: V_,
updater: (value: V) => V_
): OrderedMap<K, V | V_>;
merge<K_, V_>(
...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
): OrderedMap<K | K_, V | V_>;
concat<K_, V_>(
...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
): OrderedMap<K | K_, V | V_>;
mergeWith<K_, W, X>(
merger: (oldVal: V, newVal: W, key: K) => X,
...collections: (Iterable<[K_, W]> | PlainObjInput<K_, W>)[]
): OrderedMap<K | K_, V | W | X>;
mergeDeep<K_, V_>(
...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
): OrderedMap<K | K_, V | V_>;
mergeDeepWith<K_, V_>(
merger: (oldVal: any, newVal: any, key: any) => mixed,
...collections: (Iterable<[K_, V_]> | PlainObjInput<K_, V_>)[]
): OrderedMap<K | K_, V | V_>;
mergeIn(
keyPath: Iterable<mixed>,
...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
): this;
mergeDeepIn(
keyPath: Iterable<mixed>,
...collections: (Iterable<mixed> | PlainObjInput<mixed, mixed>)[]
): this;
withMutations(mutator: (mutable: this) => mixed): this;
asMutable(): this;
wasAltered(): boolean;
asImmutable(): this;
// Override specialized return types
flip(): OrderedMap<V, K>;
filter(predicate: typeof Boolean): OrderedMap<K, $NonMaybeType<V>>;
filter(
predicate: (value: V, key: K, iter: this) => mixed,
context?: mixed
): OrderedMap<K, V>;
map<M>(
mapper: (value: V, key: K, iter: this) => M,
context?: mixed
): 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<U>(value: U): Set<T | U>;
delete(value: T): this;
remove(value: T): this;
clear(): this;
union<U>(...collections: Iterable<U>[]): Set<T | U>;
merge<U>(...collections: Iterable<U>[]): Set<T | U>;
concat<U>(...collections: Iterable<U>[]): Set<T | U>;
intersect<U>(...collections: Iterable<U>[]): Set<T & U>;
subtract(...collections: Iterable<mixed>[]): this;
withMutations(mutator: (mutable: this) => mixed): this;
asMutable(): this;
wasAltered(): boolean;
asImmutable(): this;
// Override specialized return types
filter(predicate: typeof Boolean): Set<$NonMaybeType<T>>;
filter(
predicate: (value: T, value: T, iter: this) => mixed,
context?: mixed
): Set<T>;
map<M>(
mapper: (value: T, value: T, iter: this) => M,
context?: mixed
): 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<U>(value: U): OrderedSet<T | U>;
union<U>(...collections: Iterable<U>[]): OrderedSet<T | U>;
merge<U>(...collections: Iterable<U>[]): OrderedSet<T | U>;
concat<U>(...collections: Iterable<U>[]): OrderedSet<T | U>;
intersect<U>(...collections: Iterable<U>[]): OrderedSet<T & U>;
filter(predicate: typeof Boolean): OrderedSet<$NonMaybeType<T>>;
filter(
predicate: (value: T, value: T, iter: this) => mixed,
context?: mixed
): OrderedSet<T>;
map<M>(
mapper: (value: T, value: T, iter: this) => M,
context?: mixed
): OrderedSet<M>;
flatMap<M>(
mapper: (value: T, value: T, iter: this) => Iterable<M>,
context?: mixed
): OrderedSet<M>;
flatten(depth?: number): OrderedSet<any>;
flatten(shallow?: boolean): OrderedSet<any>;
zip<A>(a: Iterable<A>, ..._: []): OrderedSet<[T, A]>;
zip<A, B>(a: Iterable<A>, b: Iterable<B>, ..._: []): OrderedSet<[T, A, B]>;
zip<A, B, C>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): OrderedSet<[T, A, B, C]>;
zip<A, B, C, D>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): OrderedSet<[T, A, B, C, D]>;
zip<A, B, C, D, E>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): OrderedSet<[T, A, B, C, D, E]>;
zipAll<A>(a: Iterable<A>, ..._: []): OrderedSet<[T | void, A | void]>;
zipAll<A, B>(
a: Iterable<A>,
b: Iterable<B>,
..._: []
): OrderedSet<[T | void, A | void, B | void]>;
zipAll<A, B, C>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): OrderedSet<[T | void, A | void, B | void, C | void]>;
zipAll<A, B, C, D>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): OrderedSet<[T | void, A | void, B | void, C | void, D | void]>;
zipAll<A, B, C, D, E>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): OrderedSet<[T | void, A | void, B | void, C | void, D | void, E | void]>;
zipWith<A, R>(
zipper: (value: T, a: A) => R,
a: Iterable<A>,
..._: []
): OrderedSet<R>;
zipWith<A, B, R>(
zipper: (value: T, a: A, b: B) => R,
a: Iterable<A>,
b: Iterable<B>,
..._: []
): OrderedSet<R>;
zipWith<A, B, C, R>(
zipper: (value: T, a: A, b: B, c: C) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): OrderedSet<R>;
zipWith<A, B, C, D, R>(
zipper: (value: T, a: A, b: B, c: C, d: D) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): OrderedSet<R>;
zipWith<A, B, C, D, E, R>(
zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): OrderedSet<R>;
}
declare 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<U>(...values: U[]): Stack<T | U>;
unshiftAll<U>(iter: Iterable<U>): Stack<T | U>;
shift(): this;
push<U>(...values: U[]): Stack<T | U>;
pushAll<U>(iter: Iterable<U>): 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<B>, ..._: []): Stack<[T, A, B]>;
zip<A, B, C>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): Stack<[T, A, B, C]>;
zip<A, B, C, D>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): Stack<[T, A, B, C, D]>;
zip<A, B, C, D, E>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): Stack<[T, A, B, C, D, E]>;
zipAll<A>(a: Iterable<A>, ..._: []): Stack<[T | void, A | void]>;
zipAll<A, B>(
a: Iterable<A>,
b: Iterable<B>,
..._: []
): Stack<[T | void, A | void, B | void]>;
zipAll<A, B, C>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): Stack<[T | void, A | void, B | void, C | void]>;
zipAll<A, B, C, D>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): Stack<[T | void, A | void, B | void, C | void, D | void]>;
zipAll<A, B, C, D, E>(
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): Stack<[T | void, A | void, B | void, C | void, D | void, E | void]>;
zipWith<A, R>(
zipper: (value: T, a: A) => R,
a: Iterable<A>,
..._: []
): Stack<R>;
zipWith<A, B, R>(
zipper: (value: T, a: A, b: B) => R,
a: Iterable<A>,
b: Iterable<B>,
..._: []
): Stack<R>;
zipWith<A, B, C, R>(
zipper: (value: T, a: A, b: B, c: C) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
..._: []
): Stack<R>;
zipWith<A, B, C, D, R>(
zipper: (value: T, a: A, b: B, c: C, d: D) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
..._: []
): Stack<R>;
zipWith<A, B, C, D, E, R>(
zipper: (value: T, a: A, b: B, c: C, d: D, e: E) => R,
a: Iterable<A>,
b: Iterable<B>,
c: Iterable<C>,
d: Iterable<D>,
e: Iterable<E>,
..._: []
): Stack<R>;
}
declare function Range(
start?: number,
end?: number,
step?: number
): IndexedSeq<number>;
declare function Repeat<T>(value: T, times?: number): IndexedSeq<T>;
// 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<U>(
keyPath: [],
notSetValue: mixed,
updater: (value: this & T) => U
): U;
updateIn<U>(keyPath: [], updater: (value: this & T) => U): U;
updateIn<NSV, K: $Keys<T>, S: $ValOf<T, K>>(
keyPath: [K],
notSetValue: NSV,
updater: (value: $ValOf<T, K>) => S
): this & $ReadOnly<T>;
updateIn<K: $Keys<T>, S: $ValOf<T, K>>(
keyPath: [K],
updater: (value: $ValOf<T, K>) => S
): this & $ReadOnly<T>;
updateIn<
NSV,
K: $Keys<T>,
K2: $KeyOf<$ValOf<T, K>>,
S: $ValOf<$ValOf<T, K>, K2>
>(
keyPath: [K, K2],
notSetValue: NSV,
updater: (value: $ValOf<$ValOf<T, K>, K2> | NSV) => S
): this & $ReadOnly<T>;
updateIn<K: $Keys<T>, K2: $KeyOf<$ValOf<T, K>>, S: $ValOf<$ValOf<T, K>, K2>>(
keyPath: [K, K2],
updater: (value: $ValOf<$ValOf<T, K>, K2>) => S
): this & $ReadOnly<T>;
updateIn<
NSV,
K: $Keys<T>,
K2: $KeyOf<$ValOf<T, K>>,
K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>,
S: $ValOf<$ValOf<$ValOf<T, K>, K2>, K3>
>(
keyPath: [K, K2, K3],
notSetValue: NSV,
updater: (value: $ValOf<$ValOf<$ValOf<T, K>, K2>, K3> | NSV) => S
): this & $ReadOnly<T>;
updateIn<
K: $Keys<T>,
K2: $KeyOf<$ValOf<T, K>>,
K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>,
S: $ValOf<$ValOf<$ValOf<T, K>, K2>, K3>
>(
keyPath: [K, K2, K3],
updater: (value: $ValOf<$ValOf<$ValOf<T, K>, K2>, K3>) => S
): this & $ReadOnly<T>;
updateIn<
NSV,
K: $Keys<T>,
K2: $KeyOf<$ValOf<T, K>>,
K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>,
K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>,
S: $ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>
>(
keyPath: [K, K2, K3, K4],
notSetValue: NSV,
updater: (
value: $ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4> | NSV
) => S
): this & $ReadOnly<T>;
updateIn<
K: $Keys<T>,
K2: $KeyOf<$ValOf<T, K>>,
K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>,
K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>,
S: $ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>
>(
keyPath: [K, K2, K3, K4],
updater: (value: $ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>) => S
): this & $ReadOnly<T>;
updateIn<
NSV,
K: $Keys<T>,
K2: $KeyOf<$ValOf<T, K>>,
K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>,
K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>,
K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>>,
S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>, K5>
>(
keyPath: [K, K2, K3, K4, K5],
notSetValue: NSV,
updater: (
value: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>, K5> | NSV
) => S
): this & $ReadOnly<T>;
updateIn<
K: $Keys<T>,
K2: $KeyOf<$ValOf<T, K>>,
K3: $KeyOf<$ValOf<$ValOf<T, K>, K2>>,
K4: $KeyOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>>,
K5: $KeyOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>>,
S: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>, K5>
>(
keyPath: [K, K2, K3, K4, K5],
updater: (
value: $ValOf<$ValOf<$ValOf<$ValOf<$ValOf<T, K>, K2>, K3>, K4>, K5>
) => S
): this & $ReadOnly<T>;
mergeIn(
keyPath: Iterable<mixed>,
...collections: Array<any>
): this & $ReadOnly<T>;
mergeDeepIn(
keyPath: Iterable<mixed>,
...collections: Array<any>
): this & $ReadOnly<T>;
toSeq(): KeyedSeq<$Keys<T>, any>;
toJS(): { [key: $Keys<T>]: mixed };
toJSON(): T;
toObject(): T;
withMutations(mutator: (mutable: this & T) => mixed): this & $ReadOnly<T>;
asMutable(): this & $ReadOnly<T>;
wasAltered(): boolean;
asImmutable(): this & $ReadOnly<T>;
@@iterator(): Iterator<[$Keys<T>, $ValOf<T>]>;
}
declare function fromJS(
jsValue: mixed,
reviver?: (
key: string | number,
sequence: KeyedCollection<string, mixed> | IndexedCollection<mixed>,
path?: Array<string | number>
) => mixed
): 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,
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,
};