dotnet.py

class Array(DotNetAbstractClass)
    def GetUpperBound(self, *args, **kwargs):
		""" Int32 GetUpperBound(Int32) """"
	
	def GetEnumerator(self, *args, **kwargs):
		""" System.Collections.IEnumerator GetEnumerator() """"
	
	IsReadOnly = False
	
	def GetValue(self, *args, **kwargs):
		pass
	
	LongLength = 0x00001L
	
	def FindAll(self, *args, **kwargs):
		""" T[] FindAll[T](T[], System.Predicate`1[T]) """"
	
	def SyncRoot(self, *args, **kwargs):
		pass
	
	def GetLowerBound(self, *args, **kwargs):
		""" Int32 GetLowerBound(Int32) """"
	
	@property
	def Rank(self):
		""" Int32 get_Rank() """"
	
	def LastIndexOf(self, *args, **kwargs):
		pass
	
	def Get(self, *args, **kwargs):
		""" System.String Get(Int32) """"
	
	def Clone(self, *args, **kwargs):
		""" System.Object Clone() """"
	
	IsSynchronized = False
	
	def BinarySearch(self, *args, **kwargs):
		pass
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def Sort(self, *args, **kwargs):
		pass
	
	def Address(self, *args, **kwargs):
		""" System.String& Address(Int32) """"
	
	def Initialize(self, *args, **kwargs):
		""" Void Initialize() """"
	
	def Copy(self, *args, **kwargs):
		pass
	
	@property
	def SyncRoot(self):
		""" System.Object get_SyncRoot() """"
	
	def Resize(self, *args, **kwargs):
		""" Void Resize[T](T[] ByRef, Int32) """"
	
	def ConstrainedCopy(self, *args, **kwargs):
		""" Void ConstrainedCopy(System.Array, Int32, System.Array, Int32, Int32) """"
	
	def FindIndex(self, *args, **kwargs):
		pass
	
	@property
	def IsFixedSize(self):
		""" Boolean get_IsFixedSize() """"
	
	def Reverse(self, *args, **kwargs):
		pass
	
	def GetLength(self, *args, **kwargs):
		""" Int32 GetLength(Int32) """"
	
	def Clear(self, *args, **kwargs):
		""" Void Clear(System.Array, Int32, Int32) """"
	
	def CreateInstance(self, *args, **kwargs):
		pass
	
	@property
	def IsReadOnly(self):
		""" Boolean get_IsReadOnly() """"
	
	def FindLast(self, *args, **kwargs):
		""" T FindLast[T](T[], System.Predicate`1[T]) """"
	
	def CopyTo(self, *args, **kwargs):
		pass
	
	def SetValue(self, *args, **kwargs):
		pass
	
	def GetLongLength(self, *args, **kwargs):
		""" Int64 GetLongLength(Int32) """"
	
	@property
	def IsSynchronized(self):
		""" Boolean get_IsSynchronized() """"
	
	def AsReadOnly(self, *args, **kwargs):
		""" System.Collections.ObjectModel.ReadOnlyCollection`1[T] AsReadOnly[T](T[]) """"
	
	@property
	def Length(self):
		""" Int32 get_Length() """"
	
	def Set(self, *args, **kwargs):
		""" Void Set(Int32, System.String) """"
	
	def Exists(self, *args, **kwargs):
		""" Boolean Exists[T](T[], System.Predicate`1[T]) """"
	
	def FindLastIndex(self, *args, **kwargs):
		pass
	
	def IndexOf(self, *args, **kwargs):
		pass
	
	def TrueForAll(self, *args, **kwargs):
		""" Boolean TrueForAll[T](T[], System.Predicate`1[T]) """"
	
	Length = 1
	
	Rank = 1
	
	IsFixedSize = True
	
	@property
	def LongLength(self):
		""" Int64 get_LongLength() """"
	
	def ConvertAll(self, *args, **kwargs):
		""" TOutput[] ConvertAll[TInput,TOutput](TInput[], System.Converter`2[TInput,TOutput]) """"
	
	def ForEach(self, *args, **kwargs):
		""" Void ForEach[T](T[], System.Action`1[T]) """"
	
	def Find(self, *args, **kwargs):
		""" T Find[T](T[], System.Predicate`1[T]) """"
	

class Tuple(DotNetAbstractClass)
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	Item1 = "0"
	
	@property
	def Item1(self):
		""" System.String get_Item1() """"
	

class Object(DotNetInstClass)
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	

