# encoding: utf-8
# module System.Collections.Generic calls itself Generic
# from mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, Microsoft.Bcl.AsyncInterfaces, Version=1.0.0.0, Culture=neutral, PublicKeyToken=<KEY>
# by generator 1.145
# no doc
# no imports

# no functions
# classes

class Comparer(object, IComparer, IComparer[T]):
    # no doc
    def Compare(self, x, y):
        """ Compare(self: Comparer[T], x: T, y: T) -> int """
        pass

    @staticmethod
    def Create(comparison):
        """ Create(comparison: Comparison[T]) -> Comparer[T] """
        pass

    def __cmp__(self, *args): #cannot find CLR method
        """ x.__cmp__(y) <==> cmp(x,y) """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass


class Dictionary(object, IDictionary[TKey, TValue], ICollection[KeyValuePair[TKey, TValue]], IEnumerable[KeyValuePair[TKey, TValue]], IEnumerable, IDictionary, ICollection, IReadOnlyDictionary[TKey, TValue], IReadOnlyCollection[KeyValuePair[TKey, TValue]], ISerializable, IDeserializationCallback):
    """
    Dictionary[TKey, TValue]()

    Dictionary[TKey, TValue](capacity: int)

    Dictionary[TKey, TValue](comparer: IEqualityComparer[TKey])

    Dictionary[TKey, TValue](capacity: int, comparer: IEqualityComparer[TKey])

    Dictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue])

    Dictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue], comparer: IEqualityComparer[TKey])
    """
    def Add(self, key, value):
        """ Add(self: Dictionary[TKey, TValue], key: TKey, value: TValue) """
        pass

    def Clear(self):
        """ Clear(self: Dictionary[TKey, TValue]) """
        pass

    def ContainsKey(self, key):
        """ ContainsKey(self: Dictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def ContainsValue(self, value):
        """ ContainsValue(self: Dictionary[TKey, TValue], value: TValue) -> bool """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: Dictionary[TKey, TValue]) -> Enumerator """
        pass

    def GetObjectData(self, info, context):
        """ GetObjectData(self: Dictionary[TKey, TValue], info: SerializationInfo, context: StreamingContext) """
        pass

    def OnDeserialization(self, sender):
        """ OnDeserialization(self: Dictionary[TKey, TValue], sender: object) """
        pass

    def Remove(self, key):
        """ Remove(self: Dictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def TryGetValue(self, key, value):
        """ TryGetValue(self: Dictionary[TKey, TValue], key: TKey) -> (bool, TValue) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """
        __contains__(self: IDictionary[TKey, TValue], key: TKey) -> bool

        __contains__(self: IDictionary, key: object) -> bool
        """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, capacity: int)

        __new__(cls: type, comparer: IEqualityComparer[TKey])

        __new__(cls: type, capacity: int, comparer: IEqualityComparer[TKey])

        __new__(cls: type, dictionary: IDictionary[TKey, TValue])

        __new__(cls: type, dictionary: IDictionary[TKey, TValue], comparer: IEqualityComparer[TKey])

        __new__(cls: type, info: SerializationInfo, context: StreamingContext)
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """
        __repr__(self: Dictionary[TKey, TValue]) -> str

        __repr__(self: Dictionary[K, V]) -> str
        """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass

    Comparer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Comparer(self: Dictionary[TKey, TValue]) -> IEqualityComparer[TKey]



"""

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: Dictionary[TKey, TValue]) -> int



"""

    Keys = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Keys(self: Dictionary[TKey, TValue]) -> KeyCollection



"""

    Values = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Values(self: Dictionary[TKey, TValue]) -> ValueCollection



"""


    Enumerator = None
    KeyCollection = None
    ValueCollection = None


class EqualityComparer(object, IEqualityComparer, IEqualityComparer[T]):
    # no doc
    def Equals(self, *__args):
        """ Equals(self: EqualityComparer[T], x: T, y: T) -> bool """
        pass

    def GetHashCode(self, obj=None):
        """ GetHashCode(self: EqualityComparer[T], obj: T) -> int """
        pass

    def __eq__(self, *args): #cannot find CLR method
        """ x.__eq__(y) <==> x==y """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass


class IAsyncEnumerable:
    # no doc
    def GetAsyncEnumerator(self, cancellationToken):
        """
        GetAsyncEnumerator(self: IAsyncEnumerable[T], cancellationToken: CancellationToken) -> IAsyncEnumerator[T]

        

            Returns an enumerator that iterates asynchronously through the collection.

        

            cancellationToken: A System.Threading.CancellationToken that may be used to cancel the asynchronous iteration.

            Returns: An enumerator that can be used to iterate asynchronously through the collection.
        """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass


class IAsyncEnumerator(IAsyncDisposable):
    # no doc
    def MoveNextAsync(self):
        """
        MoveNextAsync(self: IAsyncEnumerator[T]) -> ValueTask[bool]

        

            Advances the enumerator asynchronously to the next element of the collection.

            Returns: A System.Threading.Tasks.ValueTask that will complete with a result of true if the enumerator

                    was successfully advanced to the next element, or false if the enumerator 

             has passed the end

                    of the collection.
        """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    Current = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Gets the element in the collection at the current position of the enumerator.



Get: Current(self: IAsyncEnumerator[T]) -> T



"""



class ICollection(IEnumerable[T], IEnumerable):
    # no doc
    def Add(self, item):
        """ Add(self: ICollection[T], item: T) """
        pass

    def Clear(self):
        """ Clear(self: ICollection[T]) """
        pass

    def Contains(self, item):
        """ Contains(self: ICollection[T], item: T) -> bool """
        pass

    def CopyTo(self, array, arrayIndex):
        """ CopyTo(self: ICollection[T], array: Array[T], arrayIndex: int) """
        pass

    def Remove(self, item):
        """ Remove(self: ICollection[T], item: T) -> bool """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[T](enumerable: IEnumerable[T], value: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: ICollection[T]) -> int



"""

    IsReadOnly = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: IsReadOnly(self: ICollection[T]) -> bool



