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.
2413 lines
61 KiB
2413 lines
61 KiB
/**
|
|
* 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<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?: 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<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>;
|
|
|
|
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<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>;
|
|
|
|
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<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>;
|
|
|
|
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<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>;
|
|
|
|
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<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>;
|
|
|
|
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<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>;
|
|
|
|
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<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>;
|
|
|
|
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<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>;
|
|
|
|
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<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,
|
|
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,
|
|
};
|