class String(DotNetInstClass)
	def Normalize(self, *args, **kwargs):
		pass
	
	def GetEnumerator(self, *args, **kwargs):
		""" System.CharEnumerator GetEnumerator() """"
	
	def CompareOrdinal(self, *args, **kwargs):
		pass
	
	def Contains(self, *args, **kwargs):
		""" Boolean Contains(System.String) """"
	
	def op_Equality(self, *args, **kwargs):
		""" Boolean op_Equality(System.String, System.String) """"
	
	def EndsWith(self, *args, **kwargs):
		pass
	
	def Split(self, *args, **kwargs):
		pass
	
	def ToUpper(self, *args, **kwargs):
		pass
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def ToUpperInvariant(self, *args, **kwargs):
		""" System.String ToUpperInvariant() """"
	
	def TrimEnd(self, *args, **kwargs):
		""" System.String TrimEnd(Char[]) """"
	
	Empty = ""
	
	def PadLeft(self, *args, **kwargs):
		pass
	
	def LastIndexOf(self, *args, **kwargs):
		pass
	
	def Format(self, *args, **kwargs):
		pass
	
	def LastIndexOfAny(self, *args, **kwargs):
		pass
	
	def Clone(self, *args, **kwargs):
		""" System.Object Clone() """"
	
	def IsInterned(self, *args, **kwargs):
		""" System.String IsInterned(System.String) """"
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def Copy(self, *args, **kwargs):
		""" System.String Copy(System.String) """"
	
	def op_Inequality(self, *args, **kwargs):
		""" Boolean op_Inequality(System.String, System.String) """"
	
	def Concat(self, *args, **kwargs):
		pass
	
	def PadRight(self, *args, **kwargs):
		pass
	
	def Insert(self, *args, **kwargs):
		""" System.String Insert(Int32, System.String) """"
	
	def Join(self, *args, **kwargs):
		pass
	
	def ToLower(self, *args, **kwargs):
		pass
	
	def Remove(self, *args, **kwargs):
		pass
	
	def CopyTo(self, *args, **kwargs):
		""" Void CopyTo(Int32, Char[], Int32, Int32) """"
	
	Length = 0
	
	def ToLowerInvariant(self, *args, **kwargs):
		""" System.String ToLowerInvariant() """"
	
	def Trim(self, *args, **kwargs):
		pass
	
	@property
	def Length(self):
		""" Int32 get_Length() """"
	
	def Compare(self, *args, **kwargs):
		pass
	
	@property
	def Chars(self):
		""" Char get_Chars(Int32) """"
	
	def IndexOf(self, *args, **kwargs):
		pass
	
	def IsNormalized(self, *args, **kwargs):
		pass
	
	def IndexOfAny(self, *args, **kwargs):
		pass
	
	def Replace(self, *args, **kwargs):
		pass
	
	def Substring(self, *args, **kwargs):
		pass
	
	def Intern(self, *args, **kwargs):
		""" System.String Intern(System.String) """"
	
	def StartsWith(self, *args, **kwargs):
		pass
	
	def TrimStart(self, *args, **kwargs):
		""" System.String TrimStart(Char[]) """"
	
	def IsNullOrWhiteSpace(self, *args, **kwargs):
		""" Boolean IsNullOrWhiteSpace(System.String) """"
	
	def IsNullOrEmpty(self, *args, **kwargs):
		""" Boolean IsNullOrEmpty(System.String) """"
	
	def ToCharArray(self, *args, **kwargs):
		pass
	

