PySimultan 0.5.9.6__py3-none-any.whl → 0.6.0.1__py3-none-any.whl

PySimultan2/typings/System/Buffers/Binary/__init__.pyi

@@ -0,0 +1,248 @@
+import typing, clr, abc
+from System import ReadOnlySpan_1, Half, Int128, UInt128, UIntPtr, Span_1
+
+class BinaryPrimitives(abc.ABC):
+    @staticmethod
+    def ReadDoubleBigEndian(source: ReadOnlySpan_1[int]) -> float: ...
+    @staticmethod
+    def ReadDoubleLittleEndian(source: ReadOnlySpan_1[int]) -> float: ...
+    @staticmethod
+    def ReadHalfBigEndian(source: ReadOnlySpan_1[int]) -> Half: ...
+    @staticmethod
+    def ReadHalfLittleEndian(source: ReadOnlySpan_1[int]) -> Half: ...
+    @staticmethod
+    def ReadInt128BigEndian(source: ReadOnlySpan_1[int]) -> Int128: ...
+    @staticmethod
+    def ReadInt128LittleEndian(source: ReadOnlySpan_1[int]) -> Int128: ...
+    @staticmethod
+    def ReadInt16BigEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadInt16LittleEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadInt32BigEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadInt32LittleEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadInt64BigEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadInt64LittleEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadIntPtrBigEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadIntPtrLittleEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadSingleBigEndian(source: ReadOnlySpan_1[int]) -> float: ...
+    @staticmethod
+    def ReadSingleLittleEndian(source: ReadOnlySpan_1[int]) -> float: ...
+    @staticmethod
+    def ReadUInt128BigEndian(source: ReadOnlySpan_1[int]) -> UInt128: ...
+    @staticmethod
+    def ReadUInt128LittleEndian(source: ReadOnlySpan_1[int]) -> UInt128: ...
+    @staticmethod
+    def ReadUInt16BigEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadUInt16LittleEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadUInt32BigEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadUInt32LittleEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadUInt64BigEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadUInt64LittleEndian(source: ReadOnlySpan_1[int]) -> int: ...
+    @staticmethod
+    def ReadUIntPtrBigEndian(source: ReadOnlySpan_1[int]) -> UIntPtr: ...
+    @staticmethod
+    def ReadUIntPtrLittleEndian(source: ReadOnlySpan_1[int]) -> UIntPtr: ...
+    @staticmethod
+    def TryReadDoubleBigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[float]) -> bool: ...
+    @staticmethod
+    def TryReadDoubleLittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[float]) -> bool: ...
+    @staticmethod
+    def TryReadHalfBigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[Half]) -> bool: ...
+    @staticmethod
+    def TryReadHalfLittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[Half]) -> bool: ...
+    @staticmethod
+    def TryReadInt128BigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[Int128]) -> bool: ...
+    @staticmethod
+    def TryReadInt128LittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[Int128]) -> bool: ...
+    @staticmethod
+    def TryReadInt16BigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadInt16LittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadInt32BigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadInt32LittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadInt64BigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadInt64LittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadIntPtrBigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadIntPtrLittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadSingleBigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[float]) -> bool: ...
+    @staticmethod
+    def TryReadSingleLittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[float]) -> bool: ...
+    @staticmethod
+    def TryReadUInt128BigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[UInt128]) -> bool: ...
+    @staticmethod
+    def TryReadUInt128LittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[UInt128]) -> bool: ...
+    @staticmethod
+    def TryReadUInt16BigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadUInt16LittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadUInt32BigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadUInt32LittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadUInt64BigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadUInt64LittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[int]) -> bool: ...
+    @staticmethod
+    def TryReadUIntPtrBigEndian(source: ReadOnlySpan_1[int], value: clr.Reference[UIntPtr]) -> bool: ...
+    @staticmethod
+    def TryReadUIntPtrLittleEndian(source: ReadOnlySpan_1[int], value: clr.Reference[UIntPtr]) -> bool: ...
+    @staticmethod
+    def TryWriteDoubleBigEndian(destination: Span_1[int], value: float) -> bool: ...
+    @staticmethod
+    def TryWriteDoubleLittleEndian(destination: Span_1[int], value: float) -> bool: ...
+    @staticmethod
+    def TryWriteHalfBigEndian(destination: Span_1[int], value: Half) -> bool: ...
+    @staticmethod
+    def TryWriteHalfLittleEndian(destination: Span_1[int], value: Half) -> bool: ...
+    @staticmethod
+    def TryWriteInt128BigEndian(destination: Span_1[int], value: Int128) -> bool: ...
+    @staticmethod
+    def TryWriteInt128LittleEndian(destination: Span_1[int], value: Int128) -> bool: ...
+    @staticmethod
+    def TryWriteInt16BigEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteInt16LittleEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteInt32BigEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteInt32LittleEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteInt64BigEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteInt64LittleEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteIntPtrBigEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteIntPtrLittleEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteSingleBigEndian(destination: Span_1[int], value: float) -> bool: ...
+    @staticmethod
+    def TryWriteSingleLittleEndian(destination: Span_1[int], value: float) -> bool: ...
+    @staticmethod
+    def TryWriteUInt128BigEndian(destination: Span_1[int], value: UInt128) -> bool: ...
+    @staticmethod
+    def TryWriteUInt128LittleEndian(destination: Span_1[int], value: UInt128) -> bool: ...
+    @staticmethod
+    def TryWriteUInt16BigEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteUInt16LittleEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteUInt32BigEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteUInt32LittleEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteUInt64BigEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteUInt64LittleEndian(destination: Span_1[int], value: int) -> bool: ...
+    @staticmethod
+    def TryWriteUIntPtrBigEndian(destination: Span_1[int], value: UIntPtr) -> bool: ...
+    @staticmethod
+    def TryWriteUIntPtrLittleEndian(destination: Span_1[int], value: UIntPtr) -> bool: ...
+    @staticmethod
+    def WriteDoubleBigEndian(destination: Span_1[int], value: float) -> None: ...
+    @staticmethod
+    def WriteDoubleLittleEndian(destination: Span_1[int], value: float) -> None: ...
+    @staticmethod
+    def WriteHalfBigEndian(destination: Span_1[int], value: Half) -> None: ...
+    @staticmethod
+    def WriteHalfLittleEndian(destination: Span_1[int], value: Half) -> None: ...
+    @staticmethod
+    def WriteInt128BigEndian(destination: Span_1[int], value: Int128) -> None: ...
+    @staticmethod
+    def WriteInt128LittleEndian(destination: Span_1[int], value: Int128) -> None: ...
+    @staticmethod
+    def WriteInt16BigEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteInt16LittleEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteInt32BigEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteInt32LittleEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteInt64BigEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteInt64LittleEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteIntPtrBigEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteIntPtrLittleEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteSingleBigEndian(destination: Span_1[int], value: float) -> None: ...
+    @staticmethod
+    def WriteSingleLittleEndian(destination: Span_1[int], value: float) -> None: ...
+    @staticmethod
+    def WriteUInt128BigEndian(destination: Span_1[int], value: UInt128) -> None: ...
+    @staticmethod
+    def WriteUInt128LittleEndian(destination: Span_1[int], value: UInt128) -> None: ...
+    @staticmethod
+    def WriteUInt16BigEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteUInt16LittleEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteUInt32BigEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteUInt32LittleEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteUInt64BigEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteUInt64LittleEndian(destination: Span_1[int], value: int) -> None: ...
+    @staticmethod
+    def WriteUIntPtrBigEndian(destination: Span_1[int], value: UIntPtr) -> None: ...
+    @staticmethod
+    def WriteUIntPtrLittleEndian(destination: Span_1[int], value: UIntPtr) -> None: ...
+    # Skipped ReverseEndianness due to it being static, abstract and generic.
+
+    ReverseEndianness : ReverseEndianness_MethodGroup
+    class ReverseEndianness_MethodGroup:
+        @typing.overload
+        def __call__(self, value: int) -> int:...
+        # Method ReverseEndianness(value : Int16) was skipped since it collides with above method
+        # Method ReverseEndianness(value : Int32) was skipped since it collides with above method
+        # Method ReverseEndianness(value : Int64) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, value: Int128) -> Int128:...
+        # Method ReverseEndianness(value : Byte) was skipped since it collides with above method
+        # Method ReverseEndianness(value : UInt16) was skipped since it collides with above method
+        # Method ReverseEndianness(value : UInt32) was skipped since it collides with above method
+        # Method ReverseEndianness(value : UInt64) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, value: UInt128) -> UInt128:...
+        # Method ReverseEndianness(value : IntPtr) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, value: UIntPtr) -> UIntPtr:...
+        @typing.overload
+        def __call__(self, source: ReadOnlySpan_1[int], destination: Span_1[int]) -> None:...
+        # Method ReverseEndianness(source : ReadOnlySpan`1, destination : Span`1) was skipped since it collides with above method
+        # Method ReverseEndianness(source : ReadOnlySpan`1, destination : Span`1) was skipped since it collides with above method
+        # Method ReverseEndianness(source : ReadOnlySpan`1, destination : Span`1) was skipped since it collides with above method
+        # Method ReverseEndianness(source : ReadOnlySpan`1, destination : Span`1) was skipped since it collides with above method
+        # Method ReverseEndianness(source : ReadOnlySpan`1, destination : Span`1) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, source: ReadOnlySpan_1[UInt128], destination: Span_1[UInt128]) -> None:...
+        @typing.overload
+        def __call__(self, source: ReadOnlySpan_1[Int128], destination: Span_1[Int128]) -> None:...
+        @typing.overload
+        def __call__(self, source: ReadOnlySpan_1[UIntPtr], destination: Span_1[UIntPtr]) -> None:...
+        # Method ReverseEndianness(source : ReadOnlySpan`1, destination : Span`1) was skipped since it collides with above method
+
+

