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.
2347 lines
60 KiB
2347 lines
60 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 |
|
>; |
|
|
|
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, |
|
};
|
|
|