@fable-org/fable-library-js 2.0.0-beta.3 → 2.0.0-beta.5

package/Map.d.ts

@@ -1,178 +0,0 @@
-import { TypeInfo } from "./Reflection.js";
-import { Option } from "./Option.js";
-import { int32 } from "./Int32.js";
-import { IMap, IEnumerator, IComparer } from "./Util.js";
-import { FSharpList } from "./List.js";
-import { FSharpRef, Record } from "./Types.js";
-export declare class MapTreeLeaf$2<Key, Value> {
-    readonly v: Value;
-    readonly k: Key;
-    constructor(k: Key, v: Value);
-}
-export declare function MapTreeLeaf$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function MapTreeLeaf$2_$ctor_5BDDA1<Key, Value>(k: Key, v: Value): MapTreeLeaf$2<Key, Value>;
-export declare function MapTreeLeaf$2__get_Key<Key, Value>(_: MapTreeLeaf$2<Key, Value>): Key;
-export declare function MapTreeLeaf$2__get_Value<Key, Value>(_: MapTreeLeaf$2<Key, Value>): Value;
-export declare class MapTreeNode$2<Key, Value> extends MapTreeLeaf$2<Key, Value> {
-    readonly right: Option<MapTreeLeaf$2<Key, Value>>;
-    readonly left: Option<MapTreeLeaf$2<Key, Value>>;
-    readonly h: int32;
-    constructor(k: Key, v: Value, left: Option<MapTreeLeaf$2<Key, Value>>, right: Option<MapTreeLeaf$2<Key, Value>>, h: int32);
-}
-export declare function MapTreeNode$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function MapTreeNode$2_$ctor_Z39DE9543<Key, Value>(k: Key, v: Value, left: Option<MapTreeLeaf$2<Key, Value>>, right: Option<MapTreeLeaf$2<Key, Value>>, h: int32): MapTreeNode$2<Key, Value>;
-export declare function MapTreeNode$2__get_Left<Key, Value>(_: MapTreeNode$2<Key, Value>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeNode$2__get_Right<Key, Value>(_: MapTreeNode$2<Key, Value>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeNode$2__get_Height<Key, Value>(_: MapTreeNode$2<Key, Value>): int32;
-export declare function MapTreeModule_empty<Key, Value>(): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_sizeAux<Key, Value>(acc_mut: int32, m_mut: Option<MapTreeLeaf$2<Key, Value>>): int32;
-export declare function MapTreeModule_size<$a, $b>(x: Option<MapTreeLeaf$2<$a, $b>>): int32;
-export declare function MapTreeModule_mk<Key, Value>(l: Option<MapTreeLeaf$2<Key, Value>>, k: Key, v: Value, r: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_rebalance<Key, Value>(t1: Option<MapTreeLeaf$2<Key, Value>>, k: Key, v: Value, t2: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_add<Key, Value>(comparer: IComparer<Key>, k: Key, v: Value, m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_tryFind<Key, Value>(comparer_mut: IComparer<Key>, k_mut: Key, m_mut: Option<MapTreeLeaf$2<Key, Value>>): Option<Value>;
-export declare function MapTreeModule_find<Key, Value>(comparer: IComparer<Key>, k: Key, m: Option<MapTreeLeaf$2<Key, Value>>): Value;
-export declare function MapTreeModule_partition1<Key, $a>(comparer: IComparer<Key>, f: any, k: Key, v: $a, acc1: Option<MapTreeLeaf$2<Key, $a>>, acc2: Option<MapTreeLeaf$2<Key, $a>>): [Option<MapTreeLeaf$2<Key, $a>>, Option<MapTreeLeaf$2<Key, $a>>];
-export declare function MapTreeModule_partitionAux<Key, Value>(comparer_mut: IComparer<Key>, f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>, acc__mut: Option<MapTreeLeaf$2<Key, Value>>, acc__1_mut: Option<MapTreeLeaf$2<Key, Value>>): [Option<MapTreeLeaf$2<Key, Value>>, Option<MapTreeLeaf$2<Key, Value>>];
-export declare function MapTreeModule_partition<Key, $a>(comparer: IComparer<Key>, f: ((arg0: Key, arg1: $a) => boolean), m: Option<MapTreeLeaf$2<Key, $a>>): [Option<MapTreeLeaf$2<Key, $a>>, Option<MapTreeLeaf$2<Key, $a>>];
-export declare function MapTreeModule_filter1<Key, $a>(comparer: IComparer<Key>, f: any, k: Key, v: $a, acc: Option<MapTreeLeaf$2<Key, $a>>): Option<MapTreeLeaf$2<Key, $a>>;
-export declare function MapTreeModule_filterAux<Key, Value>(comparer_mut: IComparer<Key>, f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>, acc_mut: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_filter<Key, $a>(comparer: IComparer<Key>, f: ((arg0: Key, arg1: $a) => boolean), m: Option<MapTreeLeaf$2<Key, $a>>): Option<MapTreeLeaf$2<Key, $a>>;
-export declare function MapTreeModule_spliceOutSuccessor<Key, Value>(m: Option<MapTreeLeaf$2<Key, Value>>): [Key, Value, Option<MapTreeLeaf$2<Key, Value>>];
-export declare function MapTreeModule_remove<Key, Value>(comparer: IComparer<Key>, k: Key, m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_change<Key, Value>(comparer: IComparer<Key>, k: Key, u: ((arg0: Option<Value>) => Option<Value>), m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_mem<Key, Value>(comparer_mut: IComparer<Key>, k_mut: Key, m_mut: Option<MapTreeLeaf$2<Key, Value>>): boolean;
-export declare function MapTreeModule_iterOpt<Key, Value>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>): void;
-export declare function MapTreeModule_iter<$a, $b>(f: ((arg0: $a, arg1: $b) => void), m: Option<MapTreeLeaf$2<$a, $b>>): void;
-export declare function MapTreeModule_tryPickOpt<Key, Value, $a>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>): Option<$a>;
-export declare function MapTreeModule_tryPick<$a, $b, $c>(f: ((arg0: $a, arg1: $b) => Option<$c>), m: Option<MapTreeLeaf$2<$a, $b>>): Option<$c>;
-export declare function MapTreeModule_existsOpt<Key, Value>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>): boolean;
-export declare function MapTreeModule_exists<$a, $b>(f: ((arg0: $a, arg1: $b) => boolean), m: Option<MapTreeLeaf$2<$a, $b>>): boolean;
-export declare function MapTreeModule_forallOpt<Key, Value>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>): boolean;
-export declare function MapTreeModule_forall<$a, $b>(f: ((arg0: $a, arg1: $b) => boolean), m: Option<MapTreeLeaf$2<$a, $b>>): boolean;
-export declare function MapTreeModule_map<Value, Result, Key>(f: ((arg0: Value) => Result), m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Result>>;
-export declare function MapTreeModule_mapiOpt<Key, Value, Result>(f: any, m: Option<MapTreeLeaf$2<Key, Value>>): Option<MapTreeLeaf$2<Key, Result>>;
-export declare function MapTreeModule_mapi<$a, $b, $c>(f: ((arg0: $a, arg1: $b) => $c), m: Option<MapTreeLeaf$2<$a, $b>>): Option<MapTreeLeaf$2<$a, $c>>;
-export declare function MapTreeModule_foldBackOpt<Key, Value, $a>(f_mut: any, m_mut: Option<MapTreeLeaf$2<Key, Value>>, x_mut: $a): $a;
-export declare function MapTreeModule_foldBack<$a, $b, $c>(f: ((arg0: $a, arg1: $b, arg2: $c) => $c), m: Option<MapTreeLeaf$2<$a, $b>>, x: $c): $c;
-export declare function MapTreeModule_foldOpt<$a, Key, Value>(f_mut: any, x_mut: $a, m_mut: Option<MapTreeLeaf$2<Key, Value>>): $a;
-export declare function MapTreeModule_fold<$a, $b, $c>(f: ((arg0: $a, arg1: $b, arg2: $c) => $a), x: $a, m: Option<MapTreeLeaf$2<$b, $c>>): $a;
-export declare function MapTreeModule_foldSectionOpt<Key, Value, a>(comparer: IComparer<Key>, lo: Key, hi: Key, f: any, m: Option<MapTreeLeaf$2<Key, Value>>, x: a): a;
-export declare function MapTreeModule_foldSection<Key, $a, $b>(comparer: IComparer<Key>, lo: Key, hi: Key, f: ((arg0: Key, arg1: $a, arg2: $b) => $b), m: Option<MapTreeLeaf$2<Key, $a>>, x: $b): $b;
-export declare function MapTreeModule_toList<Key, Value>(m: Option<MapTreeLeaf$2<Key, Value>>): FSharpList<[Key, Value]>;
-export declare function MapTreeModule_copyToArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>, arr: [$a, $b][], i: int32): void;
-export declare function MapTreeModule_toArray<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>): [$a, $b][];
-export declare function MapTreeModule_ofList<$a, $b>(comparer: IComparer<$a>, l: FSharpList<[$a, $b]>): Option<MapTreeLeaf$2<$a, $b>>;
-export declare function MapTreeModule_mkFromEnumerator<$a, $b>(comparer_mut: IComparer<$a>, acc_mut: Option<MapTreeLeaf$2<$a, $b>>, e_mut: IEnumerator<[$a, $b]>): Option<MapTreeLeaf$2<$a, $b>>;
-export declare function MapTreeModule_ofArray<Key, Value>(comparer: IComparer<Key>, arr: [Key, Value][]): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function MapTreeModule_ofSeq<Key, Value>(comparer: IComparer<Key>, c: Iterable<[Key, Value]>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare class MapTreeModule_MapIterator$2<Key, Value> extends Record {
-    stack: FSharpList<Option<MapTreeLeaf$2<Key, Value>>>;
-    started: boolean;
-    constructor(stack: FSharpList<Option<MapTreeLeaf$2<Key, Value>>>, started: boolean);
-}
-export declare function MapTreeModule_MapIterator$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function MapTreeModule_collapseLHS<Key, Value>(stack_mut: FSharpList<Option<MapTreeLeaf$2<Key, Value>>>): FSharpList<Option<MapTreeLeaf$2<Key, Value>>>;
-export declare function MapTreeModule_mkIterator<$a, $b>(m: Option<MapTreeLeaf$2<$a, $b>>): MapTreeModule_MapIterator$2<$a, $b>;
-export declare function MapTreeModule_notStarted<$a>(): $a;
-export declare function MapTreeModule_alreadyFinished<$a>(): $a;
-export declare function MapTreeModule_current<Key, Value>(i: MapTreeModule_MapIterator$2<Key, Value>): [Key, Value];
-export declare function MapTreeModule_moveNext<Key, Value>(i: MapTreeModule_MapIterator$2<Key, Value>): boolean;
-export declare function MapTreeModule_mkIEnumerator<a, b>(m: Option<MapTreeLeaf$2<a, b>>): IEnumerator<[a, b]>;
-export declare function MapTreeModule_toSeq<$a, $b>(s: Option<MapTreeLeaf$2<$a, $b>>): Iterable<[$a, $b]>;
-export declare function MapTreeModule_leftmost<Key, Value>(m_mut: Option<MapTreeLeaf$2<Key, Value>>): [Key, Value];
-export declare function MapTreeModule_rightmost<Key, Value>(m_mut: Option<MapTreeLeaf$2<Key, Value>>): [Key, Value];
-export declare class FSharpMap<Key, Value> implements IMap<Key, Value>, Iterable<[Key, Value]>, Iterable<[Key, Value]> {
-    readonly tree: Option<MapTreeLeaf$2<Key, Value>>;
-    readonly comparer: IComparer<Key>;
-    constructor(comparer: IComparer<Key>, tree: Option<MapTreeLeaf$2<Key, Value>>);
-    GetHashCode(): int32;
-    Equals(that: any): boolean;
-    toString(): string;
-    get [Symbol.toStringTag](): string;
-    toJSON(): any;
-    GetEnumerator(): IEnumerator<[Key, Value]>;
-    [Symbol.iterator](): Iterator<[Key, Value]>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-    CompareTo(obj: any): int32;
-    "System.Collections.Generic.ICollection`1.Add2B595"(x: [Key, Value]): void;
-    "System.Collections.Generic.ICollection`1.Clear"(): void;
-    "System.Collections.Generic.ICollection`1.Remove2B595"(x: [Key, Value]): boolean;
-    "System.Collections.Generic.ICollection`1.Contains2B595"(x: [Key, Value]): boolean;
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(arr: [Key, Value][], i: int32): void;
-    "System.Collections.Generic.ICollection`1.get_IsReadOnly"(): boolean;
-    "System.Collections.Generic.ICollection`1.get_Count"(): int32;
-    "System.Collections.Generic.IReadOnlyCollection`1.get_Count"(): int32;
-    get size(): int32;
-    clear(): void;
-    delete(_arg: Key): boolean;
-    entries(): Iterable<[Key, Value]>;
-    get(k: Key): Value;
-    has(k: Key): boolean;
-    keys(): Iterable<Key>;
-    set(k: Key, v: Value): IMap<Key, Value>;
-    values(): Iterable<Value>;
-    forEach(f: ((arg0: Value, arg1: Key, arg2: IMap<Key, Value>) => void), thisArg?: Option<any>): void;
-}
-export declare function FSharpMap_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function FSharpMap_$ctor<Key, Value>(comparer: IComparer<Key>, tree: Option<MapTreeLeaf$2<Key, Value>>): FSharpMap<Key, Value>;
-export declare function FSharpMap_Empty<Key, Value>(comparer: IComparer<Key>): FSharpMap<Key, Value>;
-export declare function FSharpMap__get_Comparer<Key, Value>(m: FSharpMap<Key, Value>): IComparer<Key>;
-export declare function FSharpMap__get_Tree<Key, Value>(m: FSharpMap<Key, Value>): Option<MapTreeLeaf$2<Key, Value>>;
-export declare function FSharpMap__Add<Key, Value>(m: FSharpMap<Key, Value>, key: Key, value: Value): FSharpMap<Key, Value>;
-export declare function FSharpMap__Change<Key, Value>(m: FSharpMap<Key, Value>, key: Key, f: ((arg0: Option<Value>) => Option<Value>)): FSharpMap<Key, Value>;
-export declare function FSharpMap__get_IsEmpty<Key, Value>(m: FSharpMap<Key, Value>): boolean;
-export declare function FSharpMap__get_Item<Key, Value>(m: FSharpMap<Key, Value>, key: Key): Value;
-export declare function FSharpMap__TryPick<Key, Value, $a>(m: FSharpMap<Key, Value>, f: ((arg0: Key, arg1: Value) => Option<$a>)): Option<$a>;
-export declare function FSharpMap__Exists<Key, Value>(m: FSharpMap<Key, Value>, predicate: ((arg0: Key, arg1: Value) => boolean)): boolean;
-export declare function FSharpMap__Filter<Key, Value>(m: FSharpMap<Key, Value>, predicate: ((arg0: Key, arg1: Value) => boolean)): FSharpMap<Key, Value>;
-export declare function FSharpMap__ForAll<Key, Value>(m: FSharpMap<Key, Value>, predicate: ((arg0: Key, arg1: Value) => boolean)): boolean;
-export declare function FSharpMap__Fold<Key, Value, $a>(m: FSharpMap<Key, Value>, f: ((arg0: Key, arg1: Value, arg2: $a) => $a), acc: $a): $a;
-export declare function FSharpMap__FoldSection<Key, Value, z>(m: FSharpMap<Key, Value>, lo: Key, hi: Key, f: ((arg0: Key, arg1: Value, arg2: z) => z), acc: z): z;
-export declare function FSharpMap__Iterate<Key, Value>(m: FSharpMap<Key, Value>, f: ((arg0: Key, arg1: Value) => void)): void;
-export declare function FSharpMap__MapRange<Key, Value, Result>(m: FSharpMap<Key, Value>, f: ((arg0: Value) => Result)): FSharpMap<Key, Result>;
-export declare function FSharpMap__Map<Key, Value, b>(m: FSharpMap<Key, Value>, f: ((arg0: Key, arg1: Value) => b)): FSharpMap<Key, b>;
-export declare function FSharpMap__Partition<Key, Value>(m: FSharpMap<Key, Value>, predicate: ((arg0: Key, arg1: Value) => boolean)): [FSharpMap<Key, Value>, FSharpMap<Key, Value>];
-export declare function FSharpMap__get_Count<Key, Value>(m: FSharpMap<Key, Value>): int32;
-export declare function FSharpMap__ContainsKey<Key, Value>(m: FSharpMap<Key, Value>, key: Key): boolean;
-export declare function FSharpMap__Remove<Key, Value>(m: FSharpMap<Key, Value>, key: Key): FSharpMap<Key, Value>;
-export declare function FSharpMap__TryGetValue<Key, Value>(_: FSharpMap<Key, Value>, key: Key, value: FSharpRef<Value>): boolean;
-export declare function FSharpMap__get_Keys<Key, Value>(_: FSharpMap<Key, Value>): Iterable<Key>;
-export declare function FSharpMap__get_Values<Key, Value>(_: FSharpMap<Key, Value>): Iterable<Value>;
-export declare function FSharpMap__get_MinKeyValue<Key, Value>(m: FSharpMap<Key, Value>): [Key, Value];
-export declare function FSharpMap__get_MaxKeyValue<Key, Value>(m: FSharpMap<Key, Value>): [Key, Value];
-export declare function FSharpMap__TryFind<Key, Value>(m: FSharpMap<Key, Value>, key: Key): Option<Value>;
-export declare function FSharpMap__ToList<Key, Value>(m: FSharpMap<Key, Value>): FSharpList<[Key, Value]>;
-export declare function FSharpMap__ToArray<Key, Value>(m: FSharpMap<Key, Value>): [Key, Value][];
-export declare function FSharpMap__ComputeHashCode<Key, Value>(this$: FSharpMap<Key, Value>): int32;
-export declare function isEmpty<$a, $b>(table: FSharpMap<$a, $b>): boolean;
-export declare function add<$a, $b>(key: $a, value: $b, table: FSharpMap<$a, $b>): FSharpMap<$a, $b>;
-export declare function change<$a, $b>(key: $a, f: ((arg0: Option<$b>) => Option<$b>), table: FSharpMap<$a, $b>): FSharpMap<$a, $b>;
-export declare function find<$a, $b>(key: $a, table: FSharpMap<$a, $b>): $b;
-export declare function tryFind<$a, $b>(key: $a, table: FSharpMap<$a, $b>): Option<$b>;
-export declare function remove<$a, $b>(key: $a, table: FSharpMap<$a, $b>): FSharpMap<$a, $b>;
-export declare function containsKey<$a, $b>(key: $a, table: FSharpMap<$a, $b>): boolean;
-export declare function iterate<$a, $b>(action: ((arg0: $a, arg1: $b) => void), table: FSharpMap<$a, $b>): void;
-export declare function tryPick<$a, $b, $c>(chooser: ((arg0: $a, arg1: $b) => Option<$c>), table: FSharpMap<$a, $b>): Option<$c>;
-export declare function pick<$a, $b, $c>(chooser: ((arg0: $a, arg1: $b) => Option<$c>), table: FSharpMap<$a, $b>): $c;
-export declare function exists<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): boolean;
-export declare function filter<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): FSharpMap<$a, $b>;
-export declare function partition<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): [FSharpMap<$a, $b>, FSharpMap<$a, $b>];
-export declare function forAll<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): boolean;
-export declare function map<$a, $b, $c>(mapping: ((arg0: $a, arg1: $b) => $c), table: FSharpMap<$a, $b>): FSharpMap<$a, $c>;
-export declare function fold<Key, T, State>(folder: ((arg0: State, arg1: Key, arg2: T) => State), state: State, table: FSharpMap<Key, T>): State;
-export declare function foldBack<Key, T, State>(folder: ((arg0: Key, arg1: T, arg2: State) => State), table: FSharpMap<Key, T>, state: State): State;
-export declare function toSeq<$a, $b>(table: FSharpMap<$a, $b>): Iterable<[$a, $b]>;
-export declare function findKey<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): $a;
-export declare function tryFindKey<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), table: FSharpMap<$a, $b>): Option<$a>;
-export declare function ofList<Key, Value>(elements: FSharpList<[Key, Value]>, comparer: IComparer<Key>): FSharpMap<Key, Value>;
-export declare function ofSeq<T, $a>(elements: Iterable<[T, $a]>, comparer: IComparer<T>): FSharpMap<T, $a>;
-export declare function ofArray<Key, Value>(elements: [Key, Value][], comparer: IComparer<Key>): FSharpMap<Key, Value>;
-export declare function toList<$a, $b>(table: FSharpMap<$a, $b>): FSharpList<[$a, $b]>;
-export declare function toArray<$a, $b>(table: FSharpMap<$a, $b>): [$a, $b][];
-export declare function keys<K, V>(table: FSharpMap<K, V>): Iterable<K>;
-export declare function values<K, V>(table: FSharpMap<K, V>): Iterable<V>;
-export declare function minKeyValue<$a, $b>(table: FSharpMap<$a, $b>): [$a, $b];
-export declare function maxKeyValue<$a, $b>(table: FSharpMap<$a, $b>): [$a, $b];
-export declare function empty<Key, Value>(comparer: IComparer<Key>): FSharpMap<Key, Value>;
-export declare function count<$a, $b>(table: FSharpMap<$a, $b>): int32;