"""



class IComparer:
    # no doc
    def Compare(self, x, y):
        """ Compare(self: IComparer[T], x: T, y: T) -> int """
        pass

    def __cmp__(self, *args): #cannot find CLR method
        """ x.__cmp__(y) <==> cmp(x,y) """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass


class IDictionary(ICollection[KeyValuePair[TKey, TValue]], IEnumerable[KeyValuePair[TKey, TValue]], IEnumerable):
    # no doc
    def Add(self, key, value):
        """ Add(self: IDictionary[TKey, TValue], key: TKey, value: TValue) """
        pass

    def ContainsKey(self, key):
        """ ContainsKey(self: IDictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def Remove(self, key):
        """ Remove(self: IDictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def TryGetValue(self, key, value):
        """ TryGetValue(self: IDictionary[TKey, TValue], key: TKey) -> (bool, TValue) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__(self: ICollection[KeyValuePair[TKey, TValue]], item: KeyValuePair[TKey, TValue]) -> bool """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass

    Keys = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Keys(self: IDictionary[TKey, TValue]) -> ICollection[TKey]



"""

    Values = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Values(self: IDictionary[TKey, TValue]) -> ICollection[TValue]



"""



class IEnumerable(IEnumerable):
    # no doc
    def GetEnumerator(self):
        """ GetEnumerator(self: IEnumerable[T]) -> IEnumerator[T] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass


class IEnumerator(IDisposable, IEnumerator):
    # no doc
    def next(self, *args): #cannot find CLR method
        """ next(self: object) -> object """
        pass

    def __enter__(self, *args): #cannot find CLR method
        """ __enter__(self: IDisposable) -> object """
        pass

    def __exit__(self, *args): #cannot find CLR method
        """ __exit__(self: IDisposable, exc_type: object, exc_value: object, exc_back: object) """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__[T](self: IEnumerator[T]) -> object """
        pass

    Current = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Current(self: IEnumerator[T]) -> T



"""



class IEqualityComparer:
    # no doc
    def Equals(self, x, y):
        """ Equals(self: IEqualityComparer[T], x: T, y: T) -> bool """
        pass

    def GetHashCode(self, obj):
        """ GetHashCode(self: IEqualityComparer[T], obj: T) -> int """
        pass

    def __eq__(self, *args): #cannot find CLR method
        """ x.__eq__(y) <==> x==y """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass


class IList(ICollection[T], IEnumerable[T], IEnumerable):
    # no doc
    def IndexOf(self, item):
        """ IndexOf(self: IList[T], item: T) -> int """
        pass

    def Insert(self, index, item):
        """ Insert(self: IList[T], index: int, item: T) """
        pass

    def RemoveAt(self, index):
        """ RemoveAt(self: IList[T], index: int) """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__(self: ICollection[T], item: T) -> bool """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass


class IReadOnlyCollection(IEnumerable[T], IEnumerable):
    # no doc
    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[T](enumerable: IEnumerable[T], value: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: IReadOnlyCollection[T]) -> int



"""



class IReadOnlyDictionary(IReadOnlyCollection[KeyValuePair[TKey, TValue]], IEnumerable[KeyValuePair[TKey, TValue]], IEnumerable):
    # no doc
    def ContainsKey(self, key):
        """ ContainsKey(self: IReadOnlyDictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def TryGetValue(self, key, value):
        """ TryGetValue(self: IReadOnlyDictionary[TKey, TValue], key: TKey) -> (bool, TValue) """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[KeyValuePair`2](enumerable: IEnumerable[KeyValuePair[TKey, TValue]], value: KeyValuePair[TKey, TValue]) -> bool """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    Keys = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Keys(self: IReadOnlyDictionary[TKey, TValue]) -> IEnumerable[TKey]



"""

    Values = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Values(self: IReadOnlyDictionary[TKey, TValue]) -> IEnumerable[TValue]



"""



class IReadOnlyList(IReadOnlyCollection[T], IEnumerable[T], IEnumerable):
    # no doc
    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[T](enumerable: IEnumerable[T], value: T) -> bool """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass


class ISet(ICollection[T], IEnumerable[T], IEnumerable):
    # no doc
    def Add(self, item):
        """ Add(self: ISet[T], item: T) -> bool """
        pass

    def ExceptWith(self, other):
        """ ExceptWith(self: ISet[T], other: IEnumerable[T]) """
        pass

    def IntersectWith(self, other):
        """ IntersectWith(self: ISet[T], other: IEnumerable[T]) """
        pass

    def IsProperSubsetOf(self, other):
        """ IsProperSubsetOf(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsProperSupersetOf(self, other):
        """ IsProperSupersetOf(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsSubsetOf(self, other):
        """ IsSubsetOf(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsSupersetOf(self, other):
        """ IsSupersetOf(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def Overlaps(self, other):
        """ Overlaps(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def SetEquals(self, other):
        """ SetEquals(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def SymmetricExceptWith(self, other):
        """ SymmetricExceptWith(self: ISet[T], other: IEnumerable[T]) """
        pass

    def UnionWith(self, other):
        """ UnionWith(self: ISet[T], other: IEnumerable[T]) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__(self: ICollection[T], item: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass


class KeyNotFoundException(SystemException, ISerializable, _Exception):
    """
    KeyNotFoundException()

    KeyNotFoundException(message: str)

    KeyNotFoundException(message: str, innerException: Exception)
    """
    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    @staticmethod # known case of __new__
    def __new__(self, message=None, innerException=None):
        """
        __new__(cls: type)

        __new__(cls: type, message: str)

        __new__(cls: type, message: str, innerException: Exception)

        __new__(cls: type, info: SerializationInfo, context: StreamingContext)
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __str__(self, *args): #cannot find CLR method
        pass

    SerializeObjectState = None


class KeyValuePair(object):
    """ KeyValuePair[TKey, TValue](key: TKey, value: TValue) """
    def ToString(self):
        """ ToString(self: KeyValuePair[TKey, TValue]) -> str """
        pass

    @staticmethod # known case of __new__
    def __new__(self, key, value):
        """
        __new__[KeyValuePair`2]() -> KeyValuePair[TKey, TValue]

        

        __new__(cls: type, key: TKey, value: TValue)
        """
        pass

    Key = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Key(self: KeyValuePair[TKey, TValue]) -> TKey



"""

    Value = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Value(self: KeyValuePair[TKey, TValue]) -> TValue



"""



class LinkedList(object, ICollection[T], IEnumerable[T], IEnumerable, ICollection, IReadOnlyCollection[T], ISerializable, IDeserializationCallback):
    """
    LinkedList[T]()

    LinkedList[T](collection: IEnumerable[T])
    """
    def AddAfter(self, node, *__args):
        """ AddAfter(self: LinkedList[T], node: LinkedListNode[T], newNode: LinkedListNode[T])AddAfter(self: LinkedList[T], node: LinkedListNode[T], value: T) -> LinkedListNode[T] """
        pass

    def AddBefore(self, node, *__args):
        """
        AddBefore(self: LinkedList[T], node: LinkedListNode[T], value: T) -> LinkedListNode[T]

        AddBefore(self: LinkedList[T], node: LinkedListNode[T], newNode: LinkedListNode[T])
        """
        pass

    def AddFirst(self, *__args):
        """
        AddFirst(self: LinkedList[T], value: T) -> LinkedListNode[T]

        AddFirst(self: LinkedList[T], node: LinkedListNode[T])
        """
        pass

    def AddLast(self, *__args):
        """
        AddLast(self: LinkedList[T], value: T) -> LinkedListNode[T]

        AddLast(self: LinkedList[T], node: LinkedListNode[T])
        """
        pass

    def Clear(self):
        """ Clear(self: LinkedList[T]) """
        pass

    def Contains(self, value):
        """ Contains(self: LinkedList[T], value: T) -> bool """
        pass

    def CopyTo(self, array, index):
        """ CopyTo(self: LinkedList[T], array: Array[T], index: int) """
        pass

    def Find(self, value):
        """ Find(self: LinkedList[T], value: T) -> LinkedListNode[T] """
        pass

    def FindLast(self, value):
        """ FindLast(self: LinkedList[T], value: T) -> LinkedListNode[T] """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: LinkedList[T]) -> Enumerator """
        pass

    def GetObjectData(self, info, context):
        """ GetObjectData(self: LinkedList[T], info: SerializationInfo, context: StreamingContext) """
        pass

    def OnDeserialization(self, sender):
        """ OnDeserialization(self: LinkedList[T], sender: object) """
        pass

    def Remove(self, *__args):
        """
        Remove(self: LinkedList[T], value: T) -> bool

        Remove(self: LinkedList[T], node: LinkedListNode[T])
        """
        pass

    def RemoveFirst(self):
        """ RemoveFirst(self: LinkedList[T]) """
        pass

    def RemoveLast(self):
        """ RemoveLast(self: LinkedList[T]) """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__(self: ICollection[T], item: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, collection=None):
        """
        __new__(cls: type)

        __new__(cls: type, collection: IEnumerable[T])

        __new__(cls: type, info: SerializationInfo, context: StreamingContext)
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: LinkedList[T]) -> int



"""

    First = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: First(self: LinkedList[T]) -> LinkedListNode[T]



"""

    Last = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Last(self: LinkedList[T]) -> LinkedListNode[T]



"""


    Enumerator = None


class LinkedListNode(object):
    """ LinkedListNode[T](value: T) """
    @staticmethod # known case of __new__
    def __new__(self, value):
        """ __new__(cls: type, value: T) """
        pass

    List = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: List(self: LinkedListNode[T]) -> LinkedList[T]



"""

    Next = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Next(self: LinkedListNode[T]) -> LinkedListNode[T]



"""

    Previous = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Previous(self: LinkedListNode[T]) -> LinkedListNode[T]



"""

    Value = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Value(self: LinkedListNode[T]) -> T



Set: Value(self: LinkedListNode[T]) = value

"""



class List(object, IList[T], ICollection[T], IEnumerable[T], IEnumerable, IList, ICollection, IReadOnlyList[T], IReadOnlyCollection[T]):
    """
    List[T]()

    List[T](capacity: int)

    List[T](collection: IEnumerable[T])
    """
    def Add(self, item):
        """ Add(self: List[T], item: T) """
        pass

    def AddRange(self, collection):
        """ AddRange(self: List[T], collection: IEnumerable[T]) """
        pass

    def AsReadOnly(self):
        """ AsReadOnly(self: List[T]) -> ReadOnlyCollection[T] """
        pass

    def BinarySearch(self, *__args):
        """
        BinarySearch(self: List[T], index: int, count: int, item: T, comparer: IComparer[T]) -> int

        BinarySearch(self: List[T], item: T) -> int

        BinarySearch(self: List[T], item: T, comparer: IComparer[T]) -> int
        """
        pass

    def Clear(self):
        """ Clear(self: List[T]) """
        pass

    def Contains(self, item):
        """ Contains(self: List[T], item: T) -> bool """
        pass

    def ConvertAll(self, converter):
        """ ConvertAll[TOutput](self: List[T], converter: Converter[T, TOutput]) -> List[TOutput] """
        pass

    def CopyTo(self, *__args):
        """ CopyTo(self: List[T], index: int, array: Array[T], arrayIndex: int, count: int)CopyTo(self: List[T], array: Array[T])CopyTo(self: List[T], array: Array[T], arrayIndex: int) """
        pass

    def Exists(self, match):
        """ Exists(self: List[T], match: Predicate[T]) -> bool """
        pass

    def Find(self, match):
        """ Find(self: List[T], match: Predicate[T]) -> T """
        pass

    def FindAll(self, match):
        """ FindAll(self: List[T], match: Predicate[T]) -> List[T] """
        pass

    def FindIndex(self, *__args):
        """
        FindIndex(self: List[T], match: Predicate[T]) -> int

        FindIndex(self: List[T], startIndex: int, match: Predicate[T]) -> int

        FindIndex(self: List[T], startIndex: int, count: int, match: Predicate[T]) -> int
        """
        pass

    def FindLast(self, match):
        """ FindLast(self: List[T], match: Predicate[T]) -> T """
        pass

    def FindLastIndex(self, *__args):
        """
        FindLastIndex(self: List[T], match: Predicate[T]) -> int

        FindLastIndex(self: List[T], startIndex: int, match: Predicate[T]) -> int

        FindLastIndex(self: List[T], startIndex: int, count: int, match: Predicate[T]) -> int
        """
        pass

    def ForEach(self, action):
        """ ForEach(self: List[T], action: Action[T]) """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: List[T]) -> Enumerator """
        pass

    def GetRange(self, index, count):
        """ GetRange(self: List[T], index: int, count: int) -> List[T] """
        pass

    def IndexOf(self, item, index=None, count=None):
        """
        IndexOf(self: List[T], item: T) -> int

        IndexOf(self: List[T], item: T, index: int) -> int

        IndexOf(self: List[T], item: T, index: int, count: int) -> int
        """
        pass

    def Insert(self, index, item):
        """ Insert(self: List[T], index: int, item: T) """
        pass

    def InsertRange(self, index, collection):
        """ InsertRange(self: List[T], index: int, collection: IEnumerable[T]) """
        pass

    def LastIndexOf(self, item, index=None, count=None):
        """
        LastIndexOf(self: List[T], item: T) -> int

        LastIndexOf(self: List[T], item: T, index: int) -> int

        LastIndexOf(self: List[T], item: T, index: int, count: int) -> int
        """
        pass

    def Remove(self, item):
        """ Remove(self: List[T], item: T) -> bool """
        pass

    def RemoveAll(self, match):
        """ RemoveAll(self: List[T], match: Predicate[T]) -> int """
        pass

    def RemoveAt(self, index):
        """ RemoveAt(self: List[T], index: int) """
        pass

    def RemoveRange(self, index, count):
        """ RemoveRange(self: List[T], index: int, count: int) """
        pass

    def Reverse(self, index=None, count=None):
        """ Reverse(self: List[T], index: int, count: int)Reverse(self: List[T]) """
        pass

    def Sort(self, *__args):
        """ Sort(self: List[T])Sort(self: List[T], comparer: IComparer[T])Sort(self: List[T], index: int, count: int, comparer: IComparer[T])Sort(self: List[T], comparison: Comparison[T]) """
        pass

    def ToArray(self):
        """ ToArray(self: List[T]) -> Array[T] """
        pass

    def TrimExcess(self):
        """ TrimExcess(self: List[T]) """
        pass

    def TrueForAll(self, match):
        """ TrueForAll(self: List[T], match: Predicate[T]) -> bool """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """
        __contains__(self: ICollection[T], item: T) -> bool

        __contains__(self: IList, value: object) -> bool
        """
        pass

    def __delitem__(self, *args): #cannot find CLR method
        """ x.__delitem__(y) <==> del x[y]x.__delitem__(y) <==> del x[y]x.__delitem__(y) <==> del x[y] """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __getslice__(self, *args): #cannot find CLR method
        """
        __getslice__(self: List[T], x: int, y: int) -> List[T]

        __getslice__(self: List[T], x: int, y: int) -> List[T]
        """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, capacity: int)

        __new__(cls: type, collection: IEnumerable[T])
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """
        __repr__(self: List[T]) -> str

        __repr__(self: List[T]) -> str
        """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass

    Capacity = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Capacity(self: List[T]) -> int



Set: Capacity(self: List[T]) = value

"""

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: List[T]) -> int



"""


    Enumerator = None


class Queue(object, IEnumerable[T], IEnumerable, ICollection, IReadOnlyCollection[T]):
    """
    Queue[T]()

    Queue[T](capacity: int)

    Queue[T](collection: IEnumerable[T])
    """
    def Clear(self):
        """ Clear(self: Queue[T]) """
        pass

    def Contains(self, item):
        """ Contains(self: Queue[T], item: T) -> bool """
        pass

    def CopyTo(self, array, arrayIndex):
        """ CopyTo(self: Queue[T], array: Array[T], arrayIndex: int) """
        pass

    def Dequeue(self):
        """ Dequeue(self: Queue[T]) -> T """
        pass

    def Enqueue(self, item):
        """ Enqueue(self: Queue[T], item: T) """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: Queue[T]) -> Enumerator """
        pass

    def Peek(self):
        """ Peek(self: Queue[T]) -> T """
        pass

    def ToArray(self):
        """ ToArray(self: Queue[T]) -> Array[T] """
        pass

    def TrimExcess(self):
        """ TrimExcess(self: Queue[T]) """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[T](enumerable: IEnumerable[T], value: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, capacity: int)

        __new__(cls: type, collection: IEnumerable[T])
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: Queue[T]) -> int



"""


    Enumerator = None


class SortedDictionary(object, IDictionary[TKey, TValue], ICollection[KeyValuePair[TKey, TValue]], IEnumerable[KeyValuePair[TKey, TValue]], IEnumerable, IDictionary, ICollection, IReadOnlyDictionary[TKey, TValue], IReadOnlyCollection[KeyValuePair[TKey, TValue]]):
    """
    SortedDictionary[TKey, TValue]()

    SortedDictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue])

    SortedDictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey])

    SortedDictionary[TKey, TValue](comparer: IComparer[TKey])
    """
    def Add(self, key, value):
        """ Add(self: SortedDictionary[TKey, TValue], key: TKey, value: TValue) """
        pass

    def Clear(self):
        """ Clear(self: SortedDictionary[TKey, TValue]) """
        pass

    def ContainsKey(self, key):
        """ ContainsKey(self: SortedDictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def ContainsValue(self, value):
        """ ContainsValue(self: SortedDictionary[TKey, TValue], value: TValue) -> bool """
        pass

    def CopyTo(self, array, index):
        """ CopyTo(self: SortedDictionary[TKey, TValue], array: Array[KeyValuePair[TKey, TValue]], index: int) """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: SortedDictionary[TKey, TValue]) -> Enumerator """
        pass

    def Remove(self, key):
        """ Remove(self: SortedDictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def TryGetValue(self, key, value):
        """ TryGetValue(self: SortedDictionary[TKey, TValue], key: TKey) -> (bool, TValue) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """
        __contains__(self: IDictionary[TKey, TValue], key: TKey) -> bool

        __contains__(self: IDictionary, key: object) -> bool
        """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, dictionary: IDictionary[TKey, TValue])

        __new__(cls: type, dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey])

        __new__(cls: type, comparer: IComparer[TKey])
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass

    Comparer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Comparer(self: SortedDictionary[TKey, TValue]) -> IComparer[TKey]



"""

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: SortedDictionary[TKey, TValue]) -> int



"""

    Keys = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Keys(self: SortedDictionary[TKey, TValue]) -> KeyCollection



"""

    Values = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Values(self: SortedDictionary[TKey, TValue]) -> ValueCollection



"""


    Enumerator = None
    KeyCollection = None
    ValueCollection = None


class SortedList(object, IDictionary[TKey, TValue], ICollection[KeyValuePair[TKey, TValue]], IEnumerable[KeyValuePair[TKey, TValue]], IEnumerable, IDictionary, ICollection, IReadOnlyDictionary[TKey, TValue], IReadOnlyCollection[KeyValuePair[TKey, TValue]]):
    """
    SortedList[TKey, TValue]()

    SortedList[TKey, TValue](capacity: int)

    SortedList[TKey, TValue](comparer: IComparer[TKey])

    SortedList[TKey, TValue](capacity: int, comparer: IComparer[TKey])

    SortedList[TKey, TValue](dictionary: IDictionary[TKey, TValue])

    SortedList[TKey, TValue](dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey])
    """
    def Add(self, key, value):
        """ Add(self: SortedList[TKey, TValue], key: TKey, value: TValue) """
        pass

    def Clear(self):
        """ Clear(self: SortedList[TKey, TValue]) """
        pass

    def ContainsKey(self, key):
        """ ContainsKey(self: SortedList[TKey, TValue], key: TKey) -> bool """
        pass

    def ContainsValue(self, value):
        """ ContainsValue(self: SortedList[TKey, TValue], value: TValue) -> bool """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: SortedList[TKey, TValue]) -> IEnumerator[KeyValuePair[TKey, TValue]] """
        pass

    def IndexOfKey(self, key):
        """ IndexOfKey(self: SortedList[TKey, TValue], key: TKey) -> int """
        pass

    def IndexOfValue(self, value):
        """ IndexOfValue(self: SortedList[TKey, TValue], value: TValue) -> int """
        pass

    def Remove(self, key):
        """ Remove(self: SortedList[TKey, TValue], key: TKey) -> bool """
        pass

    def RemoveAt(self, index):
        """ RemoveAt(self: SortedList[TKey, TValue], index: int) """
        pass

    def TrimExcess(self):
        """ TrimExcess(self: SortedList[TKey, TValue]) """
        pass

    def TryGetValue(self, key, value):
        """ TryGetValue(self: SortedList[TKey, TValue], key: TKey) -> (bool, TValue) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """
        __contains__(self: IDictionary[TKey, TValue], key: TKey) -> bool

        __contains__(self: IDictionary, key: object) -> bool
        """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, capacity: int)

        __new__(cls: type, comparer: IComparer[TKey])

        __new__(cls: type, capacity: int, comparer: IComparer[TKey])

        __new__(cls: type, dictionary: IDictionary[TKey, TValue])

        __new__(cls: type, dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey])
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass

    Capacity = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Capacity(self: SortedList[TKey, TValue]) -> int



Set: Capacity(self: SortedList[TKey, TValue]) = value

"""

    Comparer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Comparer(self: SortedList[TKey, TValue]) -> IComparer[TKey]



"""

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: SortedList[TKey, TValue]) -> int



"""

    Keys = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Keys(self: SortedList[TKey, TValue]) -> IList[TKey]



"""

    Values = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Values(self: SortedList[TKey, TValue]) -> IList[TValue]



"""



class SortedSet(object, ISet[T], ICollection[T], IEnumerable[T], IEnumerable, ICollection, ISerializable, IDeserializationCallback, IReadOnlyCollection[T]):
    """
    SortedSet[T]()

    SortedSet[T](comparer: IComparer[T])

    SortedSet[T](collection: IEnumerable[T])

    SortedSet[T](collection: IEnumerable[T], comparer: IComparer[T])
    """
    def Add(self, item):
        """ Add(self: SortedSet[T], item: T) -> bool """
        pass

    def Clear(self):
        """ Clear(self: SortedSet[T]) """
        pass

    def Contains(self, item):
        """ Contains(self: SortedSet[T], item: T) -> bool """
        pass

    def CopyTo(self, array, index=None, count=None):
        """ CopyTo(self: SortedSet[T], array: Array[T])CopyTo(self: SortedSet[T], array: Array[T], index: int)CopyTo(self: SortedSet[T], array: Array[T], index: int, count: int) """
        pass

    @staticmethod
    def CreateSetComparer(memberEqualityComparer=None):
        """
        CreateSetComparer() -> IEqualityComparer[SortedSet[T]]

        CreateSetComparer(memberEqualityComparer: IEqualityComparer[T]) -> IEqualityComparer[SortedSet[T]]
        """
        pass

    def ExceptWith(self, other):
        """ ExceptWith(self: SortedSet[T], other: IEnumerable[T]) """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: SortedSet[T]) -> Enumerator """
        pass

    def GetObjectData(self, *args): #cannot find CLR method
        """ GetObjectData(self: SortedSet[T], info: SerializationInfo, context: StreamingContext) """
        pass

    def GetViewBetween(self, lowerValue, upperValue):
        """ GetViewBetween(self: SortedSet[T], lowerValue: T, upperValue: T) -> SortedSet[T] """
        pass

    def IntersectWith(self, other):
        """ IntersectWith(self: SortedSet[T], other: IEnumerable[T]) """
        pass

    def IsProperSubsetOf(self, other):
        """ IsProperSubsetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsProperSupersetOf(self, other):
        """ IsProperSupersetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsSubsetOf(self, other):
        """ IsSubsetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsSupersetOf(self, other):
        """ IsSupersetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def OnDeserialization(self, *args): #cannot find CLR method
        """ OnDeserialization(self: SortedSet[T], sender: object) """
        pass

    def Overlaps(self, other):
        """ Overlaps(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def Remove(self, item):
        """ Remove(self: SortedSet[T], item: T) -> bool """
        pass

    def RemoveWhere(self, match):
        """ RemoveWhere(self: SortedSet[T], match: Predicate[T]) -> int """
        pass

    def Reverse(self):
        """ Reverse(self: SortedSet[T]) -> IEnumerable[T] """
        pass

    def SetEquals(self, other):
        """ SetEquals(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def SymmetricExceptWith(self, other):
        """ SymmetricExceptWith(self: SortedSet[T], other: IEnumerable[T]) """
        pass

    def TryGetValue(self, equalValue, actualValue):
        """ TryGetValue(self: SortedSet[T], equalValue: T) -> (bool, T) """
        pass

    def UnionWith(self, other):
        """ UnionWith(self: SortedSet[T], other: IEnumerable[T]) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__(self: ICollection[T], item: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, comparer: IComparer[T])

        __new__(cls: type, collection: IEnumerable[T])

        __new__(cls: type, collection: IEnumerable[T], comparer: IComparer[T])

        __new__(cls: type, info: SerializationInfo, context: StreamingContext)
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    Comparer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Comparer(self: SortedSet[T]) -> IComparer[T]



"""

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: SortedSet[T]) -> int



"""

    Max = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Max(self: SortedSet[T]) -> T



"""

    Min = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Min(self: SortedSet[T]) -> T



"""


    Enumerator = None


class Stack(object, IEnumerable[T], IEnumerable, ICollection, IReadOnlyCollection[T]):
    """
    Stack[T]()

    Stack[T](capacity: int)

    Stack[T](collection: IEnumerable[T])
    """
    def Clear(self):
        """ Clear(self: Stack[T]) """
        pass

    def Contains(self, item):
        """ Contains(self: Stack[T], item: T) -> bool """
        pass

    def CopyTo(self, array, arrayIndex):
        """ CopyTo(self: Stack[T], array: Array[T], arrayIndex: int) """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: Stack[T]) -> Enumerator """
        pass

    def Peek(self):
        """ Peek(self: Stack[T]) -> T """
        pass

    def Pop(self):
        """ Pop(self: Stack[T]) -> T """
        pass

    def Push(self, item):
        """ Push(self: Stack[T], item: T) """
        pass

    def ToArray(self):
        """ ToArray(self: Stack[T]) -> Array[T] """
        pass

    def TrimExcess(self):
        """ TrimExcess(self: Stack[T]) """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[T](enumerable: IEnumerable[T], value: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, capacity: int)

        __new__(cls: type, collection: IEnumerable[T])
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: Stack[T]) -> int



"""


    Enumerator = None



# encoding: utf-8
# module System.Collections.Generic calls itself Generic
# from mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, Microsoft.Bcl.AsyncInterfaces, Version=1.0.0.0, Culture=neutral, PublicKeyToken=<KEY>
# by generator 1.145
# no doc
# no imports

# no functions
# classes

class Comparer(object, IComparer, IComparer[T]):
    # no doc
    def Compare(self, x, y):
        """ Compare(self: Comparer[T], x: T, y: T) -> int """
        pass

    @staticmethod
    def Create(comparison):
        """ Create(comparison: Comparison[T]) -> Comparer[T] """
        pass

    def __cmp__(self, *args): #cannot find CLR method
        """ x.__cmp__(y) <==> cmp(x,y) """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass


class Dictionary(object, IDictionary[TKey, TValue], ICollection[KeyValuePair[TKey, TValue]], IEnumerable[KeyValuePair[TKey, TValue]], IEnumerable, IDictionary, ICollection, IReadOnlyDictionary[TKey, TValue], IReadOnlyCollection[KeyValuePair[TKey, TValue]], ISerializable, IDeserializationCallback):
    """
    Dictionary[TKey, TValue]()

    Dictionary[TKey, TValue](capacity: int)

    Dictionary[TKey, TValue](comparer: IEqualityComparer[TKey])

    Dictionary[TKey, TValue](capacity: int, comparer: IEqualityComparer[TKey])

    Dictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue])

    Dictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue], comparer: IEqualityComparer[TKey])
    """
    def Add(self, key, value):
        """ Add(self: Dictionary[TKey, TValue], key: TKey, value: TValue) """
        pass

    def Clear(self):
        """ Clear(self: Dictionary[TKey, TValue]) """
        pass

    def ContainsKey(self, key):
        """ ContainsKey(self: Dictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def ContainsValue(self, value):
        """ ContainsValue(self: Dictionary[TKey, TValue], value: TValue) -> bool """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: Dictionary[TKey, TValue]) -> Enumerator """
        pass

    def GetObjectData(self, info, context):
        """ GetObjectData(self: Dictionary[TKey, TValue], info: SerializationInfo, context: StreamingContext) """
        pass

    def OnDeserialization(self, sender):
        """ OnDeserialization(self: Dictionary[TKey, TValue], sender: object) """
        pass

    def Remove(self, key):
        """ Remove(self: Dictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def TryGetValue(self, key, value):
        """ TryGetValue(self: Dictionary[TKey, TValue], key: TKey) -> (bool, TValue) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """
        __contains__(self: IDictionary[TKey, TValue], key: TKey) -> bool

        __contains__(self: IDictionary, key: object) -> bool
        """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, capacity: int)

        __new__(cls: type, comparer: IEqualityComparer[TKey])

        __new__(cls: type, capacity: int, comparer: IEqualityComparer[TKey])

        __new__(cls: type, dictionary: IDictionary[TKey, TValue])

        __new__(cls: type, dictionary: IDictionary[TKey, TValue], comparer: IEqualityComparer[TKey])

        __new__(cls: type, info: SerializationInfo, context: StreamingContext)
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """
        __repr__(self: Dictionary[TKey, TValue]) -> str

        __repr__(self: Dictionary[K, V]) -> str
        """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass

    Comparer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Comparer(self: Dictionary[TKey, TValue]) -> IEqualityComparer[TKey]



"""

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: Dictionary[TKey, TValue]) -> int



"""

    Keys = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Keys(self: Dictionary[TKey, TValue]) -> KeyCollection



"""

    Values = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Values(self: Dictionary[TKey, TValue]) -> ValueCollection



"""


    Enumerator = None
    KeyCollection = None
    ValueCollection = None


class EqualityComparer(object, IEqualityComparer, IEqualityComparer[T]):
    # no doc
    def Equals(self, *__args):
        """ Equals(self: EqualityComparer[T], x: T, y: T) -> bool """
        pass

    def GetHashCode(self, obj=None):
        """ GetHashCode(self: EqualityComparer[T], obj: T) -> int """
        pass

    def __eq__(self, *args): #cannot find CLR method
        """ x.__eq__(y) <==> x==y """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass


class IAsyncEnumerable:
    # no doc
    def GetAsyncEnumerator(self, cancellationToken):
        """
        GetAsyncEnumerator(self: IAsyncEnumerable[T], cancellationToken: CancellationToken) -> IAsyncEnumerator[T]

        

            Returns an enumerator that iterates asynchronously through the collection.

        

            cancellationToken: A System.Threading.CancellationToken that may be used to cancel the asynchronous iteration.

            Returns: An enumerator that can be used to iterate asynchronously through the collection.
        """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass


class IAsyncEnumerator(IAsyncDisposable):
    # no doc
    def MoveNextAsync(self):
        """
        MoveNextAsync(self: IAsyncEnumerator[T]) -> ValueTask[bool]

        

            Advances the enumerator asynchronously to the next element of the collection.

            Returns: A System.Threading.Tasks.ValueTask that will complete with a result of true if the enumerator

                    was successfully advanced to the next element, or false if the enumerator 

             has passed the end

                    of the collection.
        """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    Current = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Gets the element in the collection at the current position of the enumerator.



Get: Current(self: IAsyncEnumerator[T]) -> T



"""



class ICollection(IEnumerable[T], IEnumerable):
    # no doc
    def Add(self, item):
        """ Add(self: ICollection[T], item: T) """
        pass

    def Clear(self):
        """ Clear(self: ICollection[T]) """
        pass

    def Contains(self, item):
        """ Contains(self: ICollection[T], item: T) -> bool """
        pass

    def CopyTo(self, array, arrayIndex):
        """ CopyTo(self: ICollection[T], array: Array[T], arrayIndex: int) """
        pass

    def Remove(self, item):
        """ Remove(self: ICollection[T], item: T) -> bool """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[T](enumerable: IEnumerable[T], value: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: ICollection[T]) -> int



"""

    IsReadOnly = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: IsReadOnly(self: ICollection[T]) -> bool



"""



class IComparer:
    # no doc
    def Compare(self, x, y):
        """ Compare(self: IComparer[T], x: T, y: T) -> int """
        pass

    def __cmp__(self, *args): #cannot find CLR method
        """ x.__cmp__(y) <==> cmp(x,y) """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass


class IDictionary(ICollection[KeyValuePair[TKey, TValue]], IEnumerable[KeyValuePair[TKey, TValue]], IEnumerable):
    # no doc
    def Add(self, key, value):
        """ Add(self: IDictionary[TKey, TValue], key: TKey, value: TValue) """
        pass

    def ContainsKey(self, key):
        """ ContainsKey(self: IDictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def Remove(self, key):
        """ Remove(self: IDictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def TryGetValue(self, key, value):
        """ TryGetValue(self: IDictionary[TKey, TValue], key: TKey) -> (bool, TValue) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__(self: ICollection[KeyValuePair[TKey, TValue]], item: KeyValuePair[TKey, TValue]) -> bool """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass

    Keys = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Keys(self: IDictionary[TKey, TValue]) -> ICollection[TKey]



"""

    Values = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Values(self: IDictionary[TKey, TValue]) -> ICollection[TValue]



"""



class IEnumerable(IEnumerable):
    # no doc
    def GetEnumerator(self):
        """ GetEnumerator(self: IEnumerable[T]) -> IEnumerator[T] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass


class IEnumerator(IDisposable, IEnumerator):
    # no doc
    def next(self, *args): #cannot find CLR method
        """ next(self: object) -> object """
        pass

    def __enter__(self, *args): #cannot find CLR method
        """ __enter__(self: IDisposable) -> object """
        pass

    def __exit__(self, *args): #cannot find CLR method
        """ __exit__(self: IDisposable, exc_type: object, exc_value: object, exc_back: object) """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__[T](self: IEnumerator[T]) -> object """
        pass

    Current = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Current(self: IEnumerator[T]) -> T



"""



class IEqualityComparer:
    # no doc
    def Equals(self, x, y):
        """ Equals(self: IEqualityComparer[T], x: T, y: T) -> bool """
        pass

    def GetHashCode(self, obj):
        """ GetHashCode(self: IEqualityComparer[T], obj: T) -> int """
        pass

    def __eq__(self, *args): #cannot find CLR method
        """ x.__eq__(y) <==> x==y """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass


class IList(ICollection[T], IEnumerable[T], IEnumerable):
    # no doc
    def IndexOf(self, item):
        """ IndexOf(self: IList[T], item: T) -> int """
        pass

    def Insert(self, index, item):
        """ Insert(self: IList[T], index: int, item: T) """
        pass

    def RemoveAt(self, index):
        """ RemoveAt(self: IList[T], index: int) """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__(self: ICollection[T], item: T) -> bool """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass


class IReadOnlyCollection(IEnumerable[T], IEnumerable):
    # no doc
    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[T](enumerable: IEnumerable[T], value: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: IReadOnlyCollection[T]) -> int



"""



class IReadOnlyDictionary(IReadOnlyCollection[KeyValuePair[TKey, TValue]], IEnumerable[KeyValuePair[TKey, TValue]], IEnumerable):
    # no doc
    def ContainsKey(self, key):
        """ ContainsKey(self: IReadOnlyDictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def TryGetValue(self, key, value):
        """ TryGetValue(self: IReadOnlyDictionary[TKey, TValue], key: TKey) -> (bool, TValue) """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[KeyValuePair`2](enumerable: IEnumerable[KeyValuePair[TKey, TValue]], value: KeyValuePair[TKey, TValue]) -> bool """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    Keys = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Keys(self: IReadOnlyDictionary[TKey, TValue]) -> IEnumerable[TKey]



"""

    Values = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Values(self: IReadOnlyDictionary[TKey, TValue]) -> IEnumerable[TValue]



"""



class IReadOnlyList(IReadOnlyCollection[T], IEnumerable[T], IEnumerable):
    # no doc
    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[T](enumerable: IEnumerable[T], value: T) -> bool """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass


class ISet(ICollection[T], IEnumerable[T], IEnumerable):
    # no doc
    def Add(self, item):
        """ Add(self: ISet[T], item: T) -> bool """
        pass

    def ExceptWith(self, other):
        """ ExceptWith(self: ISet[T], other: IEnumerable[T]) """
        pass

    def IntersectWith(self, other):
        """ IntersectWith(self: ISet[T], other: IEnumerable[T]) """
        pass

    def IsProperSubsetOf(self, other):
        """ IsProperSubsetOf(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsProperSupersetOf(self, other):
        """ IsProperSupersetOf(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsSubsetOf(self, other):
        """ IsSubsetOf(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsSupersetOf(self, other):
        """ IsSupersetOf(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def Overlaps(self, other):
        """ Overlaps(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def SetEquals(self, other):
        """ SetEquals(self: ISet[T], other: IEnumerable[T]) -> bool """
        pass

    def SymmetricExceptWith(self, other):
        """ SymmetricExceptWith(self: ISet[T], other: IEnumerable[T]) """
        pass

    def UnionWith(self, other):
        """ UnionWith(self: ISet[T], other: IEnumerable[T]) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__(self: ICollection[T], item: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass


class KeyNotFoundException(SystemException, ISerializable, _Exception):
    """
    KeyNotFoundException()

    KeyNotFoundException(message: str)

    KeyNotFoundException(message: str, innerException: Exception)
    """
    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    @staticmethod # known case of __new__
    def __new__(self, message=None, innerException=None):
        """
        __new__(cls: type)

        __new__(cls: type, message: str)

        __new__(cls: type, message: str, innerException: Exception)

        __new__(cls: type, info: SerializationInfo, context: StreamingContext)
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __str__(self, *args): #cannot find CLR method
        pass

    SerializeObjectState = None


class KeyValuePair(object):
    """ KeyValuePair[TKey, TValue](key: TKey, value: TValue) """
    def ToString(self):
        """ ToString(self: KeyValuePair[TKey, TValue]) -> str """
        pass

    @staticmethod # known case of __new__
    def __new__(self, key, value):
        """
        __new__[KeyValuePair`2]() -> KeyValuePair[TKey, TValue]

        

        __new__(cls: type, key: TKey, value: TValue)
        """
        pass

    Key = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Key(self: KeyValuePair[TKey, TValue]) -> TKey



"""

    Value = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Value(self: KeyValuePair[TKey, TValue]) -> TValue



"""



class LinkedList(object, ICollection[T], IEnumerable[T], IEnumerable, ICollection, IReadOnlyCollection[T], ISerializable, IDeserializationCallback):
    """
    LinkedList[T]()

    LinkedList[T](collection: IEnumerable[T])
    """
    def AddAfter(self, node, *__args):
        """ AddAfter(self: LinkedList[T], node: LinkedListNode[T], newNode: LinkedListNode[T])AddAfter(self: LinkedList[T], node: LinkedListNode[T], value: T) -> LinkedListNode[T] """
        pass

    def AddBefore(self, node, *__args):
        """
        AddBefore(self: LinkedList[T], node: LinkedListNode[T], value: T) -> LinkedListNode[T]

        AddBefore(self: LinkedList[T], node: LinkedListNode[T], newNode: LinkedListNode[T])
        """
        pass

    def AddFirst(self, *__args):
        """
        AddFirst(self: LinkedList[T], value: T) -> LinkedListNode[T]

        AddFirst(self: LinkedList[T], node: LinkedListNode[T])
        """
        pass

    def AddLast(self, *__args):
        """
        AddLast(self: LinkedList[T], value: T) -> LinkedListNode[T]

        AddLast(self: LinkedList[T], node: LinkedListNode[T])
        """
        pass

    def Clear(self):
        """ Clear(self: LinkedList[T]) """
        pass

    def Contains(self, value):
        """ Contains(self: LinkedList[T], value: T) -> bool """
        pass

    def CopyTo(self, array, index):
        """ CopyTo(self: LinkedList[T], array: Array[T], index: int) """
        pass

    def Find(self, value):
        """ Find(self: LinkedList[T], value: T) -> LinkedListNode[T] """
        pass

    def FindLast(self, value):
        """ FindLast(self: LinkedList[T], value: T) -> LinkedListNode[T] """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: LinkedList[T]) -> Enumerator """
        pass

    def GetObjectData(self, info, context):
        """ GetObjectData(self: LinkedList[T], info: SerializationInfo, context: StreamingContext) """
        pass

    def OnDeserialization(self, sender):
        """ OnDeserialization(self: LinkedList[T], sender: object) """
        pass

    def Remove(self, *__args):
        """
        Remove(self: LinkedList[T], value: T) -> bool

        Remove(self: LinkedList[T], node: LinkedListNode[T])
        """
        pass

    def RemoveFirst(self):
        """ RemoveFirst(self: LinkedList[T]) """
        pass

    def RemoveLast(self):
        """ RemoveLast(self: LinkedList[T]) """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__(self: ICollection[T], item: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, collection=None):
        """
        __new__(cls: type)

        __new__(cls: type, collection: IEnumerable[T])

        __new__(cls: type, info: SerializationInfo, context: StreamingContext)
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: LinkedList[T]) -> int



"""

    First = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: First(self: LinkedList[T]) -> LinkedListNode[T]



"""

    Last = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Last(self: LinkedList[T]) -> LinkedListNode[T]



"""


    Enumerator = None


class LinkedListNode(object):
    """ LinkedListNode[T](value: T) """
    @staticmethod # known case of __new__
    def __new__(self, value):
        """ __new__(cls: type, value: T) """
        pass

    List = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: List(self: LinkedListNode[T]) -> LinkedList[T]



"""

    Next = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Next(self: LinkedListNode[T]) -> LinkedListNode[T]



"""

    Previous = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Previous(self: LinkedListNode[T]) -> LinkedListNode[T]



"""

    Value = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Value(self: LinkedListNode[T]) -> T



Set: Value(self: LinkedListNode[T]) = value

"""



class List(object, IList[T], ICollection[T], IEnumerable[T], IEnumerable, IList, ICollection, IReadOnlyList[T], IReadOnlyCollection[T]):
    """
    List[T]()

    List[T](capacity: int)

    List[T](collection: IEnumerable[T])
    """
    def Add(self, item):
        """ Add(self: List[T], item: T) """
        pass

    def AddRange(self, collection):
        """ AddRange(self: List[T], collection: IEnumerable[T]) """
        pass

    def AsReadOnly(self):
        """ AsReadOnly(self: List[T]) -> ReadOnlyCollection[T] """
        pass

    def BinarySearch(self, *__args):
        """
        BinarySearch(self: List[T], index: int, count: int, item: T, comparer: IComparer[T]) -> int

        BinarySearch(self: List[T], item: T) -> int

        BinarySearch(self: List[T], item: T, comparer: IComparer[T]) -> int
        """
        pass

    def Clear(self):
        """ Clear(self: List[T]) """
        pass

    def Contains(self, item):
        """ Contains(self: List[T], item: T) -> bool """
        pass

    def ConvertAll(self, converter):
        """ ConvertAll[TOutput](self: List[T], converter: Converter[T, TOutput]) -> List[TOutput] """
        pass

    def CopyTo(self, *__args):
        """ CopyTo(self: List[T], index: int, array: Array[T], arrayIndex: int, count: int)CopyTo(self: List[T], array: Array[T])CopyTo(self: List[T], array: Array[T], arrayIndex: int) """
        pass

    def Exists(self, match):
        """ Exists(self: List[T], match: Predicate[T]) -> bool """
        pass

    def Find(self, match):
        """ Find(self: List[T], match: Predicate[T]) -> T """
        pass

    def FindAll(self, match):
        """ FindAll(self: List[T], match: Predicate[T]) -> List[T] """
        pass

    def FindIndex(self, *__args):
        """
        FindIndex(self: List[T], match: Predicate[T]) -> int

        FindIndex(self: List[T], startIndex: int, match: Predicate[T]) -> int

        FindIndex(self: List[T], startIndex: int, count: int, match: Predicate[T]) -> int
        """
        pass

    def FindLast(self, match):
        """ FindLast(self: List[T], match: Predicate[T]) -> T """
        pass

    def FindLastIndex(self, *__args):
        """
        FindLastIndex(self: List[T], match: Predicate[T]) -> int

        FindLastIndex(self: List[T], startIndex: int, match: Predicate[T]) -> int

        FindLastIndex(self: List[T], startIndex: int, count: int, match: Predicate[T]) -> int
        """
        pass

    def ForEach(self, action):
        """ ForEach(self: List[T], action: Action[T]) """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: List[T]) -> Enumerator """
        pass

    def GetRange(self, index, count):
        """ GetRange(self: List[T], index: int, count: int) -> List[T] """
        pass

    def IndexOf(self, item, index=None, count=None):
        """
        IndexOf(self: List[T], item: T) -> int

        IndexOf(self: List[T], item: T, index: int) -> int

        IndexOf(self: List[T], item: T, index: int, count: int) -> int
        """
        pass

    def Insert(self, index, item):
        """ Insert(self: List[T], index: int, item: T) """
        pass

    def InsertRange(self, index, collection):
        """ InsertRange(self: List[T], index: int, collection: IEnumerable[T]) """
        pass

    def LastIndexOf(self, item, index=None, count=None):
        """
        LastIndexOf(self: List[T], item: T) -> int

        LastIndexOf(self: List[T], item: T, index: int) -> int

        LastIndexOf(self: List[T], item: T, index: int, count: int) -> int
        """
        pass

    def Remove(self, item):
        """ Remove(self: List[T], item: T) -> bool """
        pass

    def RemoveAll(self, match):
        """ RemoveAll(self: List[T], match: Predicate[T]) -> int """
        pass

    def RemoveAt(self, index):
        """ RemoveAt(self: List[T], index: int) """
        pass

    def RemoveRange(self, index, count):
        """ RemoveRange(self: List[T], index: int, count: int) """
        pass

    def Reverse(self, index=None, count=None):
        """ Reverse(self: List[T], index: int, count: int)Reverse(self: List[T]) """
        pass

    def Sort(self, *__args):
        """ Sort(self: List[T])Sort(self: List[T], comparer: IComparer[T])Sort(self: List[T], index: int, count: int, comparer: IComparer[T])Sort(self: List[T], comparison: Comparison[T]) """
        pass

    def ToArray(self):
        """ ToArray(self: List[T]) -> Array[T] """
        pass

    def TrimExcess(self):
        """ TrimExcess(self: List[T]) """
        pass

    def TrueForAll(self, match):
        """ TrueForAll(self: List[T], match: Predicate[T]) -> bool """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """
        __contains__(self: ICollection[T], item: T) -> bool

        __contains__(self: IList, value: object) -> bool
        """
        pass

    def __delitem__(self, *args): #cannot find CLR method
        """ x.__delitem__(y) <==> del x[y]x.__delitem__(y) <==> del x[y]x.__delitem__(y) <==> del x[y] """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __getslice__(self, *args): #cannot find CLR method
        """
        __getslice__(self: List[T], x: int, y: int) -> List[T]

        __getslice__(self: List[T], x: int, y: int) -> List[T]
        """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, capacity: int)

        __new__(cls: type, collection: IEnumerable[T])
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """
        __repr__(self: List[T]) -> str

        __repr__(self: List[T]) -> str
        """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass

    Capacity = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Capacity(self: List[T]) -> int



Set: Capacity(self: List[T]) = value

"""

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: List[T]) -> int



"""


    Enumerator = None


class Queue(object, IEnumerable[T], IEnumerable, ICollection, IReadOnlyCollection[T]):
    """
    Queue[T]()

    Queue[T](capacity: int)

    Queue[T](collection: IEnumerable[T])
    """
    def Clear(self):
        """ Clear(self: Queue[T]) """
        pass

    def Contains(self, item):
        """ Contains(self: Queue[T], item: T) -> bool """
        pass

    def CopyTo(self, array, arrayIndex):
        """ CopyTo(self: Queue[T], array: Array[T], arrayIndex: int) """
        pass

    def Dequeue(self):
        """ Dequeue(self: Queue[T]) -> T """
        pass

    def Enqueue(self, item):
        """ Enqueue(self: Queue[T], item: T) """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: Queue[T]) -> Enumerator """
        pass

    def Peek(self):
        """ Peek(self: Queue[T]) -> T """
        pass

    def ToArray(self):
        """ ToArray(self: Queue[T]) -> Array[T] """
        pass

    def TrimExcess(self):
        """ TrimExcess(self: Queue[T]) """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[T](enumerable: IEnumerable[T], value: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, capacity: int)

        __new__(cls: type, collection: IEnumerable[T])
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: Queue[T]) -> int



"""


    Enumerator = None


class SortedDictionary(object, IDictionary[TKey, TValue], ICollection[KeyValuePair[TKey, TValue]], IEnumerable[KeyValuePair[TKey, TValue]], IEnumerable, IDictionary, ICollection, IReadOnlyDictionary[TKey, TValue], IReadOnlyCollection[KeyValuePair[TKey, TValue]]):
    """
    SortedDictionary[TKey, TValue]()

    SortedDictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue])

    SortedDictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey])

    SortedDictionary[TKey, TValue](comparer: IComparer[TKey])
    """
    def Add(self, key, value):
        """ Add(self: SortedDictionary[TKey, TValue], key: TKey, value: TValue) """
        pass

    def Clear(self):
        """ Clear(self: SortedDictionary[TKey, TValue]) """
        pass

    def ContainsKey(self, key):
        """ ContainsKey(self: SortedDictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def ContainsValue(self, value):
        """ ContainsValue(self: SortedDictionary[TKey, TValue], value: TValue) -> bool """
        pass

    def CopyTo(self, array, index):
        """ CopyTo(self: SortedDictionary[TKey, TValue], array: Array[KeyValuePair[TKey, TValue]], index: int) """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: SortedDictionary[TKey, TValue]) -> Enumerator """
        pass

    def Remove(self, key):
        """ Remove(self: SortedDictionary[TKey, TValue], key: TKey) -> bool """
        pass

    def TryGetValue(self, key, value):
        """ TryGetValue(self: SortedDictionary[TKey, TValue], key: TKey) -> (bool, TValue) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """
        __contains__(self: IDictionary[TKey, TValue], key: TKey) -> bool

        __contains__(self: IDictionary, key: object) -> bool
        """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, dictionary: IDictionary[TKey, TValue])

        __new__(cls: type, dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey])

        __new__(cls: type, comparer: IComparer[TKey])
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass

    Comparer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Comparer(self: SortedDictionary[TKey, TValue]) -> IComparer[TKey]



"""

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: SortedDictionary[TKey, TValue]) -> int



"""

    Keys = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Keys(self: SortedDictionary[TKey, TValue]) -> KeyCollection



"""

    Values = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Values(self: SortedDictionary[TKey, TValue]) -> ValueCollection



"""


    Enumerator = None
    KeyCollection = None
    ValueCollection = None


class SortedList(object, IDictionary[TKey, TValue], ICollection[KeyValuePair[TKey, TValue]], IEnumerable[KeyValuePair[TKey, TValue]], IEnumerable, IDictionary, ICollection, IReadOnlyDictionary[TKey, TValue], IReadOnlyCollection[KeyValuePair[TKey, TValue]]):
    """
    SortedList[TKey, TValue]()

    SortedList[TKey, TValue](capacity: int)

    SortedList[TKey, TValue](comparer: IComparer[TKey])

    SortedList[TKey, TValue](capacity: int, comparer: IComparer[TKey])

    SortedList[TKey, TValue](dictionary: IDictionary[TKey, TValue])

    SortedList[TKey, TValue](dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey])
    """
    def Add(self, key, value):
        """ Add(self: SortedList[TKey, TValue], key: TKey, value: TValue) """
        pass

    def Clear(self):
        """ Clear(self: SortedList[TKey, TValue]) """
        pass

    def ContainsKey(self, key):
        """ ContainsKey(self: SortedList[TKey, TValue], key: TKey) -> bool """
        pass

    def ContainsValue(self, value):
        """ ContainsValue(self: SortedList[TKey, TValue], value: TValue) -> bool """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: SortedList[TKey, TValue]) -> IEnumerator[KeyValuePair[TKey, TValue]] """
        pass

    def IndexOfKey(self, key):
        """ IndexOfKey(self: SortedList[TKey, TValue], key: TKey) -> int """
        pass

    def IndexOfValue(self, value):
        """ IndexOfValue(self: SortedList[TKey, TValue], value: TValue) -> int """
        pass

    def Remove(self, key):
        """ Remove(self: SortedList[TKey, TValue], key: TKey) -> bool """
        pass

    def RemoveAt(self, index):
        """ RemoveAt(self: SortedList[TKey, TValue], index: int) """
        pass

    def TrimExcess(self):
        """ TrimExcess(self: SortedList[TKey, TValue]) """
        pass

    def TryGetValue(self, key, value):
        """ TryGetValue(self: SortedList[TKey, TValue], key: TKey) -> (bool, TValue) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """
        __contains__(self: IDictionary[TKey, TValue], key: TKey) -> bool

        __contains__(self: IDictionary, key: object) -> bool
        """
        pass

    def __getitem__(self, *args): #cannot find CLR method
        """ x.__getitem__(y) <==> x[y] """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, capacity: int)

        __new__(cls: type, comparer: IComparer[TKey])

        __new__(cls: type, capacity: int, comparer: IComparer[TKey])

        __new__(cls: type, dictionary: IDictionary[TKey, TValue])

        __new__(cls: type, dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey])
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    def __setitem__(self, *args): #cannot find CLR method
        """ x.__setitem__(i, y) <==> x[i]= """
        pass

    Capacity = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Capacity(self: SortedList[TKey, TValue]) -> int



Set: Capacity(self: SortedList[TKey, TValue]) = value

"""

    Comparer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Comparer(self: SortedList[TKey, TValue]) -> IComparer[TKey]



"""

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: SortedList[TKey, TValue]) -> int



"""

    Keys = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Keys(self: SortedList[TKey, TValue]) -> IList[TKey]



"""

    Values = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Values(self: SortedList[TKey, TValue]) -> IList[TValue]



"""



class SortedSet(object, ISet[T], ICollection[T], IEnumerable[T], IEnumerable, ICollection, ISerializable, IDeserializationCallback, IReadOnlyCollection[T]):
    """
    SortedSet[T]()

    SortedSet[T](comparer: IComparer[T])

    SortedSet[T](collection: IEnumerable[T])

    SortedSet[T](collection: IEnumerable[T], comparer: IComparer[T])
    """
    def Add(self, item):
        """ Add(self: SortedSet[T], item: T) -> bool """
        pass

    def Clear(self):
        """ Clear(self: SortedSet[T]) """
        pass

    def Contains(self, item):
        """ Contains(self: SortedSet[T], item: T) -> bool """
        pass

    def CopyTo(self, array, index=None, count=None):
        """ CopyTo(self: SortedSet[T], array: Array[T])CopyTo(self: SortedSet[T], array: Array[T], index: int)CopyTo(self: SortedSet[T], array: Array[T], index: int, count: int) """
        pass

    @staticmethod
    def CreateSetComparer(memberEqualityComparer=None):
        """
        CreateSetComparer() -> IEqualityComparer[SortedSet[T]]

        CreateSetComparer(memberEqualityComparer: IEqualityComparer[T]) -> IEqualityComparer[SortedSet[T]]
        """
        pass

    def ExceptWith(self, other):
        """ ExceptWith(self: SortedSet[T], other: IEnumerable[T]) """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: SortedSet[T]) -> Enumerator """
        pass

    def GetObjectData(self, *args): #cannot find CLR method
        """ GetObjectData(self: SortedSet[T], info: SerializationInfo, context: StreamingContext) """
        pass

    def GetViewBetween(self, lowerValue, upperValue):
        """ GetViewBetween(self: SortedSet[T], lowerValue: T, upperValue: T) -> SortedSet[T] """
        pass

    def IntersectWith(self, other):
        """ IntersectWith(self: SortedSet[T], other: IEnumerable[T]) """
        pass

    def IsProperSubsetOf(self, other):
        """ IsProperSubsetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsProperSupersetOf(self, other):
        """ IsProperSupersetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsSubsetOf(self, other):
        """ IsSubsetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def IsSupersetOf(self, other):
        """ IsSupersetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def OnDeserialization(self, *args): #cannot find CLR method
        """ OnDeserialization(self: SortedSet[T], sender: object) """
        pass

    def Overlaps(self, other):
        """ Overlaps(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def Remove(self, item):
        """ Remove(self: SortedSet[T], item: T) -> bool """
        pass

    def RemoveWhere(self, match):
        """ RemoveWhere(self: SortedSet[T], match: Predicate[T]) -> int """
        pass

    def Reverse(self):
        """ Reverse(self: SortedSet[T]) -> IEnumerable[T] """
        pass

    def SetEquals(self, other):
        """ SetEquals(self: SortedSet[T], other: IEnumerable[T]) -> bool """
        pass

    def SymmetricExceptWith(self, other):
        """ SymmetricExceptWith(self: SortedSet[T], other: IEnumerable[T]) """
        pass

    def TryGetValue(self, equalValue, actualValue):
        """ TryGetValue(self: SortedSet[T], equalValue: T) -> (bool, T) """
        pass

    def UnionWith(self, other):
        """ UnionWith(self: SortedSet[T], other: IEnumerable[T]) """
        pass

    def __add__(self, *args): #cannot find CLR method
        """ x.__add__(y) <==> x+y """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__(self: ICollection[T], item: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, comparer: IComparer[T])

        __new__(cls: type, collection: IEnumerable[T])

        __new__(cls: type, collection: IEnumerable[T], comparer: IComparer[T])

        __new__(cls: type, info: SerializationInfo, context: StreamingContext)
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    Comparer = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Comparer(self: SortedSet[T]) -> IComparer[T]



"""

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: SortedSet[T]) -> int



"""

    Max = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Max(self: SortedSet[T]) -> T



"""

    Min = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Min(self: SortedSet[T]) -> T



"""


    Enumerator = None


class Stack(object, IEnumerable[T], IEnumerable, ICollection, IReadOnlyCollection[T]):
    """
    Stack[T]()

    Stack[T](capacity: int)

    Stack[T](collection: IEnumerable[T])
    """
    def Clear(self):
        """ Clear(self: Stack[T]) """
        pass

    def Contains(self, item):
        """ Contains(self: Stack[T], item: T) -> bool """
        pass

    def CopyTo(self, array, arrayIndex):
        """ CopyTo(self: Stack[T], array: Array[T], arrayIndex: int) """
        pass

    def GetEnumerator(self):
        """ GetEnumerator(self: Stack[T]) -> Enumerator """
        pass

    def Peek(self):
        """ Peek(self: Stack[T]) -> T """
        pass

    def Pop(self):
        """ Pop(self: Stack[T]) -> T """
        pass

    def Push(self, item):
        """ Push(self: Stack[T], item: T) """
        pass

    def ToArray(self):
        """ ToArray(self: Stack[T]) -> Array[T] """
        pass

    def TrimExcess(self):
        """ TrimExcess(self: Stack[T]) """
        pass

    def __contains__(self, *args): #cannot find CLR method
        """ __contains__[T](enumerable: IEnumerable[T], value: T) -> bool """
        pass

    def __init__(self, *args): #cannot find CLR method
        """ x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature """
        pass

    def __iter__(self, *args): #cannot find CLR method
        """ __iter__(self: IEnumerable) -> object """
        pass

    def __len__(self, *args): #cannot find CLR method
        """ x.__len__() <==> len(x) """
        pass

    @staticmethod # known case of __new__
    def __new__(self, *__args):
        """
        __new__(cls: type)

        __new__(cls: type, capacity: int)

        __new__(cls: type, collection: IEnumerable[T])
        """
        pass

    def __reduce_ex__(self, *args): #cannot find CLR method
        pass

    def __repr__(self, *args): #cannot find CLR method
        """ __repr__(self: object) -> str """
        pass

    Count = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
    """Get: Count(self: Stack[T]) -> int



"""


    Enumerator = None



# encoding: utf-8 # module System.Collections.Generic calls itself Generic # from mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, Microsoft.Bcl.AsyncInterfaces, Version=1.0.0.0, Culture=neutral, PublicKeyToken=<KEY> # by generator 1.145 # no doc # no imports # no functions # classes # no doc Compare(self: Comparer[T], x: T, y: T) -> int Create(comparison: Comparison[T]) -> Comparer[T] #cannot find CLR method x.__cmp__(y) <==> cmp(x,y) #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method #cannot find CLR method __repr__(self: object) -> str Dictionary[TKey, TValue]()

     Dictionary[TKey, TValue](capacity: int)

     Dictionary[TKey, TValue](comparer: IEqualityComparer[TKey])

     Dictionary[TKey, TValue](capacity: int, comparer: IEqualityComparer[TKey])

     Dictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue])

     Dictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue], comparer: IEqualityComparer[TKey]) Add(self: Dictionary[TKey, TValue], key: TKey, value: TValue) Clear(self: Dictionary[TKey, TValue]) ContainsKey(self: Dictionary[TKey, TValue], key: TKey) -> bool ContainsValue(self: Dictionary[TKey, TValue], value: TValue) -> bool GetEnumerator(self: Dictionary[TKey, TValue]) -> Enumerator GetObjectData(self: Dictionary[TKey, TValue], info: SerializationInfo, context: StreamingContext) OnDeserialization(self: Dictionary[TKey, TValue], sender: object) Remove(self: Dictionary[TKey, TValue], key: TKey) -> bool TryGetValue(self: Dictionary[TKey, TValue], key: TKey) -> (bool, TValue) #cannot find CLR method x.__add__(y) <==> x+y #cannot find CLR method __contains__(self: IDictionary[TKey, TValue], key: TKey) -> bool

         __contains__(self: IDictionary, key: object) -> bool #cannot find CLR method x.__getitem__(y) <==> x[y] #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object #cannot find CLR method x.__len__() <==> len(x) # known case of __new__ __new__(cls: type)

         __new__(cls: type, capacity: int)

         __new__(cls: type, comparer: IEqualityComparer[TKey])

         __new__(cls: type, capacity: int, comparer: IEqualityComparer[TKey])

         __new__(cls: type, dictionary: IDictionary[TKey, TValue])

         __new__(cls: type, dictionary: IDictionary[TKey, TValue], comparer: IEqualityComparer[TKey])

         __new__(cls: type, info: SerializationInfo, context: StreamingContext) #cannot find CLR method #cannot find CLR method __repr__(self: Dictionary[TKey, TValue]) -> str

         __repr__(self: Dictionary[K, V]) -> str #cannot find CLR method x.__setitem__(i, y) <==> x[i]= # default Get: Comparer(self: Dictionary[TKey, TValue]) -> IEqualityComparer[TKey] # default Get: Count(self: Dictionary[TKey, TValue]) -> int # default Get: Keys(self: Dictionary[TKey, TValue]) -> KeyCollection # default Get: Values(self: Dictionary[TKey, TValue]) -> ValueCollection # no doc Equals(self: EqualityComparer[T], x: T, y: T) -> bool GetHashCode(self: EqualityComparer[T], obj: T) -> int #cannot find CLR method x.__eq__(y) <==> x==y #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method #cannot find CLR method __repr__(self: object) -> str # no doc GetAsyncEnumerator(self: IAsyncEnumerable[T], cancellationToken: CancellationToken) -> IAsyncEnumerator[T]

         

             Returns an enumerator that iterates asynchronously through the collection.

         

             cancellationToken: A System.Threading.CancellationToken that may be used to cancel the asynchronous iteration.

             Returns: An enumerator that can be used to iterate asynchronously through the collection. #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature # no doc MoveNextAsync(self: IAsyncEnumerator[T]) -> ValueTask[bool]

         

             Advances the enumerator asynchronously to the next element of the collection.

             Returns: A System.Threading.Tasks.ValueTask that will complete with a result of true if the enumerator

                     was successfully advanced to the next element, or false if the enumerator 

              has passed the end

                     of the collection. #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature # default Gets the element in the collection at the current position of the enumerator.

 

 Get: Current(self: IAsyncEnumerator[T]) -> T # no doc Add(self: ICollection[T], item: T) Clear(self: ICollection[T]) Contains(self: ICollection[T], item: T) -> bool CopyTo(self: ICollection[T], array: Array[T], arrayIndex: int) Remove(self: ICollection[T], item: T) -> bool #cannot find CLR method x.__add__(y) <==> x+y #cannot find CLR method __contains__[T](enumerable: IEnumerable[T], value: T) -> bool #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object # default Get: Count(self: ICollection[T]) -> int # default Get: IsReadOnly(self: ICollection[T]) -> bool # no doc Compare(self: IComparer[T], x: T, y: T) -> int #cannot find CLR method x.__cmp__(y) <==> cmp(x,y) #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature # no doc Add(self: IDictionary[TKey, TValue], key: TKey, value: TValue) ContainsKey(self: IDictionary[TKey, TValue], key: TKey) -> bool Remove(self: IDictionary[TKey, TValue], key: TKey) -> bool TryGetValue(self: IDictionary[TKey, TValue], key: TKey) -> (bool, TValue) #cannot find CLR method x.__add__(y) <==> x+y #cannot find CLR method __contains__(self: ICollection[KeyValuePair[TKey, TValue]], item: KeyValuePair[TKey, TValue]) -> bool #cannot find CLR method x.__getitem__(y) <==> x[y] #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object #cannot find CLR method x.__len__() <==> len(x) #cannot find CLR method x.__setitem__(i, y) <==> x[i]= # default Get: Keys(self: IDictionary[TKey, TValue]) -> ICollection[TKey] # default Get: Values(self: IDictionary[TKey, TValue]) -> ICollection[TValue] # no doc GetEnumerator(self: IEnumerable[T]) -> IEnumerator[T] #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature # no doc #cannot find CLR method next(self: object) -> object #cannot find CLR method __enter__(self: IDisposable) -> object #cannot find CLR method __exit__(self: IDisposable, exc_type: object, exc_value: object, exc_back: object) #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__[T](self: IEnumerator[T]) -> object # default Get: Current(self: IEnumerator[T]) -> T # no doc Equals(self: IEqualityComparer[T], x: T, y: T) -> bool GetHashCode(self: IEqualityComparer[T], obj: T) -> int #cannot find CLR method x.__eq__(y) <==> x==y #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature # no doc IndexOf(self: IList[T], item: T) -> int Insert(self: IList[T], index: int, item: T) RemoveAt(self: IList[T], index: int) #cannot find CLR method __contains__(self: ICollection[T], item: T) -> bool #cannot find CLR method x.__getitem__(y) <==> x[y] #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object #cannot find CLR method x.__len__() <==> len(x) #cannot find CLR method x.__setitem__(i, y) <==> x[i]= # no doc #cannot find CLR method __contains__[T](enumerable: IEnumerable[T], value: T) -> bool #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object # default Get: Count(self: IReadOnlyCollection[T]) -> int # no doc ContainsKey(self: IReadOnlyDictionary[TKey, TValue], key: TKey) -> bool TryGetValue(self: IReadOnlyDictionary[TKey, TValue], key: TKey) -> (bool, TValue) #cannot find CLR method __contains__[KeyValuePair`2](enumerable: IEnumerable[KeyValuePair[TKey, TValue]], value: KeyValuePair[TKey, TValue]) -> bool #cannot find CLR method x.__getitem__(y) <==> x[y] #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object # default Get: Keys(self: IReadOnlyDictionary[TKey, TValue]) -> IEnumerable[TKey] # default Get: Values(self: IReadOnlyDictionary[TKey, TValue]) -> IEnumerable[TValue] # no doc #cannot find CLR method __contains__[T](enumerable: IEnumerable[T], value: T) -> bool #cannot find CLR method x.__getitem__(y) <==> x[y] #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object # no doc Add(self: ISet[T], item: T) -> bool ExceptWith(self: ISet[T], other: IEnumerable[T]) IntersectWith(self: ISet[T], other: IEnumerable[T]) IsProperSubsetOf(self: ISet[T], other: IEnumerable[T]) -> bool IsProperSupersetOf(self: ISet[T], other: IEnumerable[T]) -> bool IsSubsetOf(self: ISet[T], other: IEnumerable[T]) -> bool IsSupersetOf(self: ISet[T], other: IEnumerable[T]) -> bool Overlaps(self: ISet[T], other: IEnumerable[T]) -> bool SetEquals(self: ISet[T], other: IEnumerable[T]) -> bool SymmetricExceptWith(self: ISet[T], other: IEnumerable[T]) UnionWith(self: ISet[T], other: IEnumerable[T]) #cannot find CLR method x.__add__(y) <==> x+y #cannot find CLR method __contains__(self: ICollection[T], item: T) -> bool #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object #cannot find CLR method x.__len__() <==> len(x) KeyNotFoundException()

     KeyNotFoundException(message: str)

     KeyNotFoundException(message: str, innerException: Exception) #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature # known case of __new__ __new__(cls: type)

         __new__(cls: type, message: str)

         __new__(cls: type, message: str, innerException: Exception)

         __new__(cls: type, info: SerializationInfo, context: StreamingContext) #cannot find CLR method #cannot find CLR method KeyValuePair[TKey, TValue](key: TKey, value: TValue) ToString(self: KeyValuePair[TKey, TValue]) -> str # known case of __new__ __new__[KeyValuePair`2]() -> KeyValuePair[TKey, TValue]

         

         __new__(cls: type, key: TKey, value: TValue) # default Get: Key(self: KeyValuePair[TKey, TValue]) -> TKey # default Get: Value(self: KeyValuePair[TKey, TValue]) -> TValue LinkedList[T]()

     LinkedList[T](collection: IEnumerable[T]) AddAfter(self: LinkedList[T], node: LinkedListNode[T], newNode: LinkedListNode[T])AddAfter(self: LinkedList[T], node: LinkedListNode[T], value: T) -> LinkedListNode[T] AddBefore(self: LinkedList[T], node: LinkedListNode[T], value: T) -> LinkedListNode[T]

         AddBefore(self: LinkedList[T], node: LinkedListNode[T], newNode: LinkedListNode[T]) AddFirst(self: LinkedList[T], value: T) -> LinkedListNode[T]

         AddFirst(self: LinkedList[T], node: LinkedListNode[T]) AddLast(self: LinkedList[T], value: T) -> LinkedListNode[T]

         AddLast(self: LinkedList[T], node: LinkedListNode[T]) Clear(self: LinkedList[T]) Contains(self: LinkedList[T], value: T) -> bool CopyTo(self: LinkedList[T], array: Array[T], index: int) Find(self: LinkedList[T], value: T) -> LinkedListNode[T] FindLast(self: LinkedList[T], value: T) -> LinkedListNode[T] GetEnumerator(self: LinkedList[T]) -> Enumerator GetObjectData(self: LinkedList[T], info: SerializationInfo, context: StreamingContext) OnDeserialization(self: LinkedList[T], sender: object) Remove(self: LinkedList[T], value: T) -> bool

         Remove(self: LinkedList[T], node: LinkedListNode[T]) RemoveFirst(self: LinkedList[T]) RemoveLast(self: LinkedList[T]) #cannot find CLR method __contains__(self: ICollection[T], item: T) -> bool #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object #cannot find CLR method x.__len__() <==> len(x) # known case of __new__ __new__(cls: type)

         __new__(cls: type, collection: IEnumerable[T])

         __new__(cls: type, info: SerializationInfo, context: StreamingContext) #cannot find CLR method #cannot find CLR method __repr__(self: object) -> str # default Get: Count(self: LinkedList[T]) -> int # default Get: First(self: LinkedList[T]) -> LinkedListNode[T] # default Get: Last(self: LinkedList[T]) -> LinkedListNode[T] LinkedListNode[T](value: T) # known case of __new__ __new__(cls: type, value: T) # default Get: List(self: LinkedListNode[T]) -> LinkedList[T] # default Get: Next(self: LinkedListNode[T]) -> LinkedListNode[T] # default Get: Previous(self: LinkedListNode[T]) -> LinkedListNode[T] # default Get: Value(self: LinkedListNode[T]) -> T

 

 Set: Value(self: LinkedListNode[T]) = value List[T]()

     List[T](capacity: int)

     List[T](collection: IEnumerable[T]) Add(self: List[T], item: T) AddRange(self: List[T], collection: IEnumerable[T]) AsReadOnly(self: List[T]) -> ReadOnlyCollection[T] BinarySearch(self: List[T], index: int, count: int, item: T, comparer: IComparer[T]) -> int

         BinarySearch(self: List[T], item: T) -> int

         BinarySearch(self: List[T], item: T, comparer: IComparer[T]) -> int Clear(self: List[T]) Contains(self: List[T], item: T) -> bool ConvertAll[TOutput](self: List[T], converter: Converter[T, TOutput]) -> List[TOutput] CopyTo(self: List[T], index: int, array: Array[T], arrayIndex: int, count: int)CopyTo(self: List[T], array: Array[T])CopyTo(self: List[T], array: Array[T], arrayIndex: int) Exists(self: List[T], match: Predicate[T]) -> bool Find(self: List[T], match: Predicate[T]) -> T FindAll(self: List[T], match: Predicate[T]) -> List[T] FindIndex(self: List[T], match: Predicate[T]) -> int

         FindIndex(self: List[T], startIndex: int, match: Predicate[T]) -> int

         FindIndex(self: List[T], startIndex: int, count: int, match: Predicate[T]) -> int FindLast(self: List[T], match: Predicate[T]) -> T FindLastIndex(self: List[T], match: Predicate[T]) -> int

         FindLastIndex(self: List[T], startIndex: int, match: Predicate[T]) -> int

         FindLastIndex(self: List[T], startIndex: int, count: int, match: Predicate[T]) -> int ForEach(self: List[T], action: Action[T]) GetEnumerator(self: List[T]) -> Enumerator GetRange(self: List[T], index: int, count: int) -> List[T] IndexOf(self: List[T], item: T) -> int

         IndexOf(self: List[T], item: T, index: int) -> int

         IndexOf(self: List[T], item: T, index: int, count: int) -> int Insert(self: List[T], index: int, item: T) InsertRange(self: List[T], index: int, collection: IEnumerable[T]) LastIndexOf(self: List[T], item: T) -> int

         LastIndexOf(self: List[T], item: T, index: int) -> int

         LastIndexOf(self: List[T], item: T, index: int, count: int) -> int Remove(self: List[T], item: T) -> bool RemoveAll(self: List[T], match: Predicate[T]) -> int RemoveAt(self: List[T], index: int) RemoveRange(self: List[T], index: int, count: int) Reverse(self: List[T], index: int, count: int)Reverse(self: List[T]) Sort(self: List[T])Sort(self: List[T], comparer: IComparer[T])Sort(self: List[T], index: int, count: int, comparer: IComparer[T])Sort(self: List[T], comparison: Comparison[T]) ToArray(self: List[T]) -> Array[T] TrimExcess(self: List[T]) TrueForAll(self: List[T], match: Predicate[T]) -> bool #cannot find CLR method x.__add__(y) <==> x+y #cannot find CLR method __contains__(self: ICollection[T], item: T) -> bool

         __contains__(self: IList, value: object) -> bool #cannot find CLR method x.__delitem__(y) <==> del x[y]x.__delitem__(y) <==> del x[y]x.__delitem__(y) <==> del x[y] #cannot find CLR method x.__getitem__(y) <==> x[y] #cannot find CLR method __getslice__(self: List[T], x: int, y: int) -> List[T]

         __getslice__(self: List[T], x: int, y: int) -> List[T] #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object #cannot find CLR method x.__len__() <==> len(x) # known case of __new__ __new__(cls: type)

         __new__(cls: type, capacity: int)

         __new__(cls: type, collection: IEnumerable[T]) #cannot find CLR method #cannot find CLR method __repr__(self: List[T]) -> str

         __repr__(self: List[T]) -> str #cannot find CLR method x.__setitem__(i, y) <==> x[i]= # default Get: Capacity(self: List[T]) -> int

 

 Set: Capacity(self: List[T]) = value # default Get: Count(self: List[T]) -> int Queue[T]()

     Queue[T](capacity: int)

     Queue[T](collection: IEnumerable[T]) Clear(self: Queue[T]) Contains(self: Queue[T], item: T) -> bool CopyTo(self: Queue[T], array: Array[T], arrayIndex: int) Dequeue(self: Queue[T]) -> T Enqueue(self: Queue[T], item: T) GetEnumerator(self: Queue[T]) -> Enumerator Peek(self: Queue[T]) -> T ToArray(self: Queue[T]) -> Array[T] TrimExcess(self: Queue[T]) #cannot find CLR method __contains__[T](enumerable: IEnumerable[T], value: T) -> bool #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object #cannot find CLR method x.__len__() <==> len(x) # known case of __new__ __new__(cls: type)

         __new__(cls: type, capacity: int)

         __new__(cls: type, collection: IEnumerable[T]) #cannot find CLR method #cannot find CLR method __repr__(self: object) -> str # default Get: Count(self: Queue[T]) -> int SortedDictionary[TKey, TValue]()

     SortedDictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue])

     SortedDictionary[TKey, TValue](dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey])

     SortedDictionary[TKey, TValue](comparer: IComparer[TKey]) Add(self: SortedDictionary[TKey, TValue], key: TKey, value: TValue) Clear(self: SortedDictionary[TKey, TValue]) ContainsKey(self: SortedDictionary[TKey, TValue], key: TKey) -> bool ContainsValue(self: SortedDictionary[TKey, TValue], value: TValue) -> bool CopyTo(self: SortedDictionary[TKey, TValue], array: Array[KeyValuePair[TKey, TValue]], index: int) GetEnumerator(self: SortedDictionary[TKey, TValue]) -> Enumerator Remove(self: SortedDictionary[TKey, TValue], key: TKey) -> bool TryGetValue(self: SortedDictionary[TKey, TValue], key: TKey) -> (bool, TValue) #cannot find CLR method x.__add__(y) <==> x+y #cannot find CLR method __contains__(self: IDictionary[TKey, TValue], key: TKey) -> bool

         __contains__(self: IDictionary, key: object) -> bool #cannot find CLR method x.__getitem__(y) <==> x[y] #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object #cannot find CLR method x.__len__() <==> len(x) # known case of __new__ __new__(cls: type)

         __new__(cls: type, dictionary: IDictionary[TKey, TValue])

         __new__(cls: type, dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey])

         __new__(cls: type, comparer: IComparer[TKey]) #cannot find CLR method #cannot find CLR method __repr__(self: object) -> str #cannot find CLR method x.__setitem__(i, y) <==> x[i]= # default Get: Comparer(self: SortedDictionary[TKey, TValue]) -> IComparer[TKey] # default Get: Count(self: SortedDictionary[TKey, TValue]) -> int # default Get: Keys(self: SortedDictionary[TKey, TValue]) -> KeyCollection # default Get: Values(self: SortedDictionary[TKey, TValue]) -> ValueCollection SortedList[TKey, TValue]()

     SortedList[TKey, TValue](capacity: int)

     SortedList[TKey, TValue](comparer: IComparer[TKey])

     SortedList[TKey, TValue](capacity: int, comparer: IComparer[TKey])

     SortedList[TKey, TValue](dictionary: IDictionary[TKey, TValue])

     SortedList[TKey, TValue](dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey]) Add(self: SortedList[TKey, TValue], key: TKey, value: TValue) Clear(self: SortedList[TKey, TValue]) ContainsKey(self: SortedList[TKey, TValue], key: TKey) -> bool ContainsValue(self: SortedList[TKey, TValue], value: TValue) -> bool GetEnumerator(self: SortedList[TKey, TValue]) -> IEnumerator[KeyValuePair[TKey, TValue]] IndexOfKey(self: SortedList[TKey, TValue], key: TKey) -> int IndexOfValue(self: SortedList[TKey, TValue], value: TValue) -> int Remove(self: SortedList[TKey, TValue], key: TKey) -> bool RemoveAt(self: SortedList[TKey, TValue], index: int) TrimExcess(self: SortedList[TKey, TValue]) TryGetValue(self: SortedList[TKey, TValue], key: TKey) -> (bool, TValue) #cannot find CLR method x.__add__(y) <==> x+y #cannot find CLR method __contains__(self: IDictionary[TKey, TValue], key: TKey) -> bool

         __contains__(self: IDictionary, key: object) -> bool #cannot find CLR method x.__getitem__(y) <==> x[y] #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object #cannot find CLR method x.__len__() <==> len(x) # known case of __new__ __new__(cls: type)

         __new__(cls: type, capacity: int)

         __new__(cls: type, comparer: IComparer[TKey])

         __new__(cls: type, capacity: int, comparer: IComparer[TKey])

         __new__(cls: type, dictionary: IDictionary[TKey, TValue])

         __new__(cls: type, dictionary: IDictionary[TKey, TValue], comparer: IComparer[TKey]) #cannot find CLR method #cannot find CLR method __repr__(self: object) -> str #cannot find CLR method x.__setitem__(i, y) <==> x[i]= # default Get: Capacity(self: SortedList[TKey, TValue]) -> int

 

 Set: Capacity(self: SortedList[TKey, TValue]) = value # default Get: Comparer(self: SortedList[TKey, TValue]) -> IComparer[TKey] # default Get: Count(self: SortedList[TKey, TValue]) -> int # default Get: Keys(self: SortedList[TKey, TValue]) -> IList[TKey] # default Get: Values(self: SortedList[TKey, TValue]) -> IList[TValue] SortedSet[T]()

     SortedSet[T](comparer: IComparer[T])

     SortedSet[T](collection: IEnumerable[T])

     SortedSet[T](collection: IEnumerable[T], comparer: IComparer[T]) Add(self: SortedSet[T], item: T) -> bool Clear(self: SortedSet[T]) Contains(self: SortedSet[T], item: T) -> bool CopyTo(self: SortedSet[T], array: Array[T])CopyTo(self: SortedSet[T], array: Array[T], index: int)CopyTo(self: SortedSet[T], array: Array[T], index: int, count: int) CreateSetComparer() -> IEqualityComparer[SortedSet[T]]

         CreateSetComparer(memberEqualityComparer: IEqualityComparer[T]) -> IEqualityComparer[SortedSet[T]] ExceptWith(self: SortedSet[T], other: IEnumerable[T]) GetEnumerator(self: SortedSet[T]) -> Enumerator #cannot find CLR method GetObjectData(self: SortedSet[T], info: SerializationInfo, context: StreamingContext) GetViewBetween(self: SortedSet[T], lowerValue: T, upperValue: T) -> SortedSet[T] IntersectWith(self: SortedSet[T], other: IEnumerable[T]) IsProperSubsetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool IsProperSupersetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool IsSubsetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool IsSupersetOf(self: SortedSet[T], other: IEnumerable[T]) -> bool #cannot find CLR method OnDeserialization(self: SortedSet[T], sender: object) Overlaps(self: SortedSet[T], other: IEnumerable[T]) -> bool Remove(self: SortedSet[T], item: T) -> bool RemoveWhere(self: SortedSet[T], match: Predicate[T]) -> int Reverse(self: SortedSet[T]) -> IEnumerable[T] SetEquals(self: SortedSet[T], other: IEnumerable[T]) -> bool SymmetricExceptWith(self: SortedSet[T], other: IEnumerable[T]) TryGetValue(self: SortedSet[T], equalValue: T) -> (bool, T) UnionWith(self: SortedSet[T], other: IEnumerable[T]) #cannot find CLR method x.__add__(y) <==> x+y #cannot find CLR method __contains__(self: ICollection[T], item: T) -> bool #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object #cannot find CLR method x.__len__() <==> len(x) # known case of __new__ __new__(cls: type)

         __new__(cls: type, comparer: IComparer[T])

         __new__(cls: type, collection: IEnumerable[T])

         __new__(cls: type, collection: IEnumerable[T], comparer: IComparer[T])

         __new__(cls: type, info: SerializationInfo, context: StreamingContext) #cannot find CLR method #cannot find CLR method __repr__(self: object) -> str # default Get: Comparer(self: SortedSet[T]) -> IComparer[T] # default Get: Count(self: SortedSet[T]) -> int # default Get: Max(self: SortedSet[T]) -> T # default Get: Min(self: SortedSet[T]) -> T Stack[T]()

     Stack[T](capacity: int)

     Stack[T](collection: IEnumerable[T]) Clear(self: Stack[T]) Contains(self: Stack[T], item: T) -> bool CopyTo(self: Stack[T], array: Array[T], arrayIndex: int) GetEnumerator(self: Stack[T]) -> Enumerator Peek(self: Stack[T]) -> T Pop(self: Stack[T]) -> T Push(self: Stack[T], item: T) ToArray(self: Stack[T]) -> Array[T] TrimExcess(self: Stack[T]) #cannot find CLR method __contains__[T](enumerable: IEnumerable[T], value: T) -> bool #cannot find CLR method x.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signaturex.__init__(...) initializes x; see x.__class__.__doc__ for signature #cannot find CLR method __iter__(self: IEnumerable) -> object #cannot find CLR method x.__len__() <==> len(x) # known case of __new__ __new__(cls: type)

         __new__(cls: type, capacity: int)

         __new__(cls: type, collection: IEnumerable[T]) #cannot find CLR method #cannot find CLR method __repr__(self: object) -> str # default Get: Count(self: Stack[T]) -> int