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

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

package/Seq.d.ts

@@ -1,164 +0,0 @@
-import { IComparer, IEqualityComparer, Nullable, IDisposable, IEnumerator } from "./Util.js";
-import { TypeInfo } from "./Reflection.js";
-import { Option } from "./Option.js";
-import { FSharpList } from "./List.js";
-import { int32 } from "./Int32.js";
-export declare const SR_enumerationAlreadyFinished = "Enumeration already finished.";
-export declare const SR_enumerationNotStarted = "Enumeration has not started. Call MoveNext.";
-export declare const SR_inputSequenceEmpty = "The input sequence was empty.";
-export declare const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
-export declare const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
-export declare const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";
-export declare const SR_resetNotSupported = "Reset is not supported on this enumerator.";
-export declare function Enumerator_noReset<$a>(): $a;
-export declare function Enumerator_notStarted<$a>(): $a;
-export declare function Enumerator_alreadyFinished<$a>(): $a;
-export declare class Enumerator_Seq<T> implements Iterable<T> {
-    readonly f: (() => IEnumerator<T>);
-    constructor(f: (() => IEnumerator<T>));
-    toString(): string;
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-}
-export declare function Enumerator_Seq_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function Enumerator_Seq_$ctor_673A07F2<T>(f: (() => IEnumerator<T>)): Enumerator_Seq<T>;
-export declare class Enumerator_FromFunctions$1<T> implements IEnumerator<T>, IDisposable {
-    readonly next: (() => boolean);
-    readonly dispose: (() => void);
-    readonly current: (() => T);
-    constructor(current: (() => T), next: (() => boolean), dispose: (() => void));
-    "System.Collections.Generic.IEnumerator`1.get_Current"(): T;
-    "System.Collections.IEnumerator.get_Current"(): Nullable<any>;
-    "System.Collections.IEnumerator.MoveNext"(): boolean;
-    "System.Collections.IEnumerator.Reset"(): void;
-    Dispose(): void;
-}
-export declare function Enumerator_FromFunctions$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function Enumerator_FromFunctions$1_$ctor_58C54629<T>(current: (() => T), next: (() => boolean), dispose: (() => void)): Enumerator_FromFunctions$1<T>;
-export declare function Enumerator_cast<T>(e: IEnumerator<T>): IEnumerator<T>;
-export declare function Enumerator_concat<T, U extends Iterable<T>>(sources: Iterable<U>): IEnumerator<T>;
-export declare function Enumerator_enumerateThenFinally<T>(f: (() => void), e: IEnumerator<T>): IEnumerator<T>;
-export declare function Enumerator_generateWhileSome<T, U>(openf: (() => T), compute: ((arg0: T) => Option<U>), closef: ((arg0: T) => void)): IEnumerator<U>;
-export declare function Enumerator_unfold<State, T>(f: ((arg0: State) => Option<[T, State]>), state: State): IEnumerator<T>;
-export declare function indexNotFound<$a>(): $a;
-export declare function mkSeq<T>(f: (() => IEnumerator<T>)): Iterable<T>;
-export declare function ofSeq<T>(xs: Iterable<T>): IEnumerator<T>;
-export declare function delay<T>(generator: (() => Iterable<T>)): Iterable<T>;
-export declare function concat<Collection extends Iterable<T>, T>(sources: Iterable<Collection>): Iterable<T>;
-export declare function unfold<State, T>(generator: ((arg0: State) => Option<[T, State]>), state: State): Iterable<T>;
-export declare function empty<T>(): Iterable<T>;
-export declare function singleton<T>(x: T): Iterable<T>;
-export declare function ofArray<T>(arr: T[]): Iterable<T>;
-export declare function toArray<T>(xs: Iterable<T>): T[];
-export declare function ofList<T>(xs: FSharpList<T>): Iterable<T>;
-export declare function toList<T>(xs: Iterable<T>): FSharpList<T>;
-export declare function generate<$a, $b>(create: (() => $a), compute: ((arg0: $a) => Option<$b>), dispose: ((arg0: $a) => void)): Iterable<$b>;
-export declare function generateIndexed<$a, $b>(create: (() => $a), compute: ((arg0: int32, arg1: $a) => Option<$b>), dispose: ((arg0: $a) => void)): Iterable<$b>;
-export declare function append<T>(xs: Iterable<T>, ys: Iterable<T>): Iterable<T>;
-export declare function cast<T>(xs: Iterable<T>): Iterable<T>;
-export declare function choose<T, U>(chooser: ((arg0: T) => Option<U>), xs: Iterable<T>): Iterable<U>;
-export declare function compareWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: Iterable<T>, ys: Iterable<T>): int32;
-export declare function contains<T>(value: T, xs: Iterable<T>, comparer: IEqualityComparer<T>): boolean;
-export declare function enumerateFromFunctions<$a, $b>(create: (() => $a), moveNext: ((arg0: $a) => boolean), current: ((arg0: $a) => $b)): Iterable<$b>;
-export declare function enumerateThenFinally<T>(source: Iterable<T>, compensation: (() => void)): Iterable<T>;
-export declare function enumerateUsing<T extends IDisposable, $a extends Iterable<U>, U>(resource: T, source: ((arg0: T) => $a)): Iterable<U>;
-export declare function enumerateWhile<T>(guard: (() => boolean), xs: Iterable<T>): Iterable<T>;
-export declare function filter<T>(f: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
-export declare function exists<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): boolean;
-export declare function exists2<T1, T2>(predicate: ((arg0: T1, arg1: T2) => boolean), xs: Iterable<T1>, ys: Iterable<T2>): boolean;
-export declare function exactlyOne<T>(xs: Iterable<T>): T;
-export declare function tryExactlyOne<T>(xs: Iterable<T>): Option<T>;
-export declare function tryFind<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<T>;
-export declare function find<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): T;
-export declare function tryFindBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<T>;
-export declare function findBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): T;
-export declare function tryFindIndex<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<int32>;
-export declare function findIndex<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): int32;
-export declare function tryFindIndexBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Option<int32>;
-export declare function findIndexBack<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): int32;
-export declare function fold<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, xs: Iterable<T>): State;
-export declare function foldBack<T, State>(folder: ((arg0: T, arg1: any) => any), xs: Iterable<T>, state: any): any;
-export declare function fold2<T1, T2, State>(folder: ((arg0: State, arg1: T1, arg2: T2) => State), state: State, xs: Iterable<T1>, ys: Iterable<T2>): State;
-export declare function foldBack2<T1, T2, State>(folder: ((arg0: T1, arg1: T2, arg2: State) => State), xs: Iterable<T1>, ys: Iterable<T2>, state: State): State;
-export declare function forAll<$a>(predicate: ((arg0: $a) => boolean), xs: Iterable<$a>): boolean;
-export declare function forAll2<$a, $b>(predicate: ((arg0: $a, arg1: $b) => boolean), xs: Iterable<$a>, ys: Iterable<$b>): boolean;
-export declare function tryHead<T>(xs: Iterable<T>): Option<T>;
-export declare function head<T>(xs: Iterable<T>): T;
-export declare function initialize<$a>(count: int32, f: ((arg0: int32) => $a)): Iterable<$a>;
-export declare function initializeInfinite<$a>(f: ((arg0: int32) => $a)): Iterable<$a>;
-export declare function isEmpty<T>(xs: Iterable<T>): boolean;
-export declare function tryItem<T>(index: int32, xs: Iterable<T>): Option<T>;
-export declare function item<T>(index: int32, xs: Iterable<T>): T;
-export declare function iterate<$a>(action: ((arg0: $a) => void), xs: Iterable<$a>): void;
-export declare function iterate2<$a, $b>(action: ((arg0: $a, arg1: $b) => void), xs: Iterable<$a>, ys: Iterable<$b>): void;
-export declare function iterateIndexed<$a>(action: ((arg0: int32, arg1: $a) => void), xs: Iterable<$a>): void;
-export declare function iterateIndexed2<$a, $b>(action: ((arg0: int32, arg1: $a, arg2: $b) => void), xs: Iterable<$a>, ys: Iterable<$b>): void;
-export declare function tryLast<T>(xs: Iterable<T>): Option<T>;
-export declare function last<T>(xs: Iterable<T>): T;
-export declare function length<T>(xs: Iterable<T>): int32;
-export declare function map<T, U>(mapping: ((arg0: T) => U), xs: Iterable<T>): Iterable<U>;
-export declare function mapIndexed<T, U>(mapping: ((arg0: int32, arg1: T) => U), xs: Iterable<T>): Iterable<U>;
-export declare function indexed<T>(xs: Iterable<T>): Iterable<[int32, T]>;
-export declare function map2<T1, T2, U>(mapping: ((arg0: T1, arg1: T2) => U), xs: Iterable<T1>, ys: Iterable<T2>): Iterable<U>;
-export declare function mapIndexed2<T1, T2, U>(mapping: ((arg0: int32, arg1: T1, arg2: T2) => U), xs: Iterable<T1>, ys: Iterable<T2>): Iterable<U>;
-export declare function map3<T1, T2, T3, U>(mapping: ((arg0: T1, arg1: T2, arg2: T3) => U), xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): Iterable<U>;
-export declare function readOnly<T>(xs: Iterable<T>): Iterable<T>;
-export declare class CachedSeq$1<T> implements Iterable<T>, IDisposable {
-    readonly res: Iterable<T>;
-    readonly cleanup: (() => void);
-    constructor(cleanup: (() => void), res: Iterable<T>);
-    Dispose(): void;
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-}
-export declare function CachedSeq$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function CachedSeq$1_$ctor_Z7A8347D4<T>(cleanup: (() => void), res: Iterable<T>): CachedSeq$1<T>;
-export declare function CachedSeq$1__Clear<T>(_: CachedSeq$1<T>): void;
-export declare function cache<T>(source: Iterable<T>): Iterable<T>;
-export declare function allPairs<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): Iterable<[T1, T2]>;
-export declare function mapFold<State, T, Result>(mapping: ((arg0: State, arg1: T) => [Result, State]), state: State, xs: Iterable<T>): [Iterable<Result>, State];
-export declare function mapFoldBack<T, State, Result>(mapping: ((arg0: T, arg1: State) => [Result, State]), xs: Iterable<T>, state: State): [Iterable<Result>, State];
-export declare function tryPick<T, $a>(chooser: ((arg0: T) => Option<$a>), xs: Iterable<T>): Option<$a>;
-export declare function pick<T, $a>(chooser: ((arg0: T) => Option<$a>), xs: Iterable<T>): $a;
-export declare function reduce<T>(folder: ((arg0: T, arg1: T) => T), xs: Iterable<T>): T;
-export declare function reduceBack<T>(folder: ((arg0: T, arg1: T) => T), xs: Iterable<T>): T;
-export declare function replicate<$a>(n: int32, x: $a): Iterable<$a>;
-export declare function reverse<T>(xs: Iterable<T>): Iterable<T>;
-export declare function scan<State, T>(folder: ((arg0: State, arg1: T) => State), state: State, xs: Iterable<T>): Iterable<State>;
-export declare function scanBack<T, State>(folder: ((arg0: T, arg1: State) => State), xs: Iterable<T>, state: State): Iterable<State>;
-export declare function skip<T>(count: int32, source: Iterable<T>): Iterable<T>;
-export declare function skipWhile<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
-export declare function tail<T>(xs: Iterable<T>): Iterable<T>;
-export declare function take<T>(count: int32, xs: Iterable<T>): Iterable<T>;
-export declare function takeWhile<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
-export declare function truncate<T>(count: int32, xs: Iterable<T>): Iterable<T>;
-export declare function zip<T1, T2>(xs: Iterable<T1>, ys: Iterable<T2>): Iterable<[T1, T2]>;
-export declare function zip3<T1, T2, T3>(xs: Iterable<T1>, ys: Iterable<T2>, zs: Iterable<T3>): Iterable<[T1, T2, T3]>;
-export declare function collect<T, Collection extends Iterable<U>, U>(mapping: ((arg0: T) => Collection), xs: Iterable<T>): Iterable<U>;
-export declare function where<T>(predicate: ((arg0: T) => boolean), xs: Iterable<T>): Iterable<T>;
-export declare function pairwise<T>(xs: Iterable<T>): Iterable<[T, T]>;
-export declare function splitInto<T>(chunks: int32, xs: Iterable<T>): Iterable<T[]>;
-export declare function windowed<T>(windowSize: int32, xs: Iterable<T>): Iterable<T[]>;
-export declare function transpose<$a extends Iterable<T>, T>(xss: Iterable<$a>): Iterable<Iterable<T>>;
-export declare function sortWith<T>(comparer: ((arg0: T, arg1: T) => int32), xs: Iterable<T>): Iterable<T>;
-export declare function sort<T>(xs: Iterable<T>, comparer: IComparer<T>): Iterable<T>;
-export declare function sortBy<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): Iterable<T>;
-export declare function sortDescending<T>(xs: Iterable<T>, comparer: IComparer<T>): Iterable<T>;
-export declare function sortByDescending<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): Iterable<T>;
-export declare function sum<T>(xs: Iterable<T>, adder: any): T;
-export declare function sumBy<T, U>(f: ((arg0: T) => U), xs: Iterable<T>, adder: any): U;
-export declare function maxBy<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): T;
-export declare function max<T>(xs: Iterable<T>, comparer: IComparer<T>): T;
-export declare function minBy<T, U>(projection: ((arg0: T) => U), xs: Iterable<T>, comparer: IComparer<U>): T;
-export declare function min<T>(xs: Iterable<T>, comparer: IComparer<T>): T;
-export declare function average<T>(xs: Iterable<T>, averager: any): T;
-export declare function averageBy<T, U>(f: ((arg0: T) => U), xs: Iterable<T>, averager: any): U;
-export declare function permute<T>(f: ((arg0: int32) => int32), xs: Iterable<T>): Iterable<T>;
-export declare function chunkBySize<T>(chunkSize: int32, xs: Iterable<T>): Iterable<T[]>;
-export declare function insertAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T>;
-export declare function insertManyAt<T>(index: int32, ys: Iterable<T>, xs: Iterable<T>): Iterable<T>;
-export declare function removeAt<T>(index: int32, xs: Iterable<T>): Iterable<T>;
-export declare function removeManyAt<T>(index: int32, count: int32, xs: Iterable<T>): Iterable<T>;
-export declare function updateAt<T>(index: int32, y: T, xs: Iterable<T>): Iterable<T>;