package/MapUtil.d.ts

@@ -1,12 +0,0 @@
-import { IMap, IMapOrWeakMap, ISet } from "./Util.js";
-import { FSharpRef } from "./Types.js";
-export declare function keyValueList(fields: Iterable<any>, caseRule?: number): {
-    [k: string]: any;
-};
-export declare function containsValue<K, V>(v: V, map: IMap<K, V>): boolean;
-export declare function tryGetValue<K, V>(map: IMapOrWeakMap<K, V>, key: K, defaultValue: FSharpRef<V>): boolean;
-export declare function addToSet<T>(v: T, set: ISet<T>): boolean;
-export declare function tryAddToDict<K, V>(dict: IMapOrWeakMap<K, V>, k: K, v: V): boolean;
-export declare function addToDict<K, V>(dict: IMapOrWeakMap<K, V>, k: K, v: V): void;
-export declare function getItemFromDict<K, V>(map: IMap<K, V>, key: K): V;
-export declare function getItemFromDictOrCreate<K, V>(map: IMapOrWeakMap<K, V>, key: K, createValue: (key: K) => V): V;

package/MutableMap.d.ts

@@ -1,52 +0,0 @@
-import { IEqualityComparer, IMap, IEnumerator } from "./Util.js";
-import { Option } from "./Option.js";
-import { int32 } from "./Int32.js";
-import { FSharpRef } from "./Types.js";
-import { TypeInfo } from "./Reflection.js";
-export declare class Dictionary<Key, Value> implements IMap<Key, Value>, Iterable<[Key, Value]>, Iterable<[Key, Value]> {
-    readonly comparer: IEqualityComparer<Key>;
-    readonly hashMap: IMap<int32, [Key, Value][]>;
-    "init@9": int32;
-    constructor(pairs: Iterable<[Key, Value]>, comparer: IEqualityComparer<Key>);
-    get [Symbol.toStringTag](): string;
-    toJSON(): any;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-    GetEnumerator(): IEnumerator<[Key, Value]>;
-    [Symbol.iterator](): Iterator<[Key, Value]>;
-    "System.Collections.Generic.ICollection`1.Add2B595"(item: [Key, Value]): void;
-    "System.Collections.Generic.ICollection`1.Clear"(): void;
-    "System.Collections.Generic.ICollection`1.Contains2B595"(item: [Key, Value]): boolean;
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: [Key, Value][], arrayIndex: int32): void;
-    "System.Collections.Generic.ICollection`1.get_Count"(): int32;
-    "System.Collections.Generic.ICollection`1.get_IsReadOnly"(): boolean;
-    "System.Collections.Generic.ICollection`1.Remove2B595"(item: [Key, Value]): boolean;
-    "System.Collections.Generic.IDictionary`2.Add5BDDA1"(key: Key, value: Value): void;
-    "System.Collections.Generic.IDictionary`2.ContainsKey2B595"(key: Key): boolean;
-    "System.Collections.Generic.IDictionary`2.get_Item2B595"(key: Key): Value;
-    "System.Collections.Generic.IDictionary`2.set_Item5BDDA1"(key: Key, v: Value): void;
-    "System.Collections.Generic.IDictionary`2.get_Keys"(): Iterable<Key>;
-    "System.Collections.Generic.IDictionary`2.Remove2B595"(key: Key): boolean;
-    "System.Collections.Generic.IDictionary`2.TryGetValue6DC89625"(key: Key, value: FSharpRef<Value>): boolean;
-    "System.Collections.Generic.IDictionary`2.get_Values"(): Iterable<Value>;
-    get size(): int32;
-    clear(): void;
-    delete(k: Key): boolean;
-    entries(): Iterable<[Key, Value]>;
-    get(k: Key): Value;
-    has(k: Key): boolean;
-    keys(): Iterable<Key>;
-    set(k: Key, v: Value): IMap<Key, Value>;
-    values(): Iterable<Value>;
-    forEach(f: ((arg0: Value, arg1: Key, arg2: IMap<Key, Value>) => void), thisArg?: Option<any>): void;
-}
-export declare function Dictionary_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function Dictionary_$ctor_6623D9B3<Key, Value>(pairs: Iterable<[Key, Value]>, comparer: IEqualityComparer<Key>): Dictionary<Key, Value>;
-export declare function Dictionary__TryFind_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): Option<[Key, Value]>;
-export declare function Dictionary__get_Comparer<Key, Value>(this$: Dictionary<Key, Value>): IEqualityComparer<Key>;
-export declare function Dictionary__Clear<Key, Value>(this$: Dictionary<Key, Value>): void;
-export declare function Dictionary__get_Count<Key, Value>(this$: Dictionary<Key, Value>): int32;
-export declare function Dictionary__get_Item_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): Value;
-export declare function Dictionary__set_Item_5BDDA1<Key, Value>(this$: Dictionary<Key, Value>, k: Key, v: Value): void;
-export declare function Dictionary__Add_5BDDA1<Key, Value>(this$: Dictionary<Key, Value>, k: Key, v: Value): void;
-export declare function Dictionary__ContainsKey_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): boolean;
-export declare function Dictionary__Remove_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): boolean;

