@kusto/language-service-next/bridge.d.ts

Azure Data Explorer (a.k.a Kusto) language service for javascript

/*
 * @version   : 17.10.1 - Bridge.NET
 * @author    : Object.NET, Inc. http://bridge.net/
 * @copyright : Copyright 2008-2019 Object.NET, Inc. http://object.net/
 * @license   : See license.txt and https://github.com/bridgedotnet/Bridge/blob/master/LICENSE.md.
 */
declare module Bridge {
    export type TypeRef<T> = { prototype: { valueOf(): T } | T };
    export function global<T>(): T;
    export function emptyFn(): Function;
    export function box<T>(v: T, type: { prototype: T }): { v: T, type: { prototype: T } };
    export function unbox(obj: any, noclone?: boolean): any;
    export function property(scope: any, name: string, defaultValue: any): void;
    export function event(scope: any, name: string, defaultValue: any): void;
    export function copy<T>(to: T, from: T, keys: string[], toIf?: boolean): T;
    export function copy<T>(to: T, from: T, keys: string, toIf?: boolean): T;
    export function ns(ns: string, scope?: any): any;
    export function ready(fn: { (): void }): void;
    export function on(event: string, el: HTMLElement, fn: Function): void;
    export function getHashCode(value: any, safe: boolean): number;
    export function getDefaultValue<T>(type: TypeRef<T>): T;
    export function getTypeName(obj: any): string;
    export function is(obj: any, type: any, ignoreFn?: boolean): boolean;
    export function as<T>(obj: any, type: TypeRef<T>): T;
    export function cast<T>(obj: any, type: TypeRef<T>): T;
    export function apply<T>(obj: T, values: any): T;
    export function merge<T>(to: T, from: T): T;
    export function GetEnumerator(obj: any): System.Collections.IEnumerator;
    export function getPropertyNames(obj: any, includeFunctions?: boolean): string[];
    export function isDefined(value: any, noNull?: boolean): boolean;
    export function isEmpty(value: any, allowEmpty?: boolean): boolean;
    export function ToArray(ienumerable: any[]): any[];
    export function ToArray<T>(ienumerable: T[]): T[];
    export function ToArray<T>(ienumerable: any): T[];
    export function isArray(obj: any): boolean;
    export function isFunction(obj: any): boolean;
    export function isDate(obj: any): boolean;
    export function isNull(obj: any): boolean;
    export function isBoolean(obj: any): boolean;
    export function isNumber(obj: any): boolean;
    export function isString(obj: any): boolean;
    export function unroll(value: string): any;
    export function equals(a: any, b: any): boolean;
    export function objectEquals(a: any, b: any): boolean;
    export function deepEquals(a: any, b: any): boolean;
    export function compare(a: any, b: any, safe?: boolean): boolean;
    export function equalsT(a: any, b: any): boolean;
    export function format(obj: any, formatString?: string): string;
    export function getType(instance: any): any;
    export function isLower(c: number): boolean;
    export function isUpper(c: number): boolean;

    export interface fnMethods {
        call(obj: any, fnName: string): any;
        bind(obj: any, method: Function, args?: any[], appendArgs?: boolean): Function;
        bindScope(obj: any, method: Function): Function;
        combine(fn1: Function, fn2: Function): Function;
        remove(fn1: Function, fn2: Function): Function;
    }

    var fn: fnMethods;

    export interface Array {
        get(arr: any[], indices: number[]): any;
        set(arr: any[], indices: number[], value: any): void;
        getLength(arr: any[], dimension: number): number;
        getRank(arr: any[]): number;
        create(defValue: any, initValues: any[], sizes: number[]): any[];
        toEnumerable(array: any[]): System.Collections.IEnumerable;
        toEnumerable<T>(array: T[]): System.Collections.Generic.IEnumerable$1<T>;
        toEnumerator(array: any[]): System.Collections.IEnumerator;
        toEnumerator<T>(array: T[]): System.Collections.Generic.IEnumerator$1<T>;
    }

    var Array: Array;

    export interface Class {
        define(className: string, props: any): Function;
        define(className: string, scope: any, props: any): Function;
        generic(className: string, props: any): Function;
        generic(className: string, scope: any, props: any): Function;
    }

    var Class: Class;
    export function define(className: string, props: any): Function;
    export function define(className: string, scope: any, props: any): Function;

    export class ErrorException extends System.Exception {
        constructor(error: Error);
        getError(): Error;
    }

    export interface IPromise {
        then(fulfilledHandler: Function, errorHandler?: Function): void;
    }
    var IPromise: Function;

    export interface Int extends System.IComparable$1<Int>, System.IEquatable$1<Int> {
        instanceOf(instance: any): boolean;
        getDefaultValue(): number;
        format(num: number, format?: string, provider?: System.Globalization.NumberFormatInfo): string;
        parseFloat(str: string, provider?: System.Globalization.NumberFormatInfo): number;
        tryParseFloat(str: string, provider: System.Globalization.NumberFormatInfo, result: { v: number }): boolean;
        parseInt(str: string, min?: number, max?: number, radix?: number): number;
        tryParseInt(str: string, result: { v: number }, min?: number, max?: number, radix?: number): boolean;
        trunc(num: number): number;
        div(x: number, y: number): number;
    }
    var Int: Int;