class Uri(DotNetInstClass)
	@property
	def Scheme(self):
		""" System.String get_Scheme() """"
	
	def IsReservedCharacter(self, *args, **kwargs):
		""" Boolean IsReservedCharacter(Char) """"
	
	@property
	def PathAndQuery(self):
		""" System.String get_PathAndQuery() """"
	
	AbsoluteUri = "http://example.com/"
	
	@property
	def AbsolutePath(self):
		""" System.String get_AbsolutePath() """"
	
	def FromHex(self, *args, **kwargs):
		""" Int32 FromHex(Char) """"
	
	def IsWellFormedOriginalString(self, *args, **kwargs):
		""" Boolean IsWellFormedOriginalString() """"
	
	def Segments(self, *args, **kwargs):
		pass
	
	@property
	def IsAbsoluteUri(self):
		""" Boolean get_IsAbsoluteUri() """"
	
	@property
	def IsLoopback(self):
		""" Boolean get_IsLoopback() """"
	
	def UnescapeDataString(self, *args, **kwargs):
		""" System.String UnescapeDataString(System.String) """"
	
	UriSchemeNetPipe = "net.pipe"
	
	def CheckHostName(self, *args, **kwargs):
		""" System.UriHostNameType CheckHostName(System.String) """"
	
	UriSchemeHttps = "https"
	
	def IsWellFormedUriString(self, *args, **kwargs):
		""" Boolean IsWellFormedUriString(System.String, System.UriKind) """"
	
	IsFile = False
	
	IsUnc = False
	
	UriSchemeHttp = "http"
	
	PathAndQuery = "/"
	
	UriSchemeNntp = "nntp"
	
	def HexEscape(self, *args, **kwargs):
		""" System.String HexEscape(Char) """"
	
	UriSchemeFtp = "ftp"
	
	HostNameType = 2
	
	Fragment = ""
	
	SchemeDelimiter = "://"
	
	@property
	def Query(self):
		""" System.String get_Query() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	UriSchemeNetTcp = "net.tcp"
	
	def GetLeftPart(self, *args, **kwargs):
		""" System.String GetLeftPart(System.UriPartial) """"
	
	@property
	def HostNameType(self):
		""" System.UriHostNameType get_HostNameType() """"
	
	@property
	def Segments(self):
		""" System.String[] get_Segments() """"
	
	Host = "example.com"
	
	def IsExcludedCharacter(self, *args, **kwargs):
		""" Boolean IsExcludedCharacter(Char) """"
	
	def GetComponents(self, *args, **kwargs):
		""" System.String GetComponents(System.UriComponents, System.UriFormat) """"
	
	DnsSafeHost = "example.com"
	
	UriSchemeFile = "file"
	
	def IsBadFileSystemCharacter(self, *args, **kwargs):
		""" Boolean IsBadFileSystemCharacter(Char) """"
	
	def EscapeDataString(self, *args, **kwargs):
		""" System.String EscapeDataString(System.String) """"
	
	def MakeRelativeUri(self, *args, **kwargs):
		""" System.Uri MakeRelativeUri(System.Uri) """"
	
	def GetObjectData(self, *args, **kwargs):
		""" Void GetObjectData(System.Runtime.Serialization.SerializationInfo, System.Runtime.Serialization.StreamingContext) """"
	
	@property
	def DnsSafeHost(self):
		""" System.String get_DnsSafeHost() """"
	
	IsDefaultPort = True
	
	@property
	def UserInfo(self):
		""" System.String get_UserInfo() """"
	
	UriSchemeMailto = "mailto"
	
	@property
	def Authority(self):
		""" System.String get_Authority() """"
	
	def Unescape(self, *args, **kwargs):
		""" System.String Unescape(System.String) """"
	
	def EscapeUriString(self, *args, **kwargs):
		""" System.String EscapeUriString(System.String) """"
	
	def CheckSecurity(self, *args, **kwargs):
		""" Void CheckSecurity() """"
	
	def TryCreate(self, *args, **kwargs):
		pass
	
	UserEscaped = False
	
	def HexUnescape(self, *args, **kwargs):
		""" Char HexUnescape(System.String, Int32 ByRef) """"
	
	LocalPath = "/"
	
	AbsolutePath = "/"
	
	@property
	def OriginalString(self):
		""" System.String get_OriginalString() """"
	
	def op_Equality(self, *args, **kwargs):
		""" Boolean op_Equality(System.Uri, System.Uri) """"
	
	def IsBaseOf(self, *args, **kwargs):
		""" Boolean IsBaseOf(System.Uri) """"
	
	def MakeRelative(self, *args, **kwargs):
		""" System.String MakeRelative(System.Uri) """"
	
	@property
	def Port(self):
		""" Int32 get_Port() """"
	
	@property
	def AbsoluteUri(self):
		""" System.String get_AbsoluteUri() """"
	
	@property
	def LocalPath(self):
		""" System.String get_LocalPath() """"
	
	def CheckSchemeName(self, *args, **kwargs):
		""" Boolean CheckSchemeName(System.String) """"
	
	def IsHexEncoding(self, *args, **kwargs):
		""" Boolean IsHexEncoding(System.String, Int32) """"
	
	OriginalString = "http://example.com"
	
	def Compare(self, *args, **kwargs):
		""" Int32 Compare(System.Uri, System.Uri, System.UriComponents, System.UriFormat, System.StringComparison) """"
	
	UriSchemeGopher = "gopher"
	
	@property
	def IsUnc(self):
		""" Boolean get_IsUnc() """"
	
	@property
	def IsDefaultPort(self):
		""" Boolean get_IsDefaultPort() """"
	
	@property
	def Fragment(self):
		""" System.String get_Fragment() """"
	
	def IsHexDigit(self, *args, **kwargs):
		""" Boolean IsHexDigit(Char) """"
	
	@property
	def Host(self):
		""" System.String get_Host() """"
	
	Authority = "example.com"
	
	Port = 80
	
	def Parse(self, *args, **kwargs):
		""" Void Parse() """"
	
	@property
	def UserEscaped(self):
		""" Boolean get_UserEscaped() """"
	
	@property
	def IsFile(self):
		""" Boolean get_IsFile() """"
	
	def op_Inequality(self, *args, **kwargs):
		""" Boolean op_Inequality(System.Uri, System.Uri) """"
	
	UserInfo = ""
	
	def Escape(self, *args, **kwargs):
		""" Void Escape() """"
	
	def Canonicalize(self, *args, **kwargs):
		""" Void Canonicalize() """"
	
	Query = ""
	
	IsAbsoluteUri = True
	
	UriSchemeNews = "news"
	
	Scheme = "http"
	
	IsLoopback = False
	
	def EscapeString(self, *args, **kwargs):
		""" System.String EscapeString(System.String) """"
	

class Boolean(DotNetStructure)
	def Parse(self, *args, **kwargs):
		""" Boolean Parse(System.String) """"
	
	FalseString = "False"
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	TrueString = "True"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		""" Boolean TryParse(System.String, Boolean ByRef) """"
	

class Byte(DotNetStructure)
	def Parse(self, *args, **kwargs):
		pass
	
	MaxValue = 255
	
	MinValue = 0
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		pass
	

class Char(DotNetStructure)
	def ConvertToUtf32(self, *args, **kwargs):
		pass
	
	def IsHighSurrogate(self, *args, **kwargs):
		pass
	
	def IsSeparator(self, *args, **kwargs):
		pass
	
	def IsPunctuation(self, *args, **kwargs):
		pass
	
	def ToUpper(self, *args, **kwargs):
		pass
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def IsDigit(self, *args, **kwargs):
		pass
	
	def ToUpperInvariant(self, *args, **kwargs):
		""" Char ToUpperInvariant(Char) """"
	
	def IsSymbol(self, *args, **kwargs):
		pass
	
	def IsLetterOrDigit(self, *args, **kwargs):
		pass
	
	def IsLetter(self, *args, **kwargs):
		pass
	
	def GetUnicodeCategory(self, *args, **kwargs):
		pass
	
	MinValue = "\x00"
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def IsSurrogatePair(self, *args, **kwargs):
		pass
	
	def IsWhiteSpace(self, *args, **kwargs):
		pass
	
	def IsLowSurrogate(self, *args, **kwargs):
		pass
	
	def GetNumericValue(self, *args, **kwargs):
		pass
	
	def ToLower(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		""" Boolean TryParse(System.String, Char ByRef) """"
	
	def IsSurrogate(self, *args, **kwargs):
		pass
	
	def ToLowerInvariant(self, *args, **kwargs):
		""" Char ToLowerInvariant(Char) """"
	
	def IsUpper(self, *args, **kwargs):
		pass
	
	MaxValue = "\xFFFF"
	
	def ConvertFromUtf32(self, *args, **kwargs):
		""" System.String ConvertFromUtf32(Int32) """"
	
	def Parse(self, *args, **kwargs):
		""" Char Parse(System.String) """"
	
	def IsControl(self, *args, **kwargs):
		pass
	
	def IsLower(self, *args, **kwargs):
		pass
	
	def IsNumber(self, *args, **kwargs):
		pass
	

class DateTime(DotNetStructure)
	Millisecond = 0
	
	def ParseExact(self, *args, **kwargs):
		pass
	
	def AddSeconds(self, *args, **kwargs):
		""" System.DateTime AddSeconds(Double) """"
	
	def AddHours(self, *args, **kwargs):
		""" System.DateTime AddHours(Double) """"
	
	def ToFileTimeUtc(self, *args, **kwargs):
		""" Int64 ToFileTimeUtc() """"
	
	@property
	def Ticks(self):
		""" Int64 get_Ticks() """"
	
	Ticks = 0x00000L
	
	def FromBinary(self, *args, **kwargs):
		""" System.DateTime FromBinary(Int64) """"
	
	def ToLongTimeString(self, *args, **kwargs):
		""" System.String ToLongTimeString() """"
	
	def ToBinary(self, *args, **kwargs):
		""" Int64 ToBinary() """"
	
	def AddTicks(self, *args, **kwargs):
		""" System.DateTime AddTicks(Int64) """"
	
	def Add(self, *args, **kwargs):
		""" System.DateTime Add(System.TimeSpan) """"
	
	def op_LessThan(self, *args, **kwargs):
		""" Boolean op_LessThan(System.DateTime, System.DateTime) """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParseExact(self, *args, **kwargs):
		pass
	
	def TimeOfDay(self, *args, **kwargs):
		pass
	
	def AddYears(self, *args, **kwargs):
		""" System.DateTime AddYears(Int32) """"
	
	def Today(self, *args, **kwargs):
		pass
	
	@property
	def Month(self):
		""" Int32 get_Month() """"
	
	DayOfWeek = 1
	
	def Parse(self, *args, **kwargs):
		pass
	
	def op_Inequality(self, *args, **kwargs):
		""" Boolean op_Inequality(System.DateTime, System.DateTime) """"
	
	def op_LessThanOrEqual(self, *args, **kwargs):
		""" Boolean op_LessThanOrEqual(System.DateTime, System.DateTime) """"
	
	def IsLeapYear(self, *args, **kwargs):
		""" Boolean IsLeapYear(Int32) """"
	
	@property
	def Second(self):
		""" Int32 get_Second() """"
	
	def op_GreaterThan(self, *args, **kwargs):
		""" Boolean op_GreaterThan(System.DateTime, System.DateTime) """"
	
	Second = 0
	
	@property
	def TimeOfDay(self):
		""" System.TimeSpan get_TimeOfDay() """"
	
	def MinValue(self, *args, **kwargs):
		pass
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def op_Subtraction(self, *args, **kwargs):
		pass
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def ToLongDateString(self, *args, **kwargs):
		""" System.String ToLongDateString() """"
	
	def Date(self, *args, **kwargs):
		pass
	
	@property
	def Today(self):
		""" System.DateTime get_Today() """"
	
	def Now(self, *args, **kwargs):
		pass
	
	def Subtract(self, *args, **kwargs):
		pass
	
	Day = 1
	
	Minute = 0
	
	Kind = 0
	
	@property
	def UtcNow(self):
		""" System.DateTime get_UtcNow() """"
	
	def ToLocalTime(self, *args, **kwargs):
		""" System.DateTime ToLocalTime() """"
	
	@property
	def DayOfWeek(self):
		""" System.DayOfWeek get_DayOfWeek() """"
	
	Hour = 0
	
	def ToShortDateString(self, *args, **kwargs):
		""" System.String ToShortDateString() """"
	
	@property
	def Minute(self):
		""" Int32 get_Minute() """"
	
	def FromFileTime(self, *args, **kwargs):
		""" System.DateTime FromFileTime(Int64) """"
	
	@property
	def DayOfYear(self):
		""" Int32 get_DayOfYear() """"
	
	def Compare(self, *args, **kwargs):
		""" Int32 Compare(System.DateTime, System.DateTime) """"
	
	def AddMonths(self, *args, **kwargs):
		""" System.DateTime AddMonths(Int32) """"
	
	def op_Equality(self, *args, **kwargs):
		""" Boolean op_Equality(System.DateTime, System.DateTime) """"
	
	def ToUniversalTime(self, *args, **kwargs):
		""" System.DateTime ToUniversalTime() """"
	
	DayOfYear = 1
	
	def UtcNow(self, *args, **kwargs):
		pass
	
	@property
	def Kind(self):
		""" System.DateTimeKind get_Kind() """"
	
	@property
	def Year(self):
		""" Int32 get_Year() """"
	
	@property
	def Hour(self):
		""" Int32 get_Hour() """"
	
	def ToShortTimeString(self, *args, **kwargs):
		""" System.String ToShortTimeString() """"
	
	@property
	def Date(self):
		""" System.DateTime get_Date() """"
	
	def op_GreaterThanOrEqual(self, *args, **kwargs):
		""" Boolean op_GreaterThanOrEqual(System.DateTime, System.DateTime) """"
	
	def GetDateTimeFormats(self, *args, **kwargs):
		pass
	
	def ToFileTime(self, *args, **kwargs):
		""" Int64 ToFileTime() """"
	
	def AddMinutes(self, *args, **kwargs):
		""" System.DateTime AddMinutes(Double) """"
	
	def op_Addition(self, *args, **kwargs):
		""" System.DateTime op_Addition(System.DateTime, System.TimeSpan) """"
	
	def SpecifyKind(self, *args, **kwargs):
		""" System.DateTime SpecifyKind(System.DateTime, System.DateTimeKind) """"
	
	@property
	def Day(self):
		""" Int32 get_Day() """"
	
	def FromOADate(self, *args, **kwargs):
		""" System.DateTime FromOADate(Double) """"
	
	def AddDays(self, *args, **kwargs):
		""" System.DateTime AddDays(Double) """"
	
	def MaxValue(self, *args, **kwargs):
		pass
	
	@property
	def Now(self):
		""" System.DateTime get_Now() """"
	
	Month = 1
	
	def AddMilliseconds(self, *args, **kwargs):
		""" System.DateTime AddMilliseconds(Double) """"
	
	def FromFileTimeUtc(self, *args, **kwargs):
		""" System.DateTime FromFileTimeUtc(Int64) """"
	
	def IsDaylightSavingTime(self, *args, **kwargs):
		""" Boolean IsDaylightSavingTime() """"
	
	@property
	def Millisecond(self):
		""" Int32 get_Millisecond() """"
	
	Year = 1
	
	def TryParse(self, *args, **kwargs):
		pass
	
	def DaysInMonth(self, *args, **kwargs):
		""" Int32 DaysInMonth(Int32, Int32) """"
	
	def ToOADate(self, *args, **kwargs):
		""" Double ToOADate() """"
	

class Decimal(DotNetStructure)
	def ToUInt32(self, *args, **kwargs):
		""" UInt32 ToUInt32(System.Decimal) """"
	
	def op_Multiply(self, *args, **kwargs):
		""" System.Decimal op_Multiply(System.Decimal, System.Decimal) """"
	
	def Floor(self, *args, **kwargs):
		""" System.Decimal Floor(System.Decimal) """"
	
	def op_Subtraction(self, *args, **kwargs):
		""" System.Decimal op_Subtraction(System.Decimal, System.Decimal) """"
	
	def ToUInt16(self, *args, **kwargs):
		""" UInt16 ToUInt16(System.Decimal) """"
	
	def op_Equality(self, *args, **kwargs):
		""" Boolean op_Equality(System.Decimal, System.Decimal) """"
	
	def Add(self, *args, **kwargs):
		""" System.Decimal Add(System.Decimal, System.Decimal) """"
	
	def ToDouble(self, *args, **kwargs):
		""" Double ToDouble(System.Decimal) """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def op_GreaterThan(self, *args, **kwargs):
		""" Boolean op_GreaterThan(System.Decimal, System.Decimal) """"
	
	def ToInt16(self, *args, **kwargs):
		""" Int16 ToInt16(System.Decimal) """"
	
	def op_GreaterThanOrEqual(self, *args, **kwargs):
		""" Boolean op_GreaterThanOrEqual(System.Decimal, System.Decimal) """"
	
	def Ceiling(self, *args, **kwargs):
		""" System.Decimal Ceiling(System.Decimal) """"
	
	def op_Inequality(self, *args, **kwargs):
		""" Boolean op_Inequality(System.Decimal, System.Decimal) """"
	
	def Truncate(self, *args, **kwargs):
		""" System.Decimal Truncate(System.Decimal) """"
	
	def ToByte(self, *args, **kwargs):
		""" Byte ToByte(System.Decimal) """"
	
	def op_Modulus(self, *args, **kwargs):
		""" System.Decimal op_Modulus(System.Decimal, System.Decimal) """"
	
	def op_Explicit(self, *args, **kwargs):
		pass
	
	def MinValue(self, *args, **kwargs):
		pass
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def op_UnaryPlus(self, *args, **kwargs):
		""" System.Decimal op_UnaryPlus(System.Decimal) """"
	
	def Multiply(self, *args, **kwargs):
		""" System.Decimal Multiply(System.Decimal, System.Decimal) """"
	
	def op_LessThan(self, *args, **kwargs):
		""" Boolean op_LessThan(System.Decimal, System.Decimal) """"
	
	def Remainder(self, *args, **kwargs):
		""" System.Decimal Remainder(System.Decimal, System.Decimal) """"
	
	def ToInt32(self, *args, **kwargs):
		""" Int32 ToInt32(System.Decimal) """"
	
	def op_Decrement(self, *args, **kwargs):
		""" System.Decimal op_Decrement(System.Decimal) """"
	
	def op_Division(self, *args, **kwargs):
		""" System.Decimal op_Division(System.Decimal, System.Decimal) """"
	
	def ToUInt64(self, *args, **kwargs):
		""" UInt64 ToUInt64(System.Decimal) """"
	
	def op_Increment(self, *args, **kwargs):
		""" System.Decimal op_Increment(System.Decimal) """"
	
	def TryParse(self, *args, **kwargs):
		pass
	
	def GetBits(self, *args, **kwargs):
		""" Int32[] GetBits(System.Decimal) """"
	
	def op_Implicit(self, *args, **kwargs):
		pass
	
	def op_LessThanOrEqual(self, *args, **kwargs):
		""" Boolean op_LessThanOrEqual(System.Decimal, System.Decimal) """"
	
	def ToSByte(self, *args, **kwargs):
		""" SByte ToSByte(System.Decimal) """"
	
	def MinusOne(self, *args, **kwargs):
		pass
	
	def Round(self, *args, **kwargs):
		pass
	
	def Compare(self, *args, **kwargs):
		""" Int32 Compare(System.Decimal, System.Decimal) """"
	
	def FromOACurrency(self, *args, **kwargs):
		""" System.Decimal FromOACurrency(Int64) """"
	
	def Divide(self, *args, **kwargs):
		""" System.Decimal Divide(System.Decimal, System.Decimal) """"
	
	def ToInt64(self, *args, **kwargs):
		""" Int64 ToInt64(System.Decimal) """"
	
	def Subtract(self, *args, **kwargs):
		""" System.Decimal Subtract(System.Decimal, System.Decimal) """"
	
	def MaxValue(self, *args, **kwargs):
		pass
	
	def One(self, *args, **kwargs):
		pass
	
	def Parse(self, *args, **kwargs):
		pass
	
	def Zero(self, *args, **kwargs):
		pass
	
	def ToSingle(self, *args, **kwargs):
		""" Single ToSingle(System.Decimal) """"
	
	def Negate(self, *args, **kwargs):
		""" System.Decimal Negate(System.Decimal) """"
	
	def op_UnaryNegation(self, *args, **kwargs):
		""" System.Decimal op_UnaryNegation(System.Decimal) """"
	
	def ToOACurrency(self, *args, **kwargs):
		""" Int64 ToOACurrency(System.Decimal) """"
	
	def op_Addition(self, *args, **kwargs):
		""" System.Decimal op_Addition(System.Decimal, System.Decimal) """"
	

class Double(DotNetStructure)
	def Parse(self, *args, **kwargs):
		pass
	
	def IsNaN(self, *args, **kwargs):
		""" Boolean IsNaN(Double) """"
	
	def op_LessThanOrEqual(self, *args, **kwargs):
		""" Boolean op_LessThanOrEqual(Double, Double) """"
	
	NegativeInfinity = -inf
	
	PositiveInfinity = inf
	
	Epsilon = 4.94065645841e-324
	
	def op_LessThan(self, *args, **kwargs):
		""" Boolean op_LessThan(Double, Double) """"
	
	NaN = nan
	
	MaxValue = 1.79769313486e+308
	
	def IsNegativeInfinity(self, *args, **kwargs):
		""" Boolean IsNegativeInfinity(Double) """"
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	MinValue = -1.79769313486e+308
	
	def op_Equality(self, *args, **kwargs):
		""" Boolean op_Equality(Double, Double) """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		pass
	
	def op_GreaterThan(self, *args, **kwargs):
		""" Boolean op_GreaterThan(Double, Double) """"
	
	def IsPositiveInfinity(self, *args, **kwargs):
		""" Boolean IsPositiveInfinity(Double) """"
	
	def op_Inequality(self, *args, **kwargs):
		""" Boolean op_Inequality(Double, Double) """"
	
	def op_GreaterThanOrEqual(self, *args, **kwargs):
		""" Boolean op_GreaterThanOrEqual(Double, Double) """"
	
	def IsInfinity(self, *args, **kwargs):
		""" Boolean IsInfinity(Double) """"
	

class Guid(DotNetStructure)
	def ParseExact(self, *args, **kwargs):
		""" System.Guid ParseExact(System.String, System.String) """"
	
	def TryParseExact(self, *args, **kwargs):
		""" Boolean TryParseExact(System.String, System.String, System.Guid ByRef) """"
	
	def NewGuid(self, *args, **kwargs):
		""" System.Guid NewGuid() """"
	
	def op_Equality(self, *args, **kwargs):
		""" Boolean op_Equality(System.Guid, System.Guid) """"
	
	def Parse(self, *args, **kwargs):
		""" System.Guid Parse(System.String) """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def ToByteArray(self, *args, **kwargs):
		""" Byte[] ToByteArray() """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		""" Boolean TryParse(System.String, System.Guid ByRef) """"
	
	def op_Inequality(self, *args, **kwargs):
		""" Boolean op_Inequality(System.Guid, System.Guid) """"
	
	def Empty(self, *args, **kwargs):
		pass
	

class Int16(DotNetStructure)
	def Parse(self, *args, **kwargs):
		pass
	
	MaxValue = 32767
	
	MinValue = -32768
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		pass
	

class Int32(DotNetStructure)
	def Parse(self, *args, **kwargs):
		pass
	
	MaxValue = 2147483647
	
	MinValue = -2147483648
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		pass
	

class Int64(DotNetStructure)
	def Parse(self, *args, **kwargs):
		pass
	
	MaxValue = 0x7FFFFFFFFFFFFFFFL
	
	MinValue = 0x-8000000000000000L
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		pass
	

class IntPtr(DotNetStructure)
	def op_Explicit(self, *args, **kwargs):
		pass
	
	def op_Addition(self, *args, **kwargs):
		""" IntPtr op_Addition(IntPtr, Int32) """"
	
	def ToInt64(self, *args, **kwargs):
		""" Int64 ToInt64() """"
	
	def op_Subtraction(self, *args, **kwargs):
		""" IntPtr op_Subtraction(IntPtr, Int32) """"
	
	def op_Inequality(self, *args, **kwargs):
		""" Boolean op_Inequality(IntPtr, IntPtr) """"
	
	def ToPointer(self, *args, **kwargs):
		""" Void* ToPointer() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def op_Equality(self, *args, **kwargs):
		""" Boolean op_Equality(IntPtr, IntPtr) """"
	
	@property
	def Size(self):
		""" Int32 get_Size() """"
	
	def Add(self, *args, **kwargs):
		""" IntPtr Add(IntPtr, Int32) """"
	
	def Zero(self, *args, **kwargs):
		pass
	
	def Subtract(self, *args, **kwargs):
		""" IntPtr Subtract(IntPtr, Int32) """"
	
	def ToInt32(self, *args, **kwargs):
		""" Int32 ToInt32() """"
	
	Size = 4
	