package/Seq2.d.ts

@@ -1,18 +0,0 @@
-import { IEqualityComparer } from "./Util.js";
-import { int32 } from "./Int32.js";
-import { FSharpList } from "./List.js";
-export declare function distinct<T>(xs: Iterable<T>, comparer: IEqualityComparer<T>): Iterable<T>;
-export declare function distinctBy<T, Key>(projection: ((arg0: T) => Key), xs: Iterable<T>, comparer: IEqualityComparer<Key>): Iterable<T>;
-export declare function except<T>(itemsToExclude: Iterable<T>, xs: Iterable<T>, comparer: IEqualityComparer<T>): Iterable<T>;
-export declare function countBy<T, Key>(projection: ((arg0: T) => Key), xs: Iterable<T>, comparer: IEqualityComparer<Key>): Iterable<[Key, int32]>;
-export declare function groupBy<T, Key>(projection: ((arg0: T) => Key), xs: Iterable<T>, comparer: IEqualityComparer<Key>): Iterable<[Key, Iterable<T>]>;
-export declare function Array_distinct<T>(xs: T[], comparer: IEqualityComparer<T>): T[];
-export declare function Array_distinctBy<T, Key>(projection: ((arg0: T) => Key), xs: T[], comparer: IEqualityComparer<Key>): T[];
-export declare function Array_except<T>(itemsToExclude: Iterable<T>, xs: T[], comparer: IEqualityComparer<T>): T[];
-export declare function Array_countBy<T, Key>(projection: ((arg0: T) => Key), xs: T[], comparer: IEqualityComparer<Key>): [Key, int32][];
-export declare function Array_groupBy<T, Key>(projection: ((arg0: T) => Key), xs: T[], comparer: IEqualityComparer<Key>): [Key, T[]][];
-export declare function List_distinct<T>(xs: FSharpList<T>, comparer: IEqualityComparer<T>): FSharpList<T>;
-export declare function List_distinctBy<T, Key>(projection: ((arg0: T) => Key), xs: FSharpList<T>, comparer: IEqualityComparer<Key>): FSharpList<T>;
-export declare function List_except<T>(itemsToExclude: Iterable<T>, xs: FSharpList<T>, comparer: IEqualityComparer<T>): FSharpList<T>;
-export declare function List_countBy<T, Key>(projection: ((arg0: T) => Key), xs: FSharpList<T>, comparer: IEqualityComparer<Key>): FSharpList<[Key, int32]>;
-export declare function List_groupBy<T, Key>(projection: ((arg0: T) => Key), xs: FSharpList<T>, comparer: IEqualityComparer<Key>): FSharpList<[Key, FSharpList<T>]>;