    export interface Browser {
        isStrict: boolean;
        isIEQuirks: boolean;
        isOpera: boolean;
        isOpera10_5: boolean;
        isWebKit: boolean;
        isChrome: boolean;
        isSafari: boolean;
        isSafari3: boolean;
        isSafari4: boolean;
        isSafari5: boolean;
        isSafari5_0: boolean;
        isSafari2: boolean;
        isIE: boolean;
        isIE6: boolean;
        isIE7: boolean;
        isIE7m: boolean;
        isIE7p: boolean;
        isIE8: boolean;
        isIE8m: boolean;
        isIE8p: boolean;
        isIE9: boolean;
        isIE9m: boolean;
        isIE9p: boolean;
        isIE10: boolean;
        isIE10m: boolean;
        isIE10p: boolean;
        isIE11: boolean;
        isIE11m: boolean;
        isIE11p: boolean;
        isGecko: boolean;
        isGecko3: boolean;
        isGecko4: boolean;
        isGecko5: boolean;
        isGecko10: boolean;
        isFF3_0: boolean;
        isFF3_5: boolean;
        isFF3_6: boolean;
        isFF4: boolean;
        isFF5: boolean;
        isFF10: boolean;
        isLinux: boolean;
        isWindows: boolean;
        isMac: boolean;
        chromeVersion: number;
        firefoxVersion: number;
        ieVersion: number;
        operaVersion: number;
        safariVersion: number;
        webKitVersion: number;
        isSecure: boolean;
        isiPhone: boolean;
        isiPod: boolean;
        isiPad: boolean;
        isBlackberry: boolean;
        isAndroid: boolean;
        isDesktop: boolean;
        isTablet: boolean;
        isPhone: boolean;
        iOS: boolean;
        standalone: boolean;
    }

    var Browser: Browser;

    export class CustomEnumerator implements System.Collections.IEnumerator {
        constructor(moveNext: Function, getCurrent: Function, reset?: Function, dispose?: Function, scope?: any);
        moveNext(): boolean;
        getCurrent(): any;
        reset(): void;
        Dispose(): void;
        readonly Current: any;
    }

    export class ArrayEnumerator implements System.Collections.IEnumerator {
        constructor(array: any[]);
        moveNext(): boolean;
        getCurrent(): any;
        reset(): void;
        Dispose(): void;
        readonly Current: any;
    }

    export class ArrayEnumerable implements System.Collections.IEnumerable {
        constructor(array: any[]);
        GetEnumerator(): ArrayEnumerator;
    }

    export interface Validation {
        isNull(value: any): boolean;
        isEmpty(value: any): boolean;
        isNotEmptyOrWhitespace(value: any): boolean;
        isNotNull(value: any): boolean;
        isNotEmpty(value: any): boolean;
        email(value: string): boolean;
        url(value: string): boolean;
        alpha(value: string): boolean;
        alphaNum(value: string): boolean;
        creditCard(value: string, type: string): boolean;
    }

    var Validation: Validation;

    module Collections {
        export interface EnumerableHelpers {
        }
        export interface EnumerableHelpersFunc extends Function {
            prototype: Bridge.Collections.EnumerableHelpers;
            new(): Bridge.Collections.EnumerableHelpers;
            ToArray<T>(T: { prototype: T }, source: System.Collections.Generic.IEnumerable$1<T>): T[];
            ToArray$1<T>(T: { prototype: T }, source: System.Collections.Generic.IEnumerable$1<T>, length: { v: number }): T[];
        }
        var EnumerableHelpers: EnumerableHelpersFunc;
    }
}

declare module System {
    export class Decimal {
        prototype: Decimal;
        static readonly Zero: Decimal;
        static readonly One: Decimal;
        static readonly MinusOne: Decimal;
        static readonly MaxValue: Decimal;
        static readonly MinValue: Decimal;
        constructor(value: any);
        abs(): Decimal;
        ceil(): Decimal;
        floor(): Decimal;
        comparedTo(d: Decimal): number;
        clone(): Decimal;
        neg(): Decimal;
        add(d: Decimal): Decimal;
        sub(d: Decimal): Decimal;
        inc(): Decimal;
        dec(): Decimal;
        mul(d: Decimal): Decimal;
        div(d: Decimal): Decimal;
        mod(d: Decimal): Decimal;
        equals(d: Decimal): boolean;
        ne(d: Decimal): boolean;
        gt(d: Decimal): boolean;
        gte(d: Decimal): boolean;
        lt(d: Decimal): boolean;
        lte(d: Decimal): boolean;
        trunc(): Decimal;
        static exp(d: Decimal): Decimal;
        static ln(d: Decimal): Decimal;
        static log(d: Decimal, logBase: Decimal): Decimal;
        static pow(d: Decimal, exponent: Decimal): Decimal;
        static sqrt(d: Decimal): Decimal;
        static tryParse(s: string, provider: System.Globalization.IFormatProvider, result: { v: Decimal }): boolean;
        static round(d: Decimal, mode: number): Decimal;
        static round(d: Decimal): Decimal;
        static toInt(d: Decimal): number;
        static toFloat(d: Decimal): number;
    }

    export class Single extends Number {
        static readonly max: number;
        static readonly min: number;
        static parse(s: string): number;
        static parse(s: string, radix: number): number;
        static tryParse(s: string, result: { v: number }): number;
        static tryParse(s: string, result: { v: number }, radix: number): number;
        static format(v: number, format: string): number;
        static format(v: number, format: string, provider: System.Globalization.IFormatProvider): number;
    }

    export class Double extends Number {
        static readonly max: number;
        static readonly min: number;
        static parse(s: string): number;
        static parse(s: string, radix: number): number;
        static tryParse(s: string, result: { v: number }): number;
        static tryParse(s: string, result: { v: number }, radix: number): number;
        static format(v: number, format: string): number;
        static format(v: number, format: string, provider: System.Globalization.IFormatProvider): number;
    }

    export class SByte extends Number {
        static parse(s: string): number;
        static parse(s: string, radix: number): number;
        static tryParse(s: string, result: { v: number }): number;
        static tryParse(s: string, result: { v: number }, radix: number): number;
        static format(v: number, format: string): number;
        static format(v: number, format: string, provider: System.Globalization.IFormatProvider): number;
    }