package/MutableSet.d.ts

@@ -1,39 +0,0 @@
-import { IMap, IEqualityComparer, ISet, IEnumerator } from "./Util.js";
-import { int32 } from "./Int32.js";
-import { Option } from "./Option.js";
-import { TypeInfo } from "./Reflection.js";
-export declare class HashSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
-    readonly comparer: IEqualityComparer<T>;
-    readonly hashMap: IMap<int32, T[]>;
-    "init@9": int32;
-    constructor(items: Iterable<T>, comparer: IEqualityComparer<T>);
-    get [Symbol.toStringTag](): string;
-    toJSON(): any;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.Generic.ICollection`1.Add2B595"(item: T): void;
-    "System.Collections.Generic.ICollection`1.Clear"(): void;
-    "System.Collections.Generic.ICollection`1.Contains2B595"(item: T): boolean;
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: T[], arrayIndex: int32): void;
-    "System.Collections.Generic.ICollection`1.get_Count"(): int32;
-    "System.Collections.Generic.ICollection`1.get_IsReadOnly"(): boolean;
-    "System.Collections.Generic.ICollection`1.Remove2B595"(item: T): boolean;
-    get size(): int32;
-    add(k: T): ISet<T>;
-    clear(): void;
-    delete(k: T): boolean;
-    has(k: T): boolean;
-    keys(): Iterable<T>;
-    values(): Iterable<T>;
-    entries(): Iterable<[T, T]>;
-    forEach(f: ((arg0: T, arg1: T, arg2: ISet<T>) => void), thisArg?: Option<any>): void;
-}
-export declare function HashSet_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function HashSet_$ctor_Z6150332D<T>(items: Iterable<T>, comparer: IEqualityComparer<T>): HashSet<T>;
-export declare function HashSet__get_Comparer<T>(this$: HashSet<T>): IEqualityComparer<T>;
-export declare function HashSet__Clear<T>(this$: HashSet<T>): void;
-export declare function HashSet__get_Count<T>(this$: HashSet<T>): int32;
-export declare function HashSet__Add_2B595<T>(this$: HashSet<T>, k: T): boolean;
-export declare function HashSet__Contains_2B595<T>(this$: HashSet<T>, k: T): boolean;
-export declare function HashSet__Remove_2B595<T>(this$: HashSet<T>, k: T): boolean;