class SByte(DotNetStructure)
	def Parse(self, *args, **kwargs):
		pass
	
	MaxValue = 127
	
	MinValue = -128
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		pass
	

class Single(DotNetStructure)
	def Parse(self, *args, **kwargs):
		pass
	
	def IsNaN(self, *args, **kwargs):
		""" Boolean IsNaN(Single) """"
	
	def op_LessThanOrEqual(self, *args, **kwargs):
		""" Boolean op_LessThanOrEqual(Single, Single) """"
	
	NegativeInfinity = -inf
	
	PositiveInfinity = inf
	
	Epsilon = 1.401298e-45
	
	def op_LessThan(self, *args, **kwargs):
		""" Boolean op_LessThan(Single, Single) """"
	
	NaN = nan
	
	MaxValue = 3.402823e+38
	
	def IsNegativeInfinity(self, *args, **kwargs):
		""" Boolean IsNegativeInfinity(Single) """"
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	MinValue = -3.402823e+38
	
	def op_Equality(self, *args, **kwargs):
		""" Boolean op_Equality(Single, Single) """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		pass
	
	def op_GreaterThan(self, *args, **kwargs):
		""" Boolean op_GreaterThan(Single, Single) """"
	
	def IsPositiveInfinity(self, *args, **kwargs):
		""" Boolean IsPositiveInfinity(Single) """"
	
	def op_Inequality(self, *args, **kwargs):
		""" Boolean op_Inequality(Single, Single) """"
	
	def op_GreaterThanOrEqual(self, *args, **kwargs):
		""" Boolean op_GreaterThanOrEqual(Single, Single) """"
	
	def IsInfinity(self, *args, **kwargs):
		""" Boolean IsInfinity(Single) """"
	