    export class Byte extends Number {
        static parse(s: string): number;
        static parse(s: string, radix: number): number;
        static tryParse(s: string, result: { v: number }): number;
        static tryParse(s: string, result: { v: number }, radix: number): number;
        static format(v: number, format: string): number;
        static format(v: number, format: string, provider: System.Globalization.IFormatProvider): number;
    }

    export class Int16 extends Number {
        static parse(s: string): number;
        static parse(s: string, radix: number): number;
        static tryParse(s: string, result: { v: number }): number;
        static tryParse(s: string, result: { v: number }, radix: number): number;
        static format(v: number, format: string): number;
        static format(v: number, format: string, provider: System.Globalization.IFormatProvider): number;
    }

    export class UInt16 extends Number {
        static parse(s: string): number;
        static parse(s: string, radix: number): number;
        static tryParse(s: string, result: { v: number }): number;
        static tryParse(s: string, result: { v: number }, radix: number): number;
        static format(v: number, format: string): number;
        static format(v: number, format: string, provider: System.Globalization.IFormatProvider): number;
    }

    export class UInt32 extends Number {
        static parse(s: string): number;
        static parse(s: string, radix: number): number;
        static tryParse(s: string, result: { v: number }): number;
        static tryParse(s: string, result: { v: number }, radix: number): number;
        static format(v: number, format: string): number;
        static format(v: number, format: string, provider: System.Globalization.IFormatProvider): number;
    }

    export class Int32 extends Number {
        static parse(s: string): number;
        static parse(s: string, radix: number): number;
        static tryParse(s: string, result: { v: number }): number;
        static tryParse(s: string, result: { v: number }, radix: number): number;
        static format(v: number, format: string): number;
        static format(v: number, format: string, provider: System.Globalization.IFormatProvider): number;
    }

    export class Int64 {
        static parse(s: string): number;
        static parse(s: string, radix: number): number;
        static tryParse(s: string, result: { v: number }): number;
        static tryParse(s: string, result: { v: number }, radix: number): number;
        static format(v: number, format: string): number;
        static format(v: number, format: string, provider: System.Globalization.IFormatProvider): number;
    }

    export class UInt64 {
        static parse(s: string): number;
        static parse(s: string, radix: number): number;
        static tryParse(s: string, result: { v: number }): number;
        static tryParse(s: string, result: { v: number }, radix: number): number;
        static format(v: number, format: string): number;
        static format(v: number, format: string, provider: System.Globalization.IFormatProvider): number;
    }

    export class Object {
    }

    export class Attribute {
    }

    export interface Nullable {
        prototype: Nullable;
        hasValue(obj: any): boolean;
        getValue<T>(obj: T): T;
        getValue(obj: any): any;
        getValueOrDefault<T>(obj: T, defValue: T): T;
        add(a: number, b: number): number;
        band<T>(a: number, b: number): number;
        bor<T>(a: number, b: number): number;
        and<T>(a: boolean, b: boolean): boolean;
        or<T>(a: boolean, b: boolean): boolean;
        div(a: number, b: number): number;
        eq(a: any, b: any): boolean;
        xor(a: number, b: number): number;
        gt(a: any, b: any): boolean;
        gte(a: any, b: any): boolean;
        neq(a: any, b: any): boolean;
        lt(a: any, b: any): boolean;
        lte(a: any, b: any): boolean;
        mod(a: number, b: number): number;
        mul(a: number, b: number): number;
        sl(a: number, b: number): number;
        sr(a: number, b: number): number;
        sub(a: number, b: number): number;
        bnot(a: number): number;
        neg(a: number): number;
        not(a: boolean): boolean;
        pos(a: number): number;
    }

    var Nullable: Nullable;

    export interface Char {
        prototype: Char;
        isWhiteSpace(value: string): boolean;
        isDigit(value: number): boolean;
        isLetter(value: number): boolean;
        isHighSurrogate(value: number): boolean;
        isLowSurrogate(value: number): boolean;
        isSurrogate(value: number): boolean;
        isSymbol(value: number): boolean;
        isSeparator(value: number): boolean;
        isPunctuation(value: number): boolean;
        isNumber(value: number): boolean;
        isControl(value: number): boolean;
    }

    var Char: Char;

    export interface String {
        prototype: String;
        isNullOrWhiteSpace(value: string): boolean;
        isNullOrEmpty(value: string): boolean;
        fromCharCount(c: number, count: number): string;
        format(str: string, ...args: any[]): string;
        alignString(str: string, alignment: number, pad: string, dir: number): string;
        startsWith(str: string, prefix: string): boolean;
        endsWith(str: string, suffix: string): boolean;
        contains(str: string, value: string): string;
        indexOfAny(str: string, anyOf: number[], startIndex?: number, length?: number): number;
        indexOf(str: string, value: string): number;
        compare(strA: string, strB: string): number;
        toCharArray(str: string, startIndex: number, length: number): number[];
    }

    var String: String;

    export class Exception {
        constructor(message: string, innerException?: Exception);
        getMessage(): string;
        getInnerException(): Exception;
        getStackTrace(): any;
        getData<T>(): T;
        toString(): string;
        static create(error: string): Exception;
        static create(error: Error): Exception;
    }

    export class SystemException extends Exception {
        constructor(message: string, innerException: Exception);
        constructor(message: string);
    }

    export class OutOfMemoryException extends SystemException {
        constructor(message: string, innerException: Exception);
        constructor(message: string);
    }

    export class IndexOutOfRangeException extends SystemException {
        constructor(message: string, innerException: Exception);
        constructor(message: string);
    }

    export class ArgumentException extends Exception {
        constructor(message: string, paramName: string, innerException: Exception);
        constructor(message: string, innerException: Exception);
        constructor(message: string);
        getParamName(): string;
    }