package/Native.d.ts

@@ -1,2 +0,0 @@
-import { int32 } from "./Int32.js";
-export declare function Helpers_allocateArrayFromCons<T>(cons: any, len: int32): T[];

package/Numeric.d.ts

@@ -1,20 +0,0 @@
-import { IComparable } from "./Util.js";
-export declare const symbol: unique symbol;
-export interface CustomNumeric extends IComparable<Numeric> {
-    [symbol](): {
-        multiply(y: Numeric): Numeric;
-        toPrecision(sd?: number): string;
-        toExponential(dp?: number): string;
-        toFixed(dp?: number): string;
-        toHex(): string;
-    };
-}
-export type Numeric = number | bigint | CustomNumeric;
-export declare function isNumeric(x: any): any;
-export declare function isIntegral(x: Numeric): boolean;
-export declare function compare(x: Numeric, y: number): number;
-export declare function multiply(x: Numeric, y: number): Numeric;
-export declare function toFixed(x: Numeric, dp?: number): string;
-export declare function toPrecision(x: Numeric, sd?: number): string;
-export declare function toExponential(x: Numeric, dp?: number): string | bigint;
-export declare function toHex(x: Numeric): string;

package/Observable.d.ts

@@ -1,32 +0,0 @@
-import { FSharpChoice$2_$union } from "./Choice.js";
-import { Option } from "./Option.js";
-import { IDisposable } from "./Util.js";
-export interface IObserver<T> {
-    OnNext: (x: T) => void;
-    OnError: (e: any) => void;
-    OnCompleted: () => void;
-}
-export declare class Observer<T> implements IObserver<T> {
-    OnNext: (x: T) => void;
-    OnError: (e: any) => void;
-    OnCompleted: () => void;
-    constructor(onNext: (x: T) => void, onError?: (e: any) => void, onCompleted?: () => void);
-}
-export interface IObservable<T> {
-    Subscribe: (o: IObserver<T>) => IDisposable;
-}
-declare class Observable<T> implements IObservable<T> {
-    Subscribe: (o: IObserver<T>) => IDisposable;
-    constructor(subscribe: (o: IObserver<T>) => IDisposable);
-}
-export declare function add<T>(callback: (x: T) => void, source: IObservable<T>): void;
-export declare function choose<T, U>(chooser: (x: T) => Option<U>, source: IObservable<T>): Observable<U>;
-export declare function filter<T>(predicate: (x: T) => boolean, source: IObservable<T>): IObservable<T>;
-export declare function map<T, U>(mapping: (x: T) => U, source: IObservable<T>): IObservable<U>;
-export declare function merge<T>(source1: IObservable<T>, source2: IObservable<T>): IObservable<T>;
-export declare function pairwise<T>(source: IObservable<T>): IObservable<[T, T]>;
-export declare function partition<T>(predicate: (x: T) => boolean, source: IObservable<T>): [Observable<T>, Observable<T>];
-export declare function scan<U, T>(collector: (u: U, t: T) => U, state: U, source: IObservable<T>): IObservable<U>;
-export declare function split<T, U1, U2>(splitter: (x: T) => FSharpChoice$2_$union<U1, U2>, source: IObservable<T>): [Observable<U1>, Observable<U2>];
-export declare function subscribe<T>(callback: (x: T) => void, source: IObservable<T>): IDisposable;
-export {};