package/Set.d.ts

@@ -1,190 +0,0 @@
-import { TypeInfo } from "./Reflection.js";
-import { Option } from "./Option.js";
-import { int32 } from "./Int32.js";
-import { ISet, IEnumerator, IComparer, Nullable } from "./Util.js";
-import { Record } from "./Types.js";
-import { FSharpList } from "./List.js";
-export declare class SetTreeLeaf$1<T> {
-    readonly k: T;
-    constructor(k: T);
-}
-export declare function SetTreeLeaf$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function SetTreeLeaf$1_$ctor_2B595<T>(k: T): SetTreeLeaf$1<T>;
-export declare function SetTreeLeaf$1__get_Key<T>(_: SetTreeLeaf$1<T>): T;
-export declare class SetTreeNode$1<T> extends SetTreeLeaf$1<T> {
-    readonly right: Option<SetTreeLeaf$1<T>>;
-    readonly left: Option<SetTreeLeaf$1<T>>;
-    readonly h: int32;
-    constructor(v: T, left: Option<SetTreeLeaf$1<T>>, right: Option<SetTreeLeaf$1<T>>, h: int32);
-}
-export declare function SetTreeNode$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function SetTreeNode$1_$ctor_5F465FC9<T>(v: T, left: Option<SetTreeLeaf$1<T>>, right: Option<SetTreeLeaf$1<T>>, h: int32): SetTreeNode$1<T>;
-export declare function SetTreeNode$1__get_Left<T>(_: SetTreeNode$1<T>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeNode$1__get_Right<T>(_: SetTreeNode$1<T>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeNode$1__get_Height<T>(_: SetTreeNode$1<T>): int32;
-export declare function SetTreeModule_empty<T>(): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_countAux<T>(t_mut: Option<SetTreeLeaf$1<T>>, acc_mut: int32): int32;
-export declare function SetTreeModule_count<$a>(s: Option<SetTreeLeaf$1<$a>>): int32;
-export declare function SetTreeModule_mk<T>(l: Option<SetTreeLeaf$1<T>>, k: T, r: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_rebalance<T>(t1: Option<SetTreeLeaf$1<T>>, v: T, t2: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_add<T>(comparer: IComparer<T>, k: T, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_balance<T>(comparer: IComparer<T>, t1: Option<SetTreeLeaf$1<T>>, k: T, t2: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_split<T>(comparer: IComparer<T>, pivot: Nullable<T>, t: Option<SetTreeLeaf$1<T>>): [Option<SetTreeLeaf$1<T>>, boolean, Option<SetTreeLeaf$1<T>>];
-export declare function SetTreeModule_spliceOutSuccessor<T>(t: Option<SetTreeLeaf$1<T>>): [T, Option<SetTreeLeaf$1<T>>];
-export declare function SetTreeModule_remove<T>(comparer: IComparer<T>, k: Nullable<T>, t: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_mem<T>(comparer_mut: IComparer<T>, k_mut: Nullable<T>, t_mut: Option<SetTreeLeaf$1<T>>): boolean;
-export declare function SetTreeModule_iter<T>(f_mut: ((arg0: T) => void), t_mut: Option<SetTreeLeaf$1<T>>): void;
-export declare function SetTreeModule_foldBackOpt<T, $a>(f_mut: any, t_mut: Option<SetTreeLeaf$1<T>>, x_mut: $a): $a;
-export declare function SetTreeModule_foldBack<$a, $b>(f: ((arg0: $a, arg1: $b) => $b), m: Option<SetTreeLeaf$1<$a>>, x: $b): $b;
-export declare function SetTreeModule_foldOpt<$a, T>(f_mut: any, x_mut: $a, t_mut: Option<SetTreeLeaf$1<T>>): $a;
-export declare function SetTreeModule_fold<$a, $b>(f: ((arg0: $a, arg1: $b) => $a), x: $a, m: Option<SetTreeLeaf$1<$b>>): $a;
-export declare function SetTreeModule_forall<T>(f_mut: ((arg0: T) => boolean), t_mut: Option<SetTreeLeaf$1<T>>): boolean;
-export declare function SetTreeModule_exists<T>(f_mut: ((arg0: T) => boolean), t_mut: Option<SetTreeLeaf$1<T>>): boolean;
-export declare function SetTreeModule_subset<$a>(comparer: IComparer<$a>, a: Option<SetTreeLeaf$1<$a>>, b: Option<SetTreeLeaf$1<$a>>): boolean;
-export declare function SetTreeModule_properSubset<T>(comparer: IComparer<T>, a: Option<SetTreeLeaf$1<T>>, b: Option<SetTreeLeaf$1<T>>): boolean;
-export declare function SetTreeModule_filterAux<T>(comparer_mut: IComparer<T>, f_mut: ((arg0: T) => boolean), t_mut: Option<SetTreeLeaf$1<T>>, acc_mut: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_filter<$a>(comparer: IComparer<$a>, f: ((arg0: $a) => boolean), s: Option<SetTreeLeaf$1<$a>>): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_diffAux<T>(comparer_mut: IComparer<T>, t_mut: Option<SetTreeLeaf$1<T>>, acc_mut: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_diff<$a>(comparer: IComparer<$a>, a: Option<SetTreeLeaf$1<$a>>, b: Option<SetTreeLeaf$1<$a>>): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_union<T>(comparer: IComparer<T>, t1: Option<SetTreeLeaf$1<T>>, t2: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_intersectionAux<T>(comparer_mut: IComparer<T>, b_mut: Option<SetTreeLeaf$1<T>>, t_mut: Option<SetTreeLeaf$1<T>>, acc_mut: Option<SetTreeLeaf$1<T>>): Option<SetTreeLeaf$1<T>>;
-export declare function SetTreeModule_intersection<$a>(comparer: IComparer<$a>, a: Option<SetTreeLeaf$1<$a>>, b: Option<SetTreeLeaf$1<$a>>): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_partition1<$a>(comparer: IComparer<$a>, f: ((arg0: $a) => boolean), k: $a, acc1: Option<SetTreeLeaf$1<$a>>, acc2: Option<SetTreeLeaf$1<$a>>): [Option<SetTreeLeaf$1<$a>>, Option<SetTreeLeaf$1<$a>>];
-export declare function SetTreeModule_partitionAux<T>(comparer_mut: IComparer<T>, f_mut: ((arg0: T) => boolean), t_mut: Option<SetTreeLeaf$1<T>>, acc__mut: Option<SetTreeLeaf$1<T>>, acc__1_mut: Option<SetTreeLeaf$1<T>>): [Option<SetTreeLeaf$1<T>>, Option<SetTreeLeaf$1<T>>];
-export declare function SetTreeModule_partition<$a>(comparer: IComparer<$a>, f: ((arg0: $a) => boolean), s: Option<SetTreeLeaf$1<$a>>): [Option<SetTreeLeaf$1<$a>>, Option<SetTreeLeaf$1<$a>>];
-export declare function SetTreeModule_minimumElementAux<T>(t_mut: Option<SetTreeLeaf$1<T>>, n_mut: T): T;
-export declare function SetTreeModule_minimumElementOpt<T>(t: Option<SetTreeLeaf$1<T>>): Option<T>;
-export declare function SetTreeModule_maximumElementAux<T>(t_mut: Option<SetTreeLeaf$1<T>>, n_mut: T): T;
-export declare function SetTreeModule_maximumElementOpt<T>(t: Option<SetTreeLeaf$1<T>>): Option<T>;
-export declare function SetTreeModule_minimumElement<$a>(s: Option<SetTreeLeaf$1<$a>>): $a;
-export declare function SetTreeModule_maximumElement<$a>(s: Option<SetTreeLeaf$1<$a>>): $a;
-export declare class SetTreeModule_SetIterator$1<T> extends Record {
-    stack: FSharpList<Option<SetTreeLeaf$1<T>>>;
-    started: boolean;
-    constructor(stack: FSharpList<Option<SetTreeLeaf$1<T>>>, started: boolean);
-}
-export declare function SetTreeModule_SetIterator$1_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function SetTreeModule_collapseLHS<T>(stack_mut: FSharpList<Option<SetTreeLeaf$1<T>>>): FSharpList<Option<SetTreeLeaf$1<T>>>;
-export declare function SetTreeModule_mkIterator<$a>(s: Option<SetTreeLeaf$1<$a>>): SetTreeModule_SetIterator$1<$a>;
-export declare function SetTreeModule_notStarted<$a>(): $a;
-export declare function SetTreeModule_alreadyFinished<$a>(): $a;
-export declare function SetTreeModule_current<$a>(i: SetTreeModule_SetIterator$1<$a>): $a;
-export declare function SetTreeModule_moveNext<T>(i: SetTreeModule_SetIterator$1<T>): boolean;
-export declare function SetTreeModule_mkIEnumerator<a>(s: Option<SetTreeLeaf$1<a>>): IEnumerator<a>;
-/**
- * Set comparison.  Note this can be expensive.
- */
-export declare function SetTreeModule_compareStacks<T>(comparer_mut: IComparer<T>, l1_mut: FSharpList<Option<SetTreeLeaf$1<T>>>, l2_mut: FSharpList<Option<SetTreeLeaf$1<T>>>): int32;
-export declare function SetTreeModule_compare<T>(comparer: IComparer<T>, t1: Option<SetTreeLeaf$1<T>>, t2: Option<SetTreeLeaf$1<T>>): int32;
-export declare function SetTreeModule_choose<$a>(s: Option<SetTreeLeaf$1<$a>>): $a;
-export declare function SetTreeModule_toList<T>(t: Option<SetTreeLeaf$1<T>>): FSharpList<T>;
-export declare function SetTreeModule_copyToArray<$a>(s: Option<SetTreeLeaf$1<$a>>, arr: $a[], i: int32): void;
-export declare function SetTreeModule_toArray<$a>(s: Option<SetTreeLeaf$1<$a>>): $a[];
-export declare function SetTreeModule_mkFromEnumerator<$a>(comparer_mut: IComparer<$a>, acc_mut: Option<SetTreeLeaf$1<$a>>, e_mut: IEnumerator<$a>): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_ofArray<$a>(comparer: IComparer<$a>, l: $a[]): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_ofList<$a>(comparer: IComparer<$a>, l: FSharpList<$a>): Option<SetTreeLeaf$1<$a>>;
-export declare function SetTreeModule_ofSeq<T>(comparer: IComparer<T>, c: Iterable<T>): Option<SetTreeLeaf$1<T>>;
-export declare class FSharpSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
-    readonly tree: Option<SetTreeLeaf$1<T>>;
-    readonly comparer: IComparer<T>;
-    constructor(comparer: IComparer<T>, tree: Option<SetTreeLeaf$1<T>>);
-    GetHashCode(): int32;
-    Equals(other: Nullable<any>): boolean;
-    toString(): string;
-    get [Symbol.toStringTag](): string;
-    toJSON(): any;
-    CompareTo(other: Nullable<any>): int32;
-    "System.Collections.Generic.ICollection`1.Add2B595"(x: T): void;
-    "System.Collections.Generic.ICollection`1.Clear"(): void;
-    "System.Collections.Generic.ICollection`1.Remove2B595"(x: T): boolean;
-    "System.Collections.Generic.ICollection`1.Contains2B595"(x: T): boolean;
-    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(arr: T[], 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;
-    GetEnumerator(): IEnumerator<T>;
-    [Symbol.iterator](): Iterator<T>;
-    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
-    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 FSharpSet_$reflection(gen0: TypeInfo): TypeInfo;
-export declare function FSharpSet_$ctor<T>(comparer: IComparer<T>, tree: Option<SetTreeLeaf$1<T>>): FSharpSet<T>;
-export declare function FSharpSet__get_Comparer<T>(set$: FSharpSet<T>): IComparer<T>;
-export declare function FSharpSet__get_Tree<T>(set$: FSharpSet<T>): Option<SetTreeLeaf$1<T>>;
-export declare function FSharpSet_Empty<T>(comparer: IComparer<T>): FSharpSet<T>;
-export declare function FSharpSet__Add<T>(s: FSharpSet<T>, value: T): FSharpSet<T>;
-export declare function FSharpSet__Remove<T>(s: FSharpSet<T>, value: Nullable<T>): FSharpSet<T>;
-export declare function FSharpSet__get_Count<T>(s: FSharpSet<T>): int32;
-export declare function FSharpSet__Contains<T>(s: FSharpSet<T>, value: Nullable<T>): boolean;
-export declare function FSharpSet__Iterate<T>(s: FSharpSet<T>, x: ((arg0: T) => void)): void;
-export declare function FSharpSet__Fold<T, $a>(s: FSharpSet<T>, f: ((arg0: T, arg1: $a) => $a), z: $a): $a;
-export declare function FSharpSet__get_IsEmpty<T>(s: FSharpSet<T>): boolean;
-export declare function FSharpSet__Partition<T>(s: FSharpSet<T>, f: ((arg0: T) => boolean)): [FSharpSet<T>, FSharpSet<T>];
-export declare function FSharpSet__Filter<T>(s: FSharpSet<T>, f: ((arg0: T) => boolean)): FSharpSet<T>;
-export declare function FSharpSet__Map<T, U>(s: FSharpSet<T>, f: ((arg0: T) => U), comparer: IComparer<U>): FSharpSet<U>;
-export declare function FSharpSet__Exists<T>(s: FSharpSet<T>, f: ((arg0: T) => boolean)): boolean;
-export declare function FSharpSet__ForAll<T>(s: FSharpSet<T>, f: ((arg0: T) => boolean)): boolean;
-export declare function FSharpSet_op_Subtraction<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;
-export declare function FSharpSet_op_Addition<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;
-export declare function FSharpSet_Intersection<T>(a: FSharpSet<T>, b: FSharpSet<T>): FSharpSet<T>;
-export declare function FSharpSet_IntersectionMany<T>(sets: Iterable<FSharpSet<T>>): FSharpSet<T>;
-export declare function FSharpSet_Equality<T>(a: FSharpSet<T>, b: FSharpSet<T>): boolean;
-export declare function FSharpSet_Compare<T>(a: FSharpSet<T>, b: FSharpSet<T>): int32;
-export declare function FSharpSet__get_Choose<T>(x: FSharpSet<T>): T;
-export declare function FSharpSet__get_MinimumElement<T>(x: FSharpSet<T>): T;
-export declare function FSharpSet__get_MaximumElement<T>(x: FSharpSet<T>): T;
-export declare function FSharpSet__IsSubsetOf<T>(x: FSharpSet<T>, otherSet: FSharpSet<T>): boolean;
-export declare function FSharpSet__IsSupersetOf<T>(x: FSharpSet<T>, otherSet: FSharpSet<T>): boolean;
-export declare function FSharpSet__IsProperSubsetOf<T>(x: FSharpSet<T>, otherSet: FSharpSet<T>): boolean;
-export declare function FSharpSet__IsProperSupersetOf<T>(x: FSharpSet<T>, otherSet: FSharpSet<T>): boolean;
-export declare function FSharpSet__ToList<T>(x: FSharpSet<T>): FSharpList<T>;
-export declare function FSharpSet__ToArray<T>(x: FSharpSet<T>): T[];
-export declare function FSharpSet__ComputeHashCode<T>(this$: FSharpSet<T>): int32;
-export declare function isEmpty<T>(set$: FSharpSet<T>): boolean;
-export declare function contains<T>(element: Nullable<T>, set$: FSharpSet<T>): boolean;
-export declare function add<T>(value: T, set$: FSharpSet<T>): FSharpSet<T>;
-export declare function singleton<T>(value: T, comparer: IComparer<T>): FSharpSet<T>;
-export declare function remove<T>(value: Nullable<T>, set$: FSharpSet<T>): FSharpSet<T>;
-export declare function union<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;
-export declare function unionMany<T>(sets: Iterable<FSharpSet<T>>, comparer: IComparer<T>): FSharpSet<T>;
-export declare function intersect<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;
-export declare function intersectMany<T>(sets: Iterable<FSharpSet<T>>): FSharpSet<T>;
-export declare function iterate<T>(action: ((arg0: T) => void), set$: FSharpSet<T>): void;
-export declare function empty<T>(comparer: IComparer<T>): FSharpSet<T>;
-export declare function forAll<T>(predicate: ((arg0: T) => boolean), set$: FSharpSet<T>): boolean;
-export declare function exists<T>(predicate: ((arg0: T) => boolean), set$: FSharpSet<T>): boolean;
-export declare function filter<T>(predicate: ((arg0: T) => boolean), set$: FSharpSet<T>): FSharpSet<T>;
-export declare function partition<T>(predicate: ((arg0: T) => boolean), set$: FSharpSet<T>): [FSharpSet<T>, FSharpSet<T>];
-export declare function fold<T, State>(folder: ((arg0: State, arg1: T) => State), state: State, set$: FSharpSet<T>): State;
-export declare function foldBack<T, State>(folder: ((arg0: T, arg1: State) => State), set$: FSharpSet<T>, state: State): State;
-export declare function map<T, U>(mapping: ((arg0: T) => U), set$: FSharpSet<T>, comparer: IComparer<U>): FSharpSet<U>;
-export declare function count<T>(set$: FSharpSet<T>): int32;
-export declare function ofList<T>(elements: Iterable<T>, comparer: IComparer<T>): FSharpSet<T>;
-export declare function ofArray<T>(array: T[], comparer: IComparer<T>): FSharpSet<T>;
-export declare function toList<T>(set$: FSharpSet<T>): FSharpList<T>;
-export declare function toArray<T>(set$: FSharpSet<T>): T[];
-export declare function toSeq<T>(set$: FSharpSet<T>): Iterable<T>;
-export declare function ofSeq<T>(elements: Iterable<T>, comparer: IComparer<T>): FSharpSet<T>;
-export declare function difference<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): FSharpSet<T>;
-export declare function isSubset<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): boolean;
-export declare function isSuperset<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): boolean;
-export declare function isProperSubset<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): boolean;
-export declare function isProperSuperset<T>(set1: FSharpSet<T>, set2: FSharpSet<T>): boolean;
-export declare function minElement<T>(set$: FSharpSet<T>): T;
-export declare function maxElement<T>(set$: FSharpSet<T>): T;
-export declare function unionWith<T>(s1: ISet<T>, s2: Iterable<T>): ISet<T>;
-export declare function newMutableSetWith<T>(s1: ISet<T>, s2: Iterable<T>): ISet<T>;
-export declare function intersectWith<T>(s1: ISet<T>, s2: Iterable<T>): void;
-export declare function exceptWith<T>(s1: ISet<T>, s2: Iterable<T>): void;
-export declare function isSubsetOf<T>(s1: ISet<T>, s2: Iterable<T>): boolean;
-export declare function isSupersetOf<T>(s1: ISet<T>, s2: Iterable<T>): boolean;
-export declare function isProperSubsetOf<T>(s1: ISet<T>, s2: Iterable<T>): boolean;
-export declare function isProperSupersetOf<T>(s1: ISet<T>, s2: Iterable<T>): boolean;