    export class ArgumentNullException extends ArgumentException {
        constructor(paramName: string, message?: string, innerException?: Exception);
    }

    export class ArgumentOutOfRangeException extends ArgumentException {
        constructor(paramName: string, message?: string, innerException?: Exception, actualValue?: any);
        getActualValue<T>(): T;
    }

    export class ArithmeticException extends Exception {
        constructor(message?: string, innerException?: Exception);
    }

    export class DivideByZeroException extends ArithmeticException {
        constructor(message?: string, innerException?: Exception);
    }

    export class OverflowException extends ArithmeticException {
        constructor(message?: string, innerException?: Exception);
    }

    export class FormatException extends Exception {
        constructor(message?: string, innerException?: Exception);
    }

    export class InvalidCastException extends Exception {
        constructor(message?: string, innerException?: Exception);
    }

    export class InvalidOperationException extends Exception {
        constructor(message?: string, innerException?: Exception);
    }

    export class NotImplementedException extends Exception {
        constructor(message?: string, innerException?: Exception);
    }

    export class NotSupportedException extends Exception {
        constructor(message?: string, innerException?: Exception);
    }

    export class NullReferenceException extends Exception {
        constructor(message?: string, innerException?: Exception);
    }

    export interface IFormattable {
        format(format: string, formatProvider: IFormatProvider): string;
    }
    var IFormattable: Function;

    export interface IComparable {
        compareTo(obj: any): number;
    }
    var IComparable: Function;

    export interface IFormatProvider {
        getFormat(formatType: any): any;
    }

    export interface ICloneable {
        clone(): any;
    }
    var ICloneable: Function;

    export interface IComparable$1<T> {
        compareTo(other: T): number;
    }
    export function IComparable$1<T>(t: Bridge.TypeRef<T>): {
        prototype: IComparable$1<T>;
    }

    export interface IEquatable$1<T> {
        equalsT(other: T): boolean;
    }
    export function IEquatable$1<T>(t: Bridge.TypeRef<T>): {
        prototype: IEquatable$1<T>;
    }

    export interface IDisposable {
        Dispose(): void;
    }
    var IDisposable: Function;

    export interface DateTime {
        prototype: DateTime;
        utcNow(): Date;
        today(): Date;
        format(date: Date, format?: string, provider?: System.Globalization.DateTimeFormatInfo): string;
        parse(value: string, provider?: System.Globalization.DateTimeFormatInfo): Date;
        parseExact(str: string, format?: string, provider?: System.Globalization.DateTimeFormatInfo, silent?: boolean): Date;
        tryParse(str: string, provider: System.Globalization.DateTimeFormatInfo, result: { v: Date }): boolean;
        tryParseExact(str: string, format: string, provider: System.Globalization.DateTimeFormatInfo, result: { v: Date }): boolean;
        isDaylightSavingTime(dt: Date): boolean;
        toUTC(dt: Date): Date;
        toLocal(dt: Date): Date;
    }
    var DateTime: DateTime;

    export interface Guid extends System.IEquatable$1<System.Guid>, System.IComparable$1<System.Guid>, System.IFormattable {
        equalsT(o: System.Guid): boolean;
        compareTo(value: System.Guid): number;
        toString(): string;
        ToString(format: string): string;
        Format(format: string, formatProvider: System.IFormatProvider): string;
        ToByteArray(): number[];
        getHashCode(): System.Guid;
        $clone(to: System.Guid): System.Guid;
    }
    export interface GuidFunc extends Function {
        prototype: Guid;
        $ctor4: {
            new(uuid: string): Guid;
        };
        $ctor1: {
            new(b: number[]): Guid;
        };
        $ctor5: {
            new(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number): Guid;
        };
        $ctor3: {
            new(a: number, b: number, c: number, d: number[]): Guid;
        };
        $ctor2: {
            new(a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number): Guid;
        };
        ctor: {
            new(): Guid;
        };
        Empty: System.Guid;
        Parse(input: string): System.Guid;
        ParseExact(input: string, format: string): System.Guid;
        TryParse(input: string, result: { v: System.Guid }): boolean;
        TryParseExact(input: string, format: string, result: { v: System.Guid }): boolean;
        NewGuid(): System.Guid;
        op_Equality(a: System.Guid, b: System.Guid): boolean;
        op_Inequality(a: System.Guid, b: System.Guid): boolean;
    }
    var Guid: GuidFunc;

    export class TimeSpan implements IComparable, IComparable$1<TimeSpan>, IEquatable$1<TimeSpan> {
        prototype: TimeSpan;
        static fromDays(value: number): TimeSpan;
        static fromHours(value: number): TimeSpan;
        static fromMilliseconds(value: number): TimeSpan;
        static fromMinutes(value: number): TimeSpan;
        static fromSeconds(value: number): TimeSpan;
        static fromTicks(value: number): TimeSpan;
        static getDefaultValue(): TimeSpan;
        constructor();
        getTicks(): number;
        getDays(): number;
        getHours(): number;
        getMilliseconds(): number;
        getMinutes(): number;
        getSeconds(): number;
        getTotalDays(): number;
        getTotalHours(): number;
        getTotalMilliseconds(): number;
        getTotalMinutes(): number;
        getTotalSeconds(): number;
        get12HourHour(): number;
        add(ts: TimeSpan): TimeSpan;
        subtract(ts: TimeSpan): TimeSpan;
        duration(): TimeSpan;
        negate(): TimeSpan;
        compareTo(other: TimeSpan): number;
        equalsT(other: TimeSpan): boolean;
        format(str: string, provider?: System.Globalization.DateTimeFormatInfo): string;
        toString(str: string, provider?: System.Globalization.DateTimeFormatInfo): string;
    }