package/Option.d.ts

@@ -1,28 +0,0 @@
-export type Nullable<T> = T | null | undefined;
-export type Option<T> = T | Some<T> | undefined;
-export declare class Some<T> {
-    value: T;
-    constructor(value: T);
-    toJSON(): T;
-    toString(): string;
-    GetHashCode(): number;
-    Equals(other: Option<T>): boolean;
-    CompareTo(other: Option<T>): number;
-}
-export declare function value<T>(x: Option<T>): T;
-export declare function unwrap<T>(opt: Option<T>): T | undefined;
-export declare function some<T>(x: T): Option<T>;
-export declare function ofNullable<T>(x: Nullable<T>): Option<T>;
-export declare function toNullable<T>(x: Option<T>): Nullable<T>;
-export declare function flatten<T>(x: Option<Option<T>>): T | Some<T> | undefined;
-export declare function toArray<T>(opt: Option<T>): T[];
-export declare function defaultArg<T>(opt: Option<T>, defaultValue: T): T;
-export declare function defaultArgWith<T>(opt: Option<T>, defThunk: () => T): T;
-export declare function orElse<T>(opt: Option<T>, ifNone: Option<T>): Option<T>;
-export declare function orElseWith<T>(opt: Option<T>, ifNoneThunk: () => Option<T>): Option<T>;
-export declare function filter<T>(predicate: (arg: T) => boolean, opt: Option<T>): Option<T>;
-export declare function map<T, U>(mapping: (arg: T) => U, opt: Option<T>): Option<U>;
-export declare function map2<T1, T2, U>(mapping: (arg1: T1, arg2: T2) => Option<U>, opt1: Option<T1>, opt2: Option<T2>): Option<U>;
-export declare function map3<T1, T2, T3, U>(mapping: (arg1: T1, arg2: T2, arg3: T3) => Option<U>, opt1: Option<T1>, opt2: Option<T2>, opt3: Option<T3>): Option<U>;
-export declare function bind<T, U>(binder: (arg: T) => Option<U>, opt: Option<T>): Option<U>;
-export declare function tryOp<T, U>(op: (x: T) => U, arg: T): Option<U>;