class TimeSpan(DotNetStructure)
	def ParseExact(self, *args, **kwargs):
		pass
	
	def FromMilliseconds(self, *args, **kwargs):
		""" System.TimeSpan FromMilliseconds(Double) """"
	
	def FromTicks(self, *args, **kwargs):
		""" System.TimeSpan FromTicks(Int64) """"
	
	def op_Subtraction(self, *args, **kwargs):
		""" System.TimeSpan op_Subtraction(System.TimeSpan, System.TimeSpan) """"
	
	@property
	def TotalMilliseconds(self):
		""" Double get_TotalMilliseconds() """"
	
	@property
	def Days(self):
		""" Int32 get_Days() """"
	
	Ticks = 0x00000L
	
	TotalDays = 0.0
	
	def op_Equality(self, *args, **kwargs):
		""" Boolean op_Equality(System.TimeSpan, System.TimeSpan) """"
	
	def Add(self, *args, **kwargs):
		""" System.TimeSpan Add(System.TimeSpan) """"
	
	def op_UnaryNegation(self, *args, **kwargs):
		""" System.TimeSpan op_UnaryNegation(System.TimeSpan) """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def op_GreaterThan(self, *args, **kwargs):
		""" Boolean op_GreaterThan(System.TimeSpan, System.TimeSpan) """"
	
	def TryParse(self, *args, **kwargs):
		pass
	
	@property
	def Minutes(self):
		""" Int32 get_Minutes() """"
	
	Milliseconds = 0
	
	@property
	def TotalDays(self):
		""" Double get_TotalDays() """"
	
	TicksPerDay = 0xC92A69C000L
	
	def op_Inequality(self, *args, **kwargs):
		""" Boolean op_Inequality(System.TimeSpan, System.TimeSpan) """"
	
	def FromSeconds(self, *args, **kwargs):
		""" System.TimeSpan FromSeconds(Double) """"
	
	TicksPerSecond = 0x989680L
	
	Seconds = 0
	
	@property
	def TotalSeconds(self):
		""" Double get_TotalSeconds() """"
	
	def MinValue(self, *args, **kwargs):
		pass
	
	Hours = 0
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def op_UnaryPlus(self, *args, **kwargs):
		""" System.TimeSpan op_UnaryPlus(System.TimeSpan) """"
	
	@property
	def TotalMinutes(self):
		""" Double get_TotalMinutes() """"
	
	TicksPerMinute = 0x23C34600L
	
	def Subtract(self, *args, **kwargs):
		""" System.TimeSpan Subtract(System.TimeSpan) """"
	
	@property
	def TotalHours(self):
		""" Double get_TotalHours() """"
	
	def FromDays(self, *args, **kwargs):
		""" System.TimeSpan FromDays(Double) """"
	
	def TryParseExact(self, *args, **kwargs):
		pass
	
	TotalMilliseconds = 0.0
	
	def op_GreaterThanOrEqual(self, *args, **kwargs):
		""" Boolean op_GreaterThanOrEqual(System.TimeSpan, System.TimeSpan) """"
	
	def op_LessThan(self, *args, **kwargs):
		""" Boolean op_LessThan(System.TimeSpan, System.TimeSpan) """"
	
	@property
	def Ticks(self):
		""" Int64 get_Ticks() """"
	
	Days = 0
	
	@property
	def Milliseconds(self):
		""" Int32 get_Milliseconds() """"
	
	def FromMinutes(self, *args, **kwargs):
		""" System.TimeSpan FromMinutes(Double) """"
	
	def Duration(self, *args, **kwargs):
		""" System.TimeSpan Duration() """"
	
	@property
	def Hours(self):
		""" Int32 get_Hours() """"
	
	TotalHours = 0.0
	
	@property
	def Seconds(self):
		""" Int32 get_Seconds() """"
	
	Minutes = 0
	
	def Compare(self, *args, **kwargs):
		""" Int32 Compare(System.TimeSpan, System.TimeSpan) """"
	
	def op_Addition(self, *args, **kwargs):
		""" System.TimeSpan op_Addition(System.TimeSpan, System.TimeSpan) """"
	
	TotalMinutes = 0.0
	
	def FromHours(self, *args, **kwargs):
		""" System.TimeSpan FromHours(Double) """"
	
	def MaxValue(self, *args, **kwargs):
		pass
	
	def Parse(self, *args, **kwargs):
		pass
	
	def Zero(self, *args, **kwargs):
		pass
	
	def op_LessThanOrEqual(self, *args, **kwargs):
		""" Boolean op_LessThanOrEqual(System.TimeSpan, System.TimeSpan) """"
	
	TicksPerMillisecond = 0x02710L
	
	def Negate(self, *args, **kwargs):
		""" System.TimeSpan Negate() """"
	
	TotalSeconds = 0.0
	
	TicksPerHour = 0x861C46800L
	