    export interface Random {
        Sample(): number;
        InternalSample(): number;
        Next(): number;
        Next$2(minValue: number, maxValue: number): number;
        Next$1(maxValue: number): number;
        NextDouble(): number;
        NextBytes(buffer: number[]): void;
    }
    export interface RandomFunc extends Function {
        prototype: Random;
        ctor: {
            new(): Random;
        };
        $ctor1: {
            new(seed: number): Random;
        };
    }
    var Random: RandomFunc;

    module Collections {
        export interface IEnumerable {
            GetEnumerator(): IEnumerator;
        }
        var IEnumerable: Function;

        export interface IEnumerator {
            getCurrent(): any;
            moveNext(): boolean;
            reset(): void;
            readonly Current: any;
        }
        var IEnumerator: Function;

        export interface IEqualityComparer {
            equals(x: any, y: any): boolean;
            getHashCode(obj: any): number;
        }
        var IEqualityComparer: Function;

        export interface ICollection extends IEnumerable {
            getCount(): number;
            System$Collections$IList$Count: number;
            Count: number;
        }
        var ICollection: Function;

        export interface BitArray extends System.Collections.ICollection, System.ICloneable {
            GetItem(index: number): boolean;
            SetItem(index: number, value: boolean): void;
            Length: number;
            Count: number;
            IsReadOnly: boolean;
            IsSynchronized: boolean;
            CopyTo(array: Array<any>, index: number): void;
            Get(index: number): boolean;
            Set(index: number, value: boolean): void;
            SetAll(value: boolean): void;
            And(value: System.Collections.BitArray): System.Collections.BitArray;
            Or(value: System.Collections.BitArray): System.Collections.BitArray;
            Xor(value: System.Collections.BitArray): System.Collections.BitArray;
            Not(): System.Collections.BitArray;
            Clone(): any;
            GetEnumerator(): System.Collections.IEnumerator;
        }
        export interface BitArrayFunc extends Function {
            prototype: BitArray;
            BitArrayEnumeratorSimple: System.Collections.BitArray.BitArrayEnumeratorSimpleFunc;
            $ctor3: {
                new(length: number): BitArray
            };
            $ctor4: {
                new(length: number, defaultValue: boolean): BitArray
            };
            $ctor1: {
                new(bytes: number[]): BitArray
            };
            ctor: {
                new(values: boolean[]): BitArray
            };
            $ctor5: {
                new(values: number[]): BitArray
            };
            $ctor2: {
                new(bits: System.Collections.BitArray): BitArray
            };
            getArrayLength(n: number, div: number): number;
        }
        var BitArray: BitArrayFunc;

        module BitArray {
            export interface BitArrayEnumeratorSimple extends System.Collections.IEnumerator {
                Current: any;
                moveNext(): boolean;
                reset(): void;
            }
            export interface BitArrayEnumeratorSimpleFunc extends Function {
                prototype: BitArrayEnumeratorSimple;
            }
        }

        export interface HashHelpers {
        }
        export interface HashHelpersFunc extends Function {
            prototype: HashHelpers;
            new(): HashHelpers;
            primes: number[];
            MaxPrimeArrayLength: number;
            isPrime(candidate: number): boolean;
            getPrime(min: number): number;
            getMinPrime(): number;
            expandPrime(oldSize: number): number;
        }
        var HashHelpers: HashHelpersFunc;

        export interface IList extends System.Collections.ICollection, System.Collections.IEnumerable {
            System$Collections$IList$getItem(index: number): any;
            getItem(index: number): any;
            System$Collections$IList$setItem(index: number, value: any): void;
            setItem(index: number, value: any): void;
            System$Collections$IList$IsReadOnly: boolean;
            IsReadOnly: boolean;
            add(item: any): number;
            System$Collections$IList$add(item: any): number;
            clear(): void;
            System$Collections$IList$clear(): void;
            contains(item: any): boolean;
            System$Collections$IList$contains(item: any): boolean;
            indexOf(item: any): number;
            System$Collections$IList$indexOf(item: any): number;
            insert(index: number, item: any): void;
            System$Collections$IList$insert(index: number, item: any): void;
            removeAt(index: number): void;
            System$Collections$IList$removeAt(index: number): void;
            remove(item: any): void;
            System$Collections$IList$remove(item: any): void;
        }

        export interface IDictionaryEnumerator extends System.Collections.IEnumerator {
            System$Collections$IDictionaryEnumerator$Key: any | null;
            Key: any | null;
            System$Collections$IDictionaryEnumerator$Value: any | null;
            Value: any | null;
            System$Collections$IDictionaryEnumerator$Entry: System.Collections.DictionaryEntry;
            Entry: System.Collections.DictionaryEntry;
        }

        export interface DictionaryEntry {
            Key: any | null;
            Value: any | null;
            getHashCode(): number;
            equals(o: System.Collections.DictionaryEntry): boolean;
            $clone(to: System.Collections.DictionaryEntry): System.Collections.DictionaryEntry;
        }
        export interface DictionaryEntryFunc extends Function {
            prototype: DictionaryEntry;
            new(key: any | null, value: any | null): DictionaryEntry;
        }
        var DictionaryEntry: DictionaryEntryFunc;

        module Generic {
            export class KeyNotFoundException extends Exception {
                constructor(message?: string, innerException?: Exception);
            }
            export interface IEnumerator$1<T> extends IEnumerator {
                getCurrent(): T;
                readonly Current: T;
            }
            export function IEnumerator$1<T>(t: Bridge.TypeRef<T>): {
                prototype: IEnumerator$1<T>;
            }

            export interface IEnumerable$1<T> extends IEnumerable {
                GetEnumerator(): IEnumerator$1<T>;
            }
            export function IEnumerable$1<T>(t: Bridge.TypeRef<T>): {
                prototype: IEnumerable$1<T>;
            }