package/Random.d.ts

@@ -1,37 +0,0 @@
-import { uint8, int32, float64 } from "./Int32.js";
-import { TypeInfo } from "./Reflection.js";
-export interface IRandom {
-    Next0(): int32;
-    Next1(maxValue: int32): int32;
-    Next2(minValue: int32, maxValue: int32): int32;
-    NextBytes(buffer: uint8[]): void;
-    NextDouble(): float64;
-}
-export declare class NonSeeded implements IRandom {
-    constructor();
-    Next0(): int32;
-    Next1(maxValue: int32): int32;
-    Next2(minValue: int32, maxValue: int32): int32;
-    NextDouble(): float64;
-    NextBytes(buffer: uint8[]): void;
-}
-export declare function NonSeeded_$reflection(): TypeInfo;
-export declare function NonSeeded_$ctor(): NonSeeded;
-export declare class Seeded implements IRandom {
-    readonly MBIG: int32;
-    inext: int32;
-    inextp: int32;
-    seedArray: int32[];
-    constructor(seed: int32);
-    Next0(): int32;
-    Next1(maxValue: int32): int32;
-    Next2(minValue: int32, maxValue: int32): int32;
-    NextDouble(): float64;
-    NextBytes(buffer: uint8[]): void;
-}
-export declare function Seeded_$reflection(): TypeInfo;
-export declare function Seeded_$ctor_Z524259A4(seed: int32): Seeded;
-export declare function Seeded__Sample(this$: Seeded): float64;
-export declare function Seeded__GetSampleForLargeRange(this$: Seeded): float64;
-export declare function nonSeeded(): NonSeeded;
-export declare function seeded(seed: int32): Seeded;

package/Range.d.ts

@@ -1,12 +0,0 @@
-import { float64 } from "./Int32.js";
-import { Option } from "./Option.js";
-import { uint64, int64 } from "./BigInt.js";
-import { decimal } from "./Decimal.js";
-export declare function makeRangeStepFunction<T>(step: T, stop: T, zero: T, add: ((arg0: T, arg1: T) => T)): ((arg0: T) => Option<[T, T]>);
-export declare function integralRangeStep<T>(start: T, step: T, stop: T, zero: T, add: ((arg0: T, arg1: T) => T)): Iterable<T>;
-export declare function rangeBigInt(start: bigint, step: bigint, stop: bigint): Iterable<bigint>;
-export declare function rangeDecimal(start: decimal, step: decimal, stop: decimal): Iterable<decimal>;
-export declare function rangeDouble(start: float64, step: float64, stop: float64): Iterable<float64>;
-export declare function rangeInt64(start: int64, step: int64, stop: int64): Iterable<int64>;
-export declare function rangeUInt64(start: uint64, step: uint64, stop: uint64): Iterable<uint64>;
-export declare function rangeChar(start: string, stop: string): Iterable<string>;