PySimultan2/typings/System/Buffers/Text/__init__.pyi

@@ -0,0 +1,91 @@
+import typing, clr, abc
+from System.Buffers import OperationStatus, StandardFormat
+from System import ReadOnlySpan_1, Span_1, Decimal, DateTimeOffset, DateTime, Guid, TimeSpan
+
+class Base64(abc.ABC):
+    @staticmethod
+    def DecodeFromUtf8(utf8: ReadOnlySpan_1[int], bytes: Span_1[int], bytesConsumed: clr.Reference[int], bytesWritten: clr.Reference[int], isFinalBlock: bool = ...) -> OperationStatus: ...
+    @staticmethod
+    def DecodeFromUtf8InPlace(buffer: Span_1[int], bytesWritten: clr.Reference[int]) -> OperationStatus: ...
+    @staticmethod
+    def EncodeToUtf8(bytes: ReadOnlySpan_1[int], utf8: Span_1[int], bytesConsumed: clr.Reference[int], bytesWritten: clr.Reference[int], isFinalBlock: bool = ...) -> OperationStatus: ...
+    @staticmethod
+    def EncodeToUtf8InPlace(buffer: Span_1[int], dataLength: int, bytesWritten: clr.Reference[int]) -> OperationStatus: ...
+    @staticmethod
+    def GetMaxDecodedFromUtf8Length(length: int) -> int: ...
+    @staticmethod
+    def GetMaxEncodedToUtf8Length(length: int) -> int: ...
+    # Skipped IsValid due to it being static, abstract and generic.
+
+    IsValid : IsValid_MethodGroup
+    class IsValid_MethodGroup:
+        @typing.overload
+        def __call__(self, base64Text: ReadOnlySpan_1[str]) -> bool:...
+        @typing.overload
+        def __call__(self, base64TextUtf8: ReadOnlySpan_1[int]) -> bool:...
+        @typing.overload
+        def __call__(self, base64TextUtf8: ReadOnlySpan_1[int], decodedLength: clr.Reference[int]) -> bool:...
+        @typing.overload
+        def __call__(self, base64Text: ReadOnlySpan_1[str], decodedLength: clr.Reference[int]) -> bool:...
+
+
+
+class Utf8Formatter(abc.ABC):
+    # Skipped TryFormat due to it being static, abstract and generic.
+
+    TryFormat : TryFormat_MethodGroup
+    class TryFormat_MethodGroup:
+        @typing.overload
+        def __call__(self, value: float, destination: Span_1[int], bytesWritten: clr.Reference[int], format: StandardFormat = ...) -> bool:...
+        # Method TryFormat(value : Single, destination : Span`1, bytesWritten : Int32&, format : StandardFormat) was skipped since it collides with above method
+        # Method TryFormat(value : Byte, destination : Span`1, bytesWritten : Int32&, format : StandardFormat) was skipped since it collides with above method
+        # Method TryFormat(value : SByte, destination : Span`1, bytesWritten : Int32&, format : StandardFormat) was skipped since it collides with above method
+        # Method TryFormat(value : UInt16, destination : Span`1, bytesWritten : Int32&, format : StandardFormat) was skipped since it collides with above method
+        # Method TryFormat(value : Int16, destination : Span`1, bytesWritten : Int32&, format : StandardFormat) was skipped since it collides with above method
+        # Method TryFormat(value : UInt32, destination : Span`1, bytesWritten : Int32&, format : StandardFormat) was skipped since it collides with above method
+        # Method TryFormat(value : Int32, destination : Span`1, bytesWritten : Int32&, format : StandardFormat) was skipped since it collides with above method
+        # Method TryFormat(value : UInt64, destination : Span`1, bytesWritten : Int32&, format : StandardFormat) was skipped since it collides with above method
+        # Method TryFormat(value : Int64, destination : Span`1, bytesWritten : Int32&, format : StandardFormat) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, value: Decimal, destination: Span_1[int], bytesWritten: clr.Reference[int], format: StandardFormat = ...) -> bool:...
+        # Method TryFormat(value : Boolean, destination : Span`1, bytesWritten : Int32&, format : StandardFormat) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, value: DateTimeOffset, destination: Span_1[int], bytesWritten: clr.Reference[int], format: StandardFormat = ...) -> bool:...
+        @typing.overload
+        def __call__(self, value: DateTime, destination: Span_1[int], bytesWritten: clr.Reference[int], format: StandardFormat = ...) -> bool:...
+        @typing.overload
+        def __call__(self, value: Guid, destination: Span_1[int], bytesWritten: clr.Reference[int], format: StandardFormat = ...) -> bool:...
+        @typing.overload
+        def __call__(self, value: TimeSpan, destination: Span_1[int], bytesWritten: clr.Reference[int], format: StandardFormat = ...) -> bool:...
+
+
+
+class Utf8Parser(abc.ABC):
+    # Skipped TryParse due to it being static, abstract and generic.
+
+    TryParse : TryParse_MethodGroup
+    class TryParse_MethodGroup:
+        @typing.overload
+        def __call__(self, source: ReadOnlySpan_1[int], value: clr.Reference[float], bytesConsumed: clr.Reference[int], standardFormat: str = ...) -> bool:...
+        # Method TryParse(source : ReadOnlySpan`1, value : Double&, bytesConsumed : Int32&, standardFormat : Char) was skipped since it collides with above method
+        # Method TryParse(source : ReadOnlySpan`1, value : SByte&, bytesConsumed : Int32&, standardFormat : Char) was skipped since it collides with above method
+        # Method TryParse(source : ReadOnlySpan`1, value : Int16&, bytesConsumed : Int32&, standardFormat : Char) was skipped since it collides with above method
+        # Method TryParse(source : ReadOnlySpan`1, value : Int32&, bytesConsumed : Int32&, standardFormat : Char) was skipped since it collides with above method
+        # Method TryParse(source : ReadOnlySpan`1, value : Int64&, bytesConsumed : Int32&, standardFormat : Char) was skipped since it collides with above method
+        # Method TryParse(source : ReadOnlySpan`1, value : Byte&, bytesConsumed : Int32&, standardFormat : Char) was skipped since it collides with above method
+        # Method TryParse(source : ReadOnlySpan`1, value : UInt16&, bytesConsumed : Int32&, standardFormat : Char) was skipped since it collides with above method
+        # Method TryParse(source : ReadOnlySpan`1, value : UInt32&, bytesConsumed : Int32&, standardFormat : Char) was skipped since it collides with above method
+        # Method TryParse(source : ReadOnlySpan`1, value : UInt64&, bytesConsumed : Int32&, standardFormat : Char) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, source: ReadOnlySpan_1[int], value: clr.Reference[Decimal], bytesConsumed: clr.Reference[int], standardFormat: str = ...) -> bool:...
+        # Method TryParse(source : ReadOnlySpan`1, value : Boolean&, bytesConsumed : Int32&, standardFormat : Char) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, source: ReadOnlySpan_1[int], value: clr.Reference[DateTime], bytesConsumed: clr.Reference[int], standardFormat: str = ...) -> bool:...
+        @typing.overload
+        def __call__(self, source: ReadOnlySpan_1[int], value: clr.Reference[DateTimeOffset], bytesConsumed: clr.Reference[int], standardFormat: str = ...) -> bool:...
+        @typing.overload
+        def __call__(self, source: ReadOnlySpan_1[int], value: clr.Reference[Guid], bytesConsumed: clr.Reference[int], standardFormat: str = ...) -> bool:...
+        @typing.overload
+        def __call__(self, source: ReadOnlySpan_1[int], value: clr.Reference[TimeSpan], bytesConsumed: clr.Reference[int], standardFormat: str = ...) -> bool:...
+
+