            export interface ICollection$1<T> extends IEnumerable$1<T> {
                getCount(): number;
                add(item: T): void;
                clear(): void;
                contains(item: T): boolean;
                remove(item: T): boolean;
            }
            export function ICollection$1<T>(t: Bridge.TypeRef<T>): {
                prototype: ICollection$1<T>;
            }

            export interface IEqualityComparer$1<T> extends IEqualityComparer {
                equals(x: T, y: T): boolean;
                getHashCode(obj: T): number;
            }
            export function IEqualityComparer$1<T>(t: Bridge.TypeRef<T>): {
                prototype: IEqualityComparer$1<T>;
            }

            export interface IReadOnlyCollection$1<T> extends IEnumerable$1<T> {
                Count: number;
            }

            export interface IReadOnlyList$1<T> extends IReadOnlyCollection$1<T> {
                getItem(index: number): T;
            }

            export interface IReadOnlyDictionary$2<TKey, TValue> extends IReadOnlyCollection$1<System.Collections.Generic.KeyValuePair$2<TKey, TValue>>, System.Collections.Generic.IEnumerable$1<System.Collections.Generic.KeyValuePair$2<TKey, TValue>> {
                getItem(key: TKey): TValue;
                Keys: System.Collections.Generic.IEnumerable$1<TKey> | null;
                Values: System.Collections.Generic.IEnumerable$1<TValue> | null;
                containsKey(key: TKey): boolean;
                tryGetValue(key: TKey, value: { v: TValue }): boolean;
            }

            export interface ReadOnlyDictionary$2<TKey, TValue> extends System.Collections.Generic.IDictionary$2<TKey, TValue>, System.Collections.Generic.IReadOnlyDictionary$2<TKey, TValue> {
                Keys: System.Collections.ObjectModel.ReadOnlyDictionary$2.KeyCollection<TKey, TValue> | null;
                Values: System.Collections.ObjectModel.ReadOnlyDictionary$2.ValueCollection<TKey, TValue> | null;
                getItem(key: TKey): TValue;
                System$Collections$IDictionary$getItem(key: any): any;
                System$Collections$IDictionary$setItem(key: any, value: any): void;
                Count: number;
                containsKey(key: TKey): boolean;
                tryGetValue(key: TKey, value: { v: TValue }): boolean;
                GetEnumerator(): System.Collections.Generic.IEnumerator$1<System.Collections.Generic.KeyValuePair$2<TKey, TValue>> | null;
            }
            interface ReadOnlyDictionary$2Func extends Function {
                <TKey, TValue>($TKey: Bridge.TypeRef<TKey>, $TValue: Bridge.TypeRef<TValue>): {
                    prototype: ReadOnlyDictionary$2<TKey, TValue>;
                    KeyCollection: System.Collections.ObjectModel.ReadOnlyDictionary$2.KeyCollectionFunc;
                    ValueCollection: System.Collections.ObjectModel.ReadOnlyDictionary$2.ValueCollectionFunc;
                    DictionaryEnumerator: System.Collections.ObjectModel.ReadOnlyDictionary$2.DictionaryEnumeratorFunc;
                    new(dictionary: System.Collections.Generic.IDictionary$2<TKey, TValue> | null): ReadOnlyDictionary$2<TKey, TValue>;
                }
            }
            var ReadOnlyDictionary$2: ReadOnlyDictionary$2Func;

            module ReadOnlyDictionary$2 {
                interface KeyCollection<TKey, TValue> extends System.Collections.Generic.ICollection$1<TKey>, System.Collections.ICollection, System.Collections.Generic.IReadOnlyCollection$1<TKey> {
                    Count: number;
                    copyTo(array: TKey[] | null, arrayIndex: number): void;
                    GetEnumerator(): System.Collections.Generic.IEnumerator$1<TKey> | null;
                }
                interface KeyCollectionFunc extends Function {
                    <TKey, TValue>($TKey: Bridge.TypeRef<TKey>, $TValue: Bridge.TypeRef<TValue>): {
                        prototype: KeyCollection<TKey, TValue>;
                    }
                }

                interface ValueCollection<TKey, TValue> extends System.Collections.Generic.ICollection$1<TValue>, System.Collections.ICollection, System.Collections.Generic.IReadOnlyCollection$1<TValue> {
                    Count: number;
                    copyTo(array: TValue[] | null, arrayIndex: number): void;
                    GetEnumerator(): System.Collections.Generic.IEnumerator$1<TValue> | null;
                }
                interface ValueCollectionFunc extends Function {
                    <TKey, TValue>($TKey: Bridge.TypeRef<TKey>, $TValue: Bridge.TypeRef<TValue>): {
                        prototype: ValueCollection<TKey, TValue>;
                    }
                }

                interface DictionaryEnumerator<TKey, TValue> extends System.Collections.IDictionaryEnumerator {
                    Entry: System.Collections.DictionaryEntry;
                    Key: any | null;
                    Value: any | null;
                    Current: any | null;
                    moveNext(): boolean;
                    reset(): void;
                    getHashCode(): number;
                    equals(o: System.Collections.ObjectModel.ReadOnlyDictionary$2.DictionaryEnumerator<TKey, TValue>): boolean;
                    $clone(to: System.Collections.ObjectModel.ReadOnlyDictionary$2.DictionaryEnumerator<TKey, TValue>): System.Collections.ObjectModel.ReadOnlyDictionary$2.DictionaryEnumerator<TKey, TValue>;
                }
                interface DictionaryEnumeratorFunc extends Function {
                    <TKey, TValue>($TKey: Bridge.TypeRef<TKey>, $TValue: Bridge.TypeRef<TValue>): {
                        prototype: DictionaryEnumerator<TKey, TValue>;
                        new(dictionary: System.Collections.Generic.IDictionary$2<TKey, TValue> | null): DictionaryEnumerator<TKey, TValue>;
                    }
                }
            }