package/Reflection.d.ts

@@ -1,119 +0,0 @@
-import { FSharpRef } from "./Types.js";
-import { IEquatable } from "./Util.js";
-export type FieldInfo = [string, TypeInfo];
-export type PropertyInfo = FieldInfo;
-export type ParameterInfo = FieldInfo;
-export type Constructor = new (...args: any[]) => any;
-export declare class CaseInfo {
-    declaringType: TypeInfo;
-    tag: number;
-    name: string;
-    fields?: FieldInfo[] | undefined;
-    constructor(declaringType: TypeInfo, tag: number, name: string, fields?: FieldInfo[] | undefined);
-}
-export type EnumCase = [string, number];
-export declare class MethodInfo {
-    name: string;
-    parameters: ParameterInfo[];
-    returnType: TypeInfo;
-    constructor(name: string, parameters: ParameterInfo[], returnType: TypeInfo);
-}
-export declare class TypeInfo implements IEquatable<TypeInfo> {
-    fullname: string;
-    generics?: TypeInfo[] | undefined;
-    construct?: Constructor | undefined;
-    parent?: TypeInfo | undefined;
-    fields?: (() => FieldInfo[]) | undefined;
-    cases?: (() => CaseInfo[]) | undefined;
-    enumCases?: EnumCase[] | undefined;
-    constructor(fullname: string, generics?: TypeInfo[] | undefined, construct?: Constructor | undefined, parent?: TypeInfo | undefined, fields?: (() => FieldInfo[]) | undefined, cases?: (() => CaseInfo[]) | undefined, enumCases?: EnumCase[] | undefined);
-    toString(): string;
-    GetHashCode(): number;
-    Equals(other: TypeInfo): boolean;
-}
-export declare class GenericParameter extends TypeInfo {
-    constructor(name: string);
-}
-export declare function getGenerics(t: TypeInfo): TypeInfo[];
-export declare function getHashCode(t: TypeInfo): number;
-export declare function equals(t1: TypeInfo, t2: TypeInfo): boolean;
-export declare function class_type(fullname: string, generics?: TypeInfo[], construct?: Constructor, parent?: TypeInfo): TypeInfo;
-export declare function record_type(fullname: string, generics: TypeInfo[], construct: Constructor, fields: () => FieldInfo[]): TypeInfo;
-export declare function anonRecord_type(...fields: FieldInfo[]): TypeInfo;
-export declare function union_type(fullname: string, generics: TypeInfo[], construct: Constructor, cases: () => FieldInfo[][]): TypeInfo;
-export declare function tuple_type(...generics: TypeInfo[]): TypeInfo;
-export declare function delegate_type(...generics: TypeInfo[]): TypeInfo;
-export declare function lambda_type(argType: TypeInfo, returnType: TypeInfo): TypeInfo;
-export declare function option_type(generic: TypeInfo): TypeInfo;
-export declare function list_type(generic: TypeInfo): TypeInfo;
-export declare function array_type(generic: TypeInfo): TypeInfo;
-export declare function enum_type(fullname: string, underlyingType: TypeInfo, enumCases: EnumCase[]): TypeInfo;
-export declare function measure_type(fullname: string): TypeInfo;
-export declare function generic_type(name: string): TypeInfo;
-export declare const obj_type: TypeInfo;
-export declare const unit_type: TypeInfo;
-export declare const char_type: TypeInfo;
-export declare const string_type: TypeInfo;
-export declare const bool_type: TypeInfo;
-export declare const int8_type: TypeInfo;
-export declare const uint8_type: TypeInfo;
-export declare const int16_type: TypeInfo;
-export declare const uint16_type: TypeInfo;
-export declare const int32_type: TypeInfo;
-export declare const uint32_type: TypeInfo;
-export declare const int64_type: TypeInfo;
-export declare const uint64_type: TypeInfo;
-export declare const int128_type: TypeInfo;
-export declare const uint128_type: TypeInfo;
-export declare const nativeint_type: TypeInfo;
-export declare const unativeint_type: TypeInfo;
-export declare const float16_type: TypeInfo;
-export declare const float32_type: TypeInfo;
-export declare const float64_type: TypeInfo;
-export declare const decimal_type: TypeInfo;
-export declare const bigint_type: TypeInfo;
-export declare function name(info: FieldInfo | TypeInfo | CaseInfo | MethodInfo): string;
-export declare function fullName(t: TypeInfo): string;
-export declare function namespace(t: TypeInfo): string;
-export declare function isArray(t: TypeInfo): boolean;
-export declare function getElementType(t: TypeInfo): TypeInfo | undefined;
-export declare function isGenericType(t: TypeInfo): boolean;
-export declare function isGenericParameter(t: TypeInfo): t is GenericParameter;
-export declare function isEnum(t: TypeInfo): boolean;
-export declare function isSubclassOf(t1: TypeInfo, t2: TypeInfo): boolean;
-export declare function isInstanceOfType(t: TypeInfo, o: any): boolean;
-/**
- * This doesn't replace types for fields (records) or cases (unions)
- * but it should be enough for type comparison purposes
- */
-export declare function getGenericTypeDefinition(t: TypeInfo): TypeInfo;
-export declare function getEnumUnderlyingType(t: TypeInfo): TypeInfo | undefined;
-export declare function getEnumValues(t: TypeInfo): number[];
-export declare function getEnumNames(t: TypeInfo): string[];
-export declare function parseEnum(t: TypeInfo, str: string): number;
-export declare function tryParseEnum(t: TypeInfo, str: string, defValue: FSharpRef<number>): boolean;
-export declare function getEnumName(t: TypeInfo, v: number): string;
-export declare function isEnumDefined(t: TypeInfo, v: string | number): boolean;
-export declare function getUnionCases(t: TypeInfo): CaseInfo[];
-export declare function getRecordElements(t: TypeInfo): FieldInfo[];
-export declare function getTupleElements(t: TypeInfo): TypeInfo[];
-export declare function getFunctionElements(t: TypeInfo): [TypeInfo, TypeInfo];
-export declare function isUnion(t: any): boolean;
-export declare function isRecord(t: any): boolean;
-export declare function isTuple(t: TypeInfo): boolean;
-export declare function isFunction(t: TypeInfo): boolean;
-export declare function getUnionFields(v: any, t: TypeInfo): [CaseInfo, any[]];
-export declare function getUnionCaseFields(uci: CaseInfo): FieldInfo[];
-export declare function getRecordFields(v: any): any[];
-export declare function getRecordField(v: any, field: FieldInfo): any;
-export declare function getTupleFields(v: any): any[];
-export declare function getTupleField(v: any, i: number): any;
-export declare function makeUnion(uci: CaseInfo, values: any[]): any;
-export declare function makeRecord(t: TypeInfo, values: any[]): any;
-export declare function makeTuple(values: any[], _t: TypeInfo): any;
-export declare function makeGenericType(t: TypeInfo, generics: TypeInfo[]): TypeInfo;
-export declare function createInstance(t: TypeInfo, consArgs?: any[]): any;
-export declare function getValue(propertyInfo: PropertyInfo, v: any): any;
-export declare function getCaseTag(x: any): number;
-export declare function getCaseName(x: any): string;
-export declare function getCaseFields(x: any): any[];