PySimultan2/typings/System/Buffers/__init__.pyi

@@ -0,0 +1,192 @@
+import typing, clr, abc
+from System import Array_1, IDisposable, Memory_1, Span_1, MulticastDelegate, IAsyncResult, ReadOnlySpan_1, AsyncCallback, IEquatable_1
+from System.Runtime.InteropServices import GCHandle
+from System.Reflection import MethodInfo
+
+class ArrayPool_GenericClasses(abc.ABCMeta):
+    Generic_ArrayPool_GenericClasses_ArrayPool_1_T = typing.TypeVar('Generic_ArrayPool_GenericClasses_ArrayPool_1_T')
+    def __getitem__(self, types : typing.Type[Generic_ArrayPool_GenericClasses_ArrayPool_1_T]) -> typing.Type[ArrayPool_1[Generic_ArrayPool_GenericClasses_ArrayPool_1_T]]: ...
+
+ArrayPool : ArrayPool_GenericClasses
+
+ArrayPool_1_T = typing.TypeVar('ArrayPool_1_T')
+class ArrayPool_1(typing.Generic[ArrayPool_1_T], abc.ABC):
+    @classmethod
+    @property
+    def Shared(cls) -> ArrayPool_1[ArrayPool_1_T]: ...
+    @abc.abstractmethod
+    def Rent(self, minimumLength: int) -> Array_1[ArrayPool_1_T]: ...
+    @abc.abstractmethod
+    def Return(self, array: Array_1[ArrayPool_1_T], clearArray: bool = ...) -> None: ...
+    # Skipped Create due to it being static, abstract and generic.
+
+    Create : Create_MethodGroup[ArrayPool_1_T]
+    Create_MethodGroup_ArrayPool_1_T = typing.TypeVar('Create_MethodGroup_ArrayPool_1_T')
+    class Create_MethodGroup(typing.Generic[Create_MethodGroup_ArrayPool_1_T]):
+        Create_MethodGroup_ArrayPool_1_T = ArrayPool_1.Create_MethodGroup_ArrayPool_1_T
+        @typing.overload
+        def __call__(self) -> ArrayPool_1[Create_MethodGroup_ArrayPool_1_T]:...
+        @typing.overload
+        def __call__(self, maxArrayLength: int, maxArraysPerBucket: int) -> ArrayPool_1[Create_MethodGroup_ArrayPool_1_T]:...
+
+
+
+class IMemoryOwner_GenericClasses(abc.ABCMeta):
+    Generic_IMemoryOwner_GenericClasses_IMemoryOwner_1_T = typing.TypeVar('Generic_IMemoryOwner_GenericClasses_IMemoryOwner_1_T')
+    def __getitem__(self, types : typing.Type[Generic_IMemoryOwner_GenericClasses_IMemoryOwner_1_T]) -> typing.Type[IMemoryOwner_1[Generic_IMemoryOwner_GenericClasses_IMemoryOwner_1_T]]: ...
+
+IMemoryOwner : IMemoryOwner_GenericClasses
+
+IMemoryOwner_1_T = typing.TypeVar('IMemoryOwner_1_T')
+class IMemoryOwner_1(typing.Generic[IMemoryOwner_1_T], IDisposable, typing.Protocol):
+    @property
+    def Memory(self) -> Memory_1[IMemoryOwner_1_T]: ...
+
+
+class IPinnable(typing.Protocol):
+    @abc.abstractmethod
+    def Pin(self, elementIndex: int) -> MemoryHandle: ...
+    @abc.abstractmethod
+    def Unpin(self) -> None: ...
+
+
+class MemoryHandle(IDisposable):
+    def __init__(self, pointer: clr.Reference[None], handle: GCHandle = ..., pinnable: IPinnable = ...) -> None: ...
+    @property
+    def Pointer(self) -> clr.Reference[None]: ...
+    def Dispose(self) -> None: ...
+
+
+class MemoryManager_GenericClasses(abc.ABCMeta):
+    Generic_MemoryManager_GenericClasses_MemoryManager_1_T = typing.TypeVar('Generic_MemoryManager_GenericClasses_MemoryManager_1_T')
+    def __getitem__(self, types : typing.Type[Generic_MemoryManager_GenericClasses_MemoryManager_1_T]) -> typing.Type[MemoryManager_1[Generic_MemoryManager_GenericClasses_MemoryManager_1_T]]: ...
+
+MemoryManager : MemoryManager_GenericClasses
+
+MemoryManager_1_T = typing.TypeVar('MemoryManager_1_T')
+class MemoryManager_1(typing.Generic[MemoryManager_1_T], IMemoryOwner_1[MemoryManager_1_T], IPinnable, abc.ABC):
+    @property
+    def Memory(self) -> Memory_1[MemoryManager_1_T]: ...
+    @abc.abstractmethod
+    def GetSpan(self) -> Span_1[MemoryManager_1_T]: ...
+    @abc.abstractmethod
+    def Pin(self, elementIndex: int = ...) -> MemoryHandle: ...
+    @abc.abstractmethod
+    def Unpin(self) -> None: ...
+
+
+class OperationStatus(typing.SupportsInt):
+    @typing.overload
+    def __init__(self, value : int) -> None: ...
+    @typing.overload
+    def __init__(self, value : int, force_if_true: bool) -> None: ...
+    def __int__(self) -> int: ...
+    
+    # Values:
+    Done : OperationStatus # 0
+    DestinationTooSmall : OperationStatus # 1
+    NeedMoreData : OperationStatus # 2
+    InvalidData : OperationStatus # 3
+
+
+class ReadOnlySpanAction_GenericClasses(abc.ABCMeta):
+    Generic_ReadOnlySpanAction_GenericClasses_ReadOnlySpanAction_2_T = typing.TypeVar('Generic_ReadOnlySpanAction_GenericClasses_ReadOnlySpanAction_2_T')
+    Generic_ReadOnlySpanAction_GenericClasses_ReadOnlySpanAction_2_TArg = typing.TypeVar('Generic_ReadOnlySpanAction_GenericClasses_ReadOnlySpanAction_2_TArg')
+    def __getitem__(self, types : typing.Tuple[typing.Type[Generic_ReadOnlySpanAction_GenericClasses_ReadOnlySpanAction_2_T], typing.Type[Generic_ReadOnlySpanAction_GenericClasses_ReadOnlySpanAction_2_TArg]]) -> typing.Type[ReadOnlySpanAction_2[Generic_ReadOnlySpanAction_GenericClasses_ReadOnlySpanAction_2_T, Generic_ReadOnlySpanAction_GenericClasses_ReadOnlySpanAction_2_TArg]]: ...
+
+ReadOnlySpanAction : ReadOnlySpanAction_GenericClasses
+
+ReadOnlySpanAction_2_T = typing.TypeVar('ReadOnlySpanAction_2_T')
+ReadOnlySpanAction_2_TArg = typing.TypeVar('ReadOnlySpanAction_2_TArg', contravariant=True)
+class ReadOnlySpanAction_2(typing.Generic[ReadOnlySpanAction_2_T, ReadOnlySpanAction_2_TArg], MulticastDelegate):
+    def __init__(self, object: typing.Any, method: int) -> None: ...
+    @property
+    def Method(self) -> MethodInfo: ...
+    @property
+    def Target(self) -> typing.Any: ...
+    def BeginInvoke(self, span: ReadOnlySpan_1[ReadOnlySpanAction_2_T], arg: ReadOnlySpanAction_2_TArg, callback: AsyncCallback, object: typing.Any) -> IAsyncResult: ...
+    def EndInvoke(self, result: IAsyncResult) -> None: ...
+    def Invoke(self, span: ReadOnlySpan_1[ReadOnlySpanAction_2_T], arg: ReadOnlySpanAction_2_TArg) -> None: ...
+
+
+class SearchValues_GenericClasses(abc.ABCMeta):
+    Generic_SearchValues_GenericClasses_SearchValues_1_T = typing.TypeVar('Generic_SearchValues_GenericClasses_SearchValues_1_T')
+    def __getitem__(self, types : typing.Type[Generic_SearchValues_GenericClasses_SearchValues_1_T]) -> typing.Type[SearchValues_1[Generic_SearchValues_GenericClasses_SearchValues_1_T]]: ...
+
+class SearchValues(SearchValues_0, metaclass =SearchValues_GenericClasses): ...
+
+class SearchValues_0(abc.ABC):
+    # Skipped Create due to it being static, abstract and generic.
+
+    Create : Create_MethodGroup
+    class Create_MethodGroup:
+        @typing.overload
+        def __call__(self, values: ReadOnlySpan_1[int]) -> SearchValues_1[int]:...
+        @typing.overload
+        def __call__(self, values: ReadOnlySpan_1[str]) -> SearchValues_1[str]:...
+
+
+
+SearchValues_1_T = typing.TypeVar('SearchValues_1_T')
+class SearchValues_1(typing.Generic[SearchValues_1_T]):
+    def Contains(self, value: SearchValues_1_T) -> bool: ...
+
+
+class SpanAction_GenericClasses(abc.ABCMeta):
+    Generic_SpanAction_GenericClasses_SpanAction_2_T = typing.TypeVar('Generic_SpanAction_GenericClasses_SpanAction_2_T')
+    Generic_SpanAction_GenericClasses_SpanAction_2_TArg = typing.TypeVar('Generic_SpanAction_GenericClasses_SpanAction_2_TArg')
+    def __getitem__(self, types : typing.Tuple[typing.Type[Generic_SpanAction_GenericClasses_SpanAction_2_T], typing.Type[Generic_SpanAction_GenericClasses_SpanAction_2_TArg]]) -> typing.Type[SpanAction_2[Generic_SpanAction_GenericClasses_SpanAction_2_T, Generic_SpanAction_GenericClasses_SpanAction_2_TArg]]: ...
+
+SpanAction : SpanAction_GenericClasses
+
+SpanAction_2_T = typing.TypeVar('SpanAction_2_T')
+SpanAction_2_TArg = typing.TypeVar('SpanAction_2_TArg', contravariant=True)
+class SpanAction_2(typing.Generic[SpanAction_2_T, SpanAction_2_TArg], MulticastDelegate):
+    def __init__(self, object: typing.Any, method: int) -> None: ...
+    @property
+    def Method(self) -> MethodInfo: ...
+    @property
+    def Target(self) -> typing.Any: ...
+    def BeginInvoke(self, span: Span_1[SpanAction_2_T], arg: SpanAction_2_TArg, callback: AsyncCallback, object: typing.Any) -> IAsyncResult: ...
+    def EndInvoke(self, result: IAsyncResult) -> None: ...
+    def Invoke(self, span: Span_1[SpanAction_2_T], arg: SpanAction_2_TArg) -> None: ...
+
+
+class StandardFormat(IEquatable_1[StandardFormat]):
+    def __init__(self, symbol: str, precision: int = ...) -> None: ...
+    MaxPrecision : int
+    NoPrecision : int
+    @property
+    def HasPrecision(self) -> bool: ...
+    @property
+    def IsDefault(self) -> bool: ...
+    @property
+    def Precision(self) -> int: ...
+    @property
+    def Symbol(self) -> str: ...
+    def GetHashCode(self) -> int: ...
+    def __eq__(self, left: StandardFormat, right: StandardFormat) -> bool: ...
+    # Operator not supported op_Implicit(symbol: Char)
+    def __ne__(self, left: StandardFormat, right: StandardFormat) -> bool: ...
+    def ToString(self) -> str: ...
+    @staticmethod
+    def TryParse(format: ReadOnlySpan_1[str], result: clr.Reference[StandardFormat]) -> bool: ...
+    # Skipped Equals due to it being static, abstract and generic.
+
+    Equals : Equals_MethodGroup
+    class Equals_MethodGroup:
+        @typing.overload
+        def __call__(self, other: StandardFormat) -> bool:...
+        @typing.overload
+        def __call__(self, obj: typing.Any) -> bool:...
+
+    # Skipped Parse due to it being static, abstract and generic.
+
+    Parse : Parse_MethodGroup
+    class Parse_MethodGroup:
+        @typing.overload
+        def __call__(self, format: ReadOnlySpan_1[str]) -> StandardFormat:...
+        @typing.overload
+        def __call__(self, format: str) -> StandardFormat:...
+
+