            export interface IDictionary$2<TKey, TValue> extends IEnumerable$1<KeyValuePair$2<TKey, TValue>> {
                get(key: TKey): TValue;
                set(key: TKey, value: TValue): void;
                getKeys(): ICollection$1<TKey>;
                getValues(): ICollection$1<TValue>;
                getCount(): number;
                containsKey(key: TKey): boolean;
                add(key: TKey, value: TValue): void;
                remove(key: TKey): boolean;
                tryGetValue(key: TKey, value: { v: TValue }): boolean;
            }
            export function IDictionary$2<TKey, TValue>(tKey: Bridge.TypeRef<TKey>, tValue: Bridge.TypeRef<TValue>): {
                prototype: IDictionary$2<TKey, TValue>;
            }

            export interface IList$1<T> extends ICollection$1<T> {
                getItem(index: number): T;
                setItem(index: number, value: T): void;
                indexOf(item: T): number;
                insert(index: number, item: T): void;
                removeAt(index: number): void;
            }
            export function IList$1<T>(t: Bridge.TypeRef<T>): {
                prototype: IList$1<T>;
            }

            export interface IComparer$1<T> {
                compare(x: T, y: T): number;
            }
            export function IComparer$1<T>(t: Bridge.TypeRef<T>): {
                prototype: IComparer$1<T>;
            }

            export interface EqualityComparer$1<T> extends IEqualityComparer$1<T> {
                equals(x: T, y: T): boolean;
                getHashCode(obj: T): number;
            }
            export function EqualityComparer$1<T>(t: Bridge.TypeRef<T>): {
                prototype: EqualityComparer$1<T>;
                new(): EqualityComparer$1<T>;
            }

            export interface Comparer$1<T> extends IComparer$1<T> {
                compare(x: T, y: T): number;
            }
            export function Comparer$1<T>(t: Bridge.TypeRef<T>): {
                prototype: Comparer$1<T>;
                new(fn: { (x: T, y: T): number }): Comparer$1<T>;
            }

            export interface KeyValuePair$2<TKey, TValue> {
                key: TKey;
                value: TValue;
            }
            export function KeyValuePair$2<TKey, TValue>(tKey: Bridge.TypeRef<TKey>, tValue: Bridge.TypeRef<TValue>): {
                prototype: KeyValuePair$2<TKey, TValue>;
                new(key: TKey, value: TValue): KeyValuePair$2<TKey, TValue>;
            }

            export interface Dictionary$2<TKey, TValue> extends IDictionary$2<TKey, TValue> {
                getKeys(): ICollection$1<TKey>;
                getValues(): ICollection$1<TValue>;
                clear(): void;
                containsKey(key: TKey): boolean;
                containsValue(value: TValue): boolean;
                get(key: TKey): TValue;
                set(key: TKey, value: TValue, add?: boolean): void;
                add(key: TKey, value: TValue): void;
                remove(key: TKey): boolean;
                getCount(): number;
                getComparer(): IEqualityComparer$1<TKey>;
                tryGetValue(key: TKey, value: { v: TValue }): boolean;
                GetEnumerator(): IEnumerator$1<KeyValuePair$2<TKey, TValue>>;
            }
            export function Dictionary$2<TKey, TValue>(tKey: Bridge.TypeRef<TKey>, tValue: Bridge.TypeRef<TValue>): {
                prototype: Dictionary$2<TKey, TValue>;
                new(): Dictionary$2<TKey, TValue>;
                new(obj: Dictionary$2<TKey, TValue>, comparer?: IEqualityComparer$1<TKey>): Dictionary$2<TKey, TValue>;
                new(obj: any, comparer?: IEqualityComparer$1<TKey>): Dictionary$2<TKey, TValue>;
            }