class UInt16(DotNetStructure)
	def Parse(self, *args, **kwargs):
		pass
	
	MaxValue = 65535
	
	MinValue = 0
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		pass
	

class UInt32(DotNetStructure)
	def Parse(self, *args, **kwargs):
		pass
	
	MaxValue = 0xFFFFFFFFL
	
	MinValue = 0x00000L
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		pass
	

class UInt64(DotNetStructure)
	def Parse(self, *args, **kwargs):
		pass
	
	MaxValue = 0xFFFFFFFFFFFFFFFFL
	
	MinValue = 0x00000L
	
	def GetTypeCode(self, *args, **kwargs):
		""" System.TypeCode GetTypeCode() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def CompareTo(self, *args, **kwargs):
		pass
	
	def TryParse(self, *args, **kwargs):
		pass
	

class UIntPtr(DotNetStructure)
	def ToUInt32(self, *args, **kwargs):
		""" UInt32 ToUInt32() """"
	
	def op_Addition(self, *args, **kwargs):
		""" UIntPtr op_Addition(UIntPtr, Int32) """"
	
	def op_Explicit(self, *args, **kwargs):
		pass
	
	def op_Subtraction(self, *args, **kwargs):
		""" UIntPtr op_Subtraction(UIntPtr, Int32) """"
	
	def op_Inequality(self, *args, **kwargs):
		""" Boolean op_Inequality(UIntPtr, UIntPtr) """"
	
	def ToPointer(self, *args, **kwargs):
		""" Void* ToPointer() """"
	
	def MemberwiseClone(self, *args, **kwargs):
		""" System.Object MemberwiseClone() """"
	
	def ToUInt64(self, *args, **kwargs):
		""" UInt64 ToUInt64() """"
	
	@property
	def Size(self):
		""" Int32 get_Size() """"
	
	def Add(self, *args, **kwargs):
		""" UIntPtr Add(UIntPtr, Int32) """"
	
	def Zero(self, *args, **kwargs):
		pass
	
	def op_Equality(self, *args, **kwargs):
		""" Boolean op_Equality(UIntPtr, UIntPtr) """"
	
	def Subtract(self, *args, **kwargs):
		""" UIntPtr Subtract(UIntPtr, Int32) """"
	
	Size = 4