PySimultan2/typings/System/CodeDom/Compiler/__init__.pyi

@@ -0,0 +1,137 @@
+import typing
+from System import Attribute, IFormatProvider, Array_1, ReadOnlyMemory_1
+from System.IO import TextWriter
+from System.Text import Encoding, StringBuilder
+from System.Threading.Tasks import ValueTask, Task
+from System.Threading import CancellationToken
+
+class GeneratedCodeAttribute(Attribute):
+    def __init__(self, tool: str, version: str) -> None: ...
+    @property
+    def Tool(self) -> str: ...
+    @property
+    def TypeId(self) -> typing.Any: ...
+    @property
+    def Version(self) -> str: ...
+
+
+class IndentedTextWriter(TextWriter):
+    @typing.overload
+    def __init__(self, writer: TextWriter) -> None: ...
+    @typing.overload
+    def __init__(self, writer: TextWriter, tabString: str) -> None: ...
+    DefaultTabString : str
+    @property
+    def Encoding(self) -> Encoding: ...
+    @property
+    def FormatProvider(self) -> IFormatProvider: ...
+    @property
+    def Indent(self) -> int: ...
+    @Indent.setter
+    def Indent(self, value: int) -> int: ...
+    @property
+    def InnerWriter(self) -> TextWriter: ...
+    @property
+    def NewLine(self) -> str: ...
+    @NewLine.setter
+    def NewLine(self, value: str) -> str: ...
+    def Close(self) -> None: ...
+    def DisposeAsync(self) -> ValueTask: ...
+    def Flush(self) -> None: ...
+    def WriteLineNoTabs(self, s: str) -> None: ...
+    def WriteLineNoTabsAsync(self, s: str) -> Task: ...
+    # Skipped FlushAsync due to it being static, abstract and generic.
+
+    FlushAsync : FlushAsync_MethodGroup
+    class FlushAsync_MethodGroup:
+        @typing.overload
+        def __call__(self) -> Task:...
+        @typing.overload
+        def __call__(self, cancellationToken: CancellationToken) -> Task:...
+
+    # Skipped Write due to it being static, abstract and generic.
+
+    Write : Write_MethodGroup
+    class Write_MethodGroup:
+        @typing.overload
+        def __call__(self, value: float) -> None:...
+        # Method Write(value : Single) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, s: str) -> None:...
+        # Method Write(value : Char) was skipped since it collides with above method
+        # Method Write(value : Int32) was skipped since it collides with above method
+        # Method Write(value : Int64) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, buffer: Array_1[str]) -> None:...
+        # Method Write(value : Boolean) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, value: typing.Any) -> None:...
+        @typing.overload
+        def __call__(self, format: str, arg: Array_1[typing.Any]) -> None:...
+        @typing.overload
+        def __call__(self, format: str, arg0: typing.Any) -> None:...
+        @typing.overload
+        def __call__(self, buffer: Array_1[str], index: int, count: int) -> None:...
+        @typing.overload
+        def __call__(self, format: str, arg0: typing.Any, arg1: typing.Any) -> None:...
+
+    # Skipped WriteAsync due to it being static, abstract and generic.
+
+    WriteAsync : WriteAsync_MethodGroup
+    class WriteAsync_MethodGroup:
+        @typing.overload
+        def __call__(self, value: str) -> Task:...
+        # Method WriteAsync(value : String) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, buffer: ReadOnlyMemory_1[str], cancellationToken: CancellationToken = ...) -> Task:...
+        @typing.overload
+        def __call__(self, value: StringBuilder, cancellationToken: CancellationToken = ...) -> Task:...
+        @typing.overload
+        def __call__(self, buffer: Array_1[str], index: int, count: int) -> Task:...
+
+    # Skipped WriteLine due to it being static, abstract and generic.
+
+    WriteLine : WriteLine_MethodGroup
+    class WriteLine_MethodGroup:
+        @typing.overload
+        def __call__(self) -> None:...
+        @typing.overload
+        def __call__(self, value: float) -> None:...
+        # Method WriteLine(value : Single) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, value: str) -> None:...
+        # Method WriteLine(value : Int32) was skipped since it collides with above method
+        # Method WriteLine(value : Int64) was skipped since it collides with above method
+        # Method WriteLine(value : UInt32) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, buffer: Array_1[str]) -> None:...
+        # Method WriteLine(s : String) was skipped since it collides with above method
+        # Method WriteLine(value : Boolean) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, value: typing.Any) -> None:...
+        @typing.overload
+        def __call__(self, format: str, arg: Array_1[typing.Any]) -> None:...
+        @typing.overload
+        def __call__(self, format: str, arg0: typing.Any) -> None:...
+        @typing.overload
+        def __call__(self, buffer: Array_1[str], index: int, count: int) -> None:...
+        @typing.overload
+        def __call__(self, format: str, arg0: typing.Any, arg1: typing.Any) -> None:...
+
+    # Skipped WriteLineAsync due to it being static, abstract and generic.
+
+    WriteLineAsync : WriteLineAsync_MethodGroup
+    class WriteLineAsync_MethodGroup:
+        @typing.overload
+        def __call__(self) -> Task:...
+        @typing.overload
+        def __call__(self, value: str) -> Task:...
+        # Method WriteLineAsync(value : String) was skipped since it collides with above method
+        @typing.overload
+        def __call__(self, buffer: ReadOnlyMemory_1[str], cancellationToken: CancellationToken = ...) -> Task:...
+        @typing.overload
+        def __call__(self, value: StringBuilder, cancellationToken: CancellationToken = ...) -> Task:...
+        @typing.overload
+        def __call__(self, buffer: Array_1[str], index: int, count: int) -> Task:...
+
+