            export interface List$1<T> extends System.Collections.Generic.IList$1<T> {
                Capacity: number;
                Count: number;
                System$Collections$IList$IsReadOnly: boolean;
                GetItem(index: number): T;
                SetItem(index: number, value: T): void;
                System$Collections$IList$GetItem(index: number): any;
                System$Collections$IList$SetItem(index: number, value: any): void;
                Add(item: T): void;
                System$Collections$IList$Add(item: any): number;
                AddRange(collection: System.Collections.Generic.IEnumerable$1<T>): void;
                AsReadOnly(): System.Collections.ObjectModel.ReadOnlyCollection$1<T>;
                BinarySearch$2(index: number, count: number, item: T, comparer: System.Collections.Generic.IComparer$1<T>): number;
                BinarySearch(item: T): number;
                BinarySearch$1(item: T, comparer: System.Collections.Generic.IComparer$1<T>): number;
                Clear(): void;
                Contains(item: T): boolean;
                System$Collections$IList$Contains(item: any): boolean;
                ConvertAll<TOutput>(TOutput: { prototype: TOutput }, converter: { (input: T): TOutput }): System.Collections.Generic.List$1<TOutput>;
                CopyTo$1(array: T[]): void;
                System$Collections$ICollection$CopyTo(array: any[], arrayIndex: number): void;
                CopyTo$2(index: number, array: T[], arrayIndex: number, count: number): void;
                CopyTo(array: T[], arrayIndex: number): void;
                EnsureCapacity(min: number): void;
                Exists(match: { (obj: T): boolean }): boolean;
                Find(match: { (obj: T): boolean }): T;
                FindAll(match: { (obj: T): boolean }): System.Collections.Generic.List$1<T>;
                FindIndex$2(match: { (obj: T): boolean }): number;
                FindIndex$1(startIndex: number, match: { (obj: T): boolean }): number;
                FindIndex(startIndex: number, count: number, match: { (obj: T): boolean }): number;
                FindLast(match: { (obj: T): boolean }): T;
                FindLastIndex$2(match: { (obj: T): boolean }): number;
                FindLastIndex$1(startIndex: number, match: { (obj: T): boolean }): number;
                FindLastIndex(startIndex: number, count: number, match: { (obj: T): boolean }): number;
                ForEach(action: { (arg: T): void }): void;
                GetEnumerator(): IEnumerator$1<T>;
                System$Collections$IEnumerable$GetEnumerator(): System.Collections.IEnumerator;
                GetRange(index: number, count: number): System.Collections.Generic.List$1<T>;
                IndexOf(item: T): number;
                System$Collections$IList$IndexOf(item: any): number;
                IndexOf$1(item: T, index: number): number;
                IndexOf$2(item: T, index: number, count: number): number;
                Insert(index: number, item: T): void;
                System$Collections$IList$Insert(index: number, item: any): void;
                InsertRange(index: number, collection: System.Collections.Generic.IEnumerable$1<T>): void;
                LastIndexOf(item: T): number;
                LastIndexOf$1(item: T, index: number): number;
                LastIndexOf$2(item: T, index: number, count: number): number;
                Remove(item: T): boolean;
                System$Collections$IList$Remove(item: any): void;
                RemoveAll(match: { (obj: T): boolean }): number;
                RemoveAt(index: number): void;
                RemoveRange(index: number, count: number): void;
                Reverse(): void;
                Reverse$1(index: number, count: number): void;
                Sort(): void;
                Sort$1(comparer: System.Collections.Generic.IComparer$1<T>): void;
                Sort$3(index: number, count: number, comparer: System.Collections.Generic.IComparer$1<T>): void;
                Sort$2(comparison: { (x: T, y: T): number }): void;
                ToArray(): T[];
                TrimExcess(): void;
                TrueForAll(match: { (obj: T): boolean }): boolean;
                toJSON(): any;
            }
            export interface List$1Func extends Function {
                <T>($T: Bridge.TypeRef<T>): {
                    prototype: List$1<T>;
                    new(): List$1<T>;
                    ctor: {
                        new(): List$1<T>
                    };
                    $ctor2: {
                        new(capacity: number): List$1<T>
                    };
                    $ctor1: {
                        new(collection: System.Collections.Generic.IEnumerable$1<T>): List$1<T>
                        new(collection: T[]): List$1<T>
                    };
                    IsCompatibleObject(value: any): boolean;
                }
            }
            var List$1: List$1Func;

            export interface LinkedListNode$1<T> {
                List: System.Collections.Generic.LinkedList$1<T> | null;
                Next: System.Collections.Generic.LinkedListNode$1<T> | null;
                Previous: System.Collections.Generic.LinkedListNode$1<T> | null;
                Value: T;
            }

            export interface LinkedListNode$1Func extends Function {
                <T>($T: Bridge.TypeRef<T>): {
                    prototype: LinkedListNode$1<T>;
                    ctor: {
                        new(value: T): LinkedListNode$1<T>
                    };
                }
            }
            var LinkedListNode$1: LinkedListNode$1Func;

            export interface LinkedList$1<T> extends System.Collections.Generic.ICollection$1<T>, System.Collections.ICollection, System.Collections.Generic.IReadOnlyCollection$1<T> {
                Count: number;
                First: System.Collections.Generic.LinkedListNode$1<T> | null;
                Last: System.Collections.Generic.LinkedListNode$1<T> | null;
                AddAfter(node: System.Collections.Generic.LinkedListNode$1<T> | null, value: T): System.Collections.Generic.LinkedListNode$1<T> | null;
                AddAfter$1(node: System.Collections.Generic.LinkedListNode$1<T> | null, newNode: System.Collections.Generic.LinkedListNode$1<T> | null): void;
                AddBefore(node: System.Collections.Generic.LinkedListNode$1<T> | null, value: T): System.Collections.Generic.LinkedListNode$1<T> | null;
                AddBefore$1(node: System.Collections.Generic.LinkedListNode$1<T> | null, newNode: System.Collections.Generic.LinkedListNode$1<T> | null): void;
                AddFirst(value: T): System.Collections.Generic.LinkedListNode$1<T> | null;
                AddFirst$1(node: System.Collections.Generic.LinkedListNode$1<T> | null): void;
                AddLast(value: T): System.Collections.Generic.LinkedListNode$1<T> | null;
                AddLast$1(node: System.Collections.Generic.LinkedListNode$1<T> | null): void;
                clear(): void;
                contains(value: T): boolean;
                copyTo(array: T[] | null, index: number): void;
                Find(value: T): System.Collections.Generic.LinkedListNode$1<T> | null;
                FindLast(value: T): System.Collections.Generic.LinkedListNode$1<T> | null;
                GetEnumerator(): IEnumerator$1<T>;
                remove(value: T): boolean;
                Remove(node: System.Collections.Generic.LinkedListNode$1<T> | null): void;
                RemoveFirst(): void;
                RemoveLast(): void;
            }
            export interface LinkedList$1Func extends Function {
                <T>($T: Bridge.TypeRef<T>): {
                    prototype: LinkedList$1<T>;
                    Enumerator: IEnumerator$1<T>;
                    new(): LinkedList$1<T>;
                    ctor: {
                        new(): LinkedList$1<T>
                    };
                    $ctor1: {
                        new(collection: System.Collections.Generic.IEnumerable$1<T> | null): LinkedList$1<T>
                    };
                }
            }
            var LinkedList$1: LinkedList$1Func;

            export interface SortedList$2<TKey, TValue> extends System.Collections