package/RegExp.d.ts

@@ -1,10 +0,0 @@
-export type MatchEvaluator = (match: any) => string;
-export declare function create(pattern: string, options?: number): RegExp;
-export declare function escape(str: string): string;
-export declare function unescape(str: string): string;
-export declare function isMatch(reg: RegExp, input: string, startAt?: number): boolean;
-export declare function match(reg: RegExp, input: string, startAt?: number): RegExpExecArray | null;
-export declare function matches(reg: RegExp, input: string, startAt?: number): RegExpExecArray[];
-export declare function options(reg: RegExp): number;
-export declare function replace(reg: string | RegExp, input: string, replacement: string | MatchEvaluator, limit?: number, offset?: number): string;
-export declare function split(reg: string | RegExp, input: string, limit?: number, offset?: number): string[];

package/Result.d.ts

@@ -1,37 +0,0 @@
-import { Union } from "./Types.js";
-import { TypeInfo } from "./Reflection.js";
-import { int32 } from "./Int32.js";
-import { FSharpList } from "./List.js";
-import { Option } from "./Option.js";
-export type FSharpResult$2_$union<T, TError> = FSharpResult$2<T, TError, 0> | FSharpResult$2<T, TError, 1>;
-export type FSharpResult$2_$cases<T, TError> = {
-    0: ["Ok", [T]];
-    1: ["Error", [TError]];
-};
-export declare function FSharpResult$2_Ok<T, TError>(ResultValue: T): FSharpResult$2<T, TError, 0>;
-export declare function FSharpResult$2_Error$<T, TError>(ErrorValue: TError): FSharpResult$2<T, TError, 1>;
-export declare class FSharpResult$2<T, TError, Tag extends keyof FSharpResult$2_$cases<T, TError>> extends Union<Tag, FSharpResult$2_$cases<T, TError>[Tag][0]> {
-    readonly tag: Tag;
-    readonly fields: FSharpResult$2_$cases<T, TError>[Tag][1];
-    constructor(tag: Tag, fields: FSharpResult$2_$cases<T, TError>[Tag][1]);
-    cases(): string[];
-}
-export declare function FSharpResult$2_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
-export declare function Result_Map<a, b, c>(mapping: ((arg0: a) => b), result: FSharpResult$2_$union<a, c>): FSharpResult$2_$union<b, c>;
-export declare function Result_MapError<a, b, c>(mapping: ((arg0: a) => b), result: FSharpResult$2_$union<c, a>): FSharpResult$2_$union<c, b>;
-export declare function Result_Bind<a, b, c>(binder: ((arg0: a) => FSharpResult$2_$union<b, c>), result: FSharpResult$2_$union<a, c>): FSharpResult$2_$union<b, c>;
-export declare function Result_IsOk<a, b>(result: FSharpResult$2_$union<a, b>): boolean;
-export declare function Result_IsError<a, b>(result: FSharpResult$2_$union<a, b>): boolean;
-export declare function Result_Contains<a, b>(value: a, result: FSharpResult$2_$union<a, b>): boolean;
-export declare function Result_Count<a, b>(result: FSharpResult$2_$union<a, b>): int32;
-export declare function Result_DefaultValue<a, b>(defaultValue: a, result: FSharpResult$2_$union<a, b>): a;
-export declare function Result_DefaultWith<b, a>(defThunk: ((arg0: b) => a), result: FSharpResult$2_$union<a, b>): a;
-export declare function Result_Exists<a, b>(predicate: ((arg0: a) => boolean), result: FSharpResult$2_$union<a, b>): boolean;
-export declare function Result_Fold<a, b, s>(folder: ((arg0: s, arg1: a) => s), state: s, result: FSharpResult$2_$union<a, b>): s;
-export declare function Result_FoldBack<a, b, s>(folder: ((arg0: a, arg1: s) => s), result: FSharpResult$2_$union<a, b>, state: s): s;
-export declare function Result_ForAll<a, b>(predicate: ((arg0: a) => boolean), result: FSharpResult$2_$union<a, b>): boolean;
-export declare function Result_Iterate<a, b>(action: ((arg0: a) => void), result: FSharpResult$2_$union<a, b>): void;
-export declare function Result_ToArray<a, b>(result: FSharpResult$2_$union<a, b>): a[];
-export declare function Result_ToList<a, b>(result: FSharpResult$2_$union<a, b>): FSharpList<a>;
-export declare function Result_ToOption<a, b>(result: FSharpResult$2_$union<a, b>): Option<a>;
-export declare function Result_ToValueOption<a, b>(result: FSharpResult$2_$union<a, b>): Option<a>;