UniSharping (version 2.1): supported C# classes and its members

C# class or memberJava analogPython analogPHP analogJavaScript analogRust analog
delegate Action<T>Action (our service class)    
   void call(T)   {!}.call({0})    
class AppDomainignored in Javaignored in Python ignored in JS 
   AppDomain static CurrentDomain   Ignored in Java   Ignored in Python    Ignored in JS 
   string BaseDirectory { get; }   get: (new java.io.File("")).getAbsolutePath()   get: os.path.dirname(os.path.realpath(__file__))    get: __dirname 
class ApplicationException : Exceptionjava.lang.ExceptionExceptionRuntimeExceptionError 
class ArgumentException : Exceptionjava.lang.IllegalArgumentExceptionExceptionInvalidArgumentExceptionError 
class ArgumentNullException : Exceptionjava.lang.IllegalArgumentExceptionExceptionInvalidArgumentExceptionError 
class ArgumentOutOfRangeException : Exceptionjava.lang.IndexOutOfBoundsExceptionExceptionInvalidArgumentExceptionError 
static class Array     
   void Clear(?)   Generate code by inner hardcode procedure    
   void Copy(?)   model by operator 'for' in code    
   void Copy(?)   model by operator 'for' in code    
   int IndexOf(byte[], byte, *)   Utils.indexOfBytes({0}, {1}, {2=0})    
   int IndexOf(char[], char, *)   Utils.indexOfChars({0}, {1}, {2=0})    
   int IndexOf(int[], int, *)   Utils.indexOfInts({0}, {1}, {2=0})    
   void Resize(ref ?)   Arrays.copyOf    
class ArrayList : List [object]java.util.ArrayList MyListArray 
class Assemblyignored in Javaignored in Pythonignored in PHPignored in JSignored in Rust
   object GetManifestResourceInfo(string)   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure
   string[] GetManifestResourceNames()   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure
   Stream GetManifestResourceStream(string)   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure   Generate code by inner hardcode procedure
   Type[] GetTypes()   Generate code by inner hardcode procedure    
   static Assembly GetCallingAssembly()   Ignored in Java   Ignored in Python   Ignored in PHP   Ignored in JS   Ignored in Rust
   static Assembly GetEntryAssembly()   Ignored in Java   Ignored in Python   Ignored in PHP   Ignored in JS   Ignored in Rust
   static Assembly GetExecutingAssembly()   Ignored in Java   Ignored in Python   Ignored in PHP   Ignored in JS   Ignored in Rust
static class Assertorg.junit.Assert (import unittest)TestCase (our service class)assert 
   void AreEqual(object, object, string)   org.junit.Assert.assertEquals({2}, {0}, {1})   self.assertEquals({0}, {1}, {2})   $this->assertEquals({0}, {1}, {2})   assert.equal({0}, {1}, {2}) 
   void AreEqual(object, object)   org.junit.Assert.assertEquals({0}, {1})   self.assertEquals({0}, {1})   $this->assertEquals({0}, {1})   assert.equal({0}, {1})   assert_eq!({0}, {1})
   void AreNotEqual(object, object)   org.junit.Assert.assertNotEquals({0}, {1})   self.assertNotEquals({0}, {1})    assert.notEqual({0}, {1})   assert_ne!({0}, {1})
   void AreNotEqual(object, object, string)   org.junit.Assert.assertNotEquals({2}, {0}, {1})   self.assertNotEquals({0}, {1}, {2})    assert.notEqual({0}, {1}, {2}) 
   void AreNotSame(object, object)   org.junit.Assert.assertNotSame({0}, {1})   self.assertNotIs({0}, {1})   
   void AreNotSame(object, object, string)   org.junit.Assert.assertNotSame({2}, {0}, {1})   self.assertNotIs({0}, {1}, {2})   
   void AreSame(object, object, string)   org.junit.Assert.assertSame({2}, {0}, {1})   self.assertIs({0}, {1}, {2})   $this->assertSame({0}, {1}, {2})  
   void AreSame(object, object)   org.junit.Assert.assertSame({0}, {1})   self.assertIs({0}, {1})   $this->assertSame({0}, {1})  
   void Fail(string)   org.junit.Assert.fail({0})   self.assertTrue(False, {0})   $this->assertFail({0})   assert.fail({0}) 
   void Fail()   org.junit.Assert.fail()   self.assertTrue(False)   $this->assertFail()   assert.fail() 
   void IsFalse(bool)   org.junit.Assert.assertFalse({0})   self.assertFalse({0})   $this->assertFalse({0})   assert.isFalse({0})   !assert!({0})
   void IsFalse(bool, string)   org.junit.Assert.assertFalse({1}, {0})   self.assertFalse({0}, {1})   $this->assertFalse({0}, {1})   assert.isFalse({0}, {1}) 
   void IsNotNull(object)   org.junit.Assert.assertNotNull({0})   self.assertIsNotNone({0})   $this->assertTrue(({0}) != NULL)   assert.isNotNull({0}) 
   void IsNotNull(object, string)   org.junit.Assert.assertNotNull({1}, {0})   self.assertIsNotNone({0})   $this->assertTrue(({0}) != NULL, {1})   assert.isNotNull({0}, {1}) 
   void IsNull(object)   org.junit.Assert.assertNull({0})   self.assertIsNone({0})   $this->assertNull({0})   assert.isNull({0}) 
   void IsNull(object, string)   org.junit.Assert.assertNull({1}, {0})   self.assertIsNone({0}, {1})   $this->assertNull({0}, {1})   assert.isNull({0}, {1}) 
   void IsTrue(bool, string)   org.junit.Assert.assertTrue({1}, {0})   self.assertTrue({0}, {1})   $this->assertTrue({0}, {1})   assert.isTrue({0}, {1}) 
   void IsTrue(bool)   org.junit.Assert.assertTrue({0})   self.assertTrue({0})   $this->assertTrue({0})   assert.isTrue({0})   assert!({0})
class Attributewarning: Inherited class ignored in Javawarning: Inherited class ignored in Pythonwarning: Inherited class ignored in PHPwarning: Inherited class ignored in JS 
static class BitConverter     
   byte[] GetBytes(long)   java.nio.ByteBuffer.allocate(8).order(java.nio.ByteOrder.LITTLE_ENDIAN).putLong({0}).array()   ({0}).to_bytes(8, byteorder="little")   Utils.ObjectToBytes({0}, 'long')   Utils.objectToBytes({0}, 'long') 
   byte[] GetBytes(uint)   java.nio.ByteBuffer.allocate(4).order(java.nio.ByteOrder.LITTLE_ENDIAN).putInt({0}).array()   ({0}).to_bytes(4, byteorder="little")   Utils.ObjectToBytes({0}, 'uint')   Utils.objectToBytes({0}, 'uint') 
   byte[] GetBytes(ulong)   java.nio.ByteBuffer.allocate(8).order(java.nio.ByteOrder.LITTLE_ENDIAN).putLong({0}).array()   ({0}).to_bytes(8, byteorder="little")   Utils.ObjectToBytes({0}, 'ulong')   Utils.objectToBytes({0}, 'ulong') 
   byte[] GetBytes(double)   java.nio.ByteBuffer.allocate(8).order(java.nio.ByteOrder.LITTLE_ENDIAN).putDouble({0}).array()   bytearray(struct.pack("d", {0})) (import struct)   Utils.ObjectToBytes({0}, 'double')   Utils.objectToBytes({0}, 'double') 
   byte[] GetBytes(float)   java.nio.ByteBuffer.allocate(4).order(java.nio.ByteOrder.LITTLE_ENDIAN).putFloat({0}).array()   bytearray(struct.pack("f", {0})) (import struct)   Utils.ObjectToBytes({0}, 'float')   Utils.objectToBytes({0}, 'float') 
   byte[] GetBytes(int)   java.nio.ByteBuffer.allocate(4).order(java.nio.ByteOrder.LITTLE_ENDIAN).putInt({0}).array()   ({0}).to_bytes(4, byteorder="little")   Utils.ObjectToBytes({0}, 'int')   Utils.objectToBytes({0}, 'int') 
   byte[] GetBytes(byte)   java.nio.ByteBuffer.allocate(1).put({0}).array()   ({0}).to_bytes(1, byteorder="little")   Utils.ObjectToBytes({0}, 'byte')   Utils.objectToBytes({0}, 'byte') 
   byte[] GetBytes(bool)   java.nio.ByteBuffer.allocate(1).put((byte)({0} ? 1 : 0)).array()   int({0}).to_bytes(1, byteorder="little")   Utils.ObjectToBytes({0}, 'bool')   Utils.objectToBytes({0}, 'bool') 
   byte[] GetBytes(char)   java.nio.ByteBuffer.allocate(2).order(java.nio.ByteOrder.LITTLE_ENDIAN).putChar({0}).array()   ord({0}).to_bytes(2, byteorder="little")   Utils.ObjectToBytes({0}, 'char')   Utils.objectToBytes({0}, 'char') 
   byte[] GetBytes(ushort)   java.nio.ByteBuffer.allocate(2).order(java.nio.ByteOrder.LITTLE_ENDIAN).putShort({0}).array()   ({0}).to_bytes(2, byteorder="little")   Utils.ObjectToBytes({0}, 'ushort')   Utils.objectToBytes({0}, 'ushort') 
   byte[] GetBytes(short)   java.nio.ByteBuffer.allocate(2).order(java.nio.ByteOrder.LITTLE_ENDIAN).putShort({0}).array()   ({0}).to_bytes(2, byteorder="little")   Utils.ObjectToBytes({0}, 'short')   Utils.objectToBytes({0}, 'short') 
   bool ToBoolean(byte[], int)   ({0})[{1}] == (byte)1   ({0})[{1}] == 1   ({0})[{1}] == 1   ({0})[{1}] == 1 
   bool ToByte(byte[], int)   ({0})[{1}]   int.from_bytes({0}[{1}:{1}+1], byteorder="little")   ({0})[{1}]   ({0})[{1}] 
   char ToChar(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getChar()   chr(int.from_bytes({0}[{1}:{1}+2], byteorder="little"))   Utils.BytesToObject({0}, {1}, 'char', 2)   Utils.bytesToObject({0}, {1}, 'char', 2) 
   float ToDouble(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 8).order(java.nio.ByteOrder.LITTLE_ENDIAN).getDouble()   struct.unpack('d', {0}[{1}:{1}+8])[0] (import struct)   Utils.BytesToObject({0}, {1}, 'double', 8)   Utils.bytesToObject({0}, {1}, 'double', 8) 
   short ToInt16(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getShort()   int.from_bytes({0}[{1}:{1}+2], byteorder="little")   Utils.BytesToObject({0}, {1}, 'short', 2)   Utils.bytesToObject({0}, {1}, 'short', 2) 
   int ToInt32(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt()   int.from_bytes({0}[{1}:{1}+2], byteorder="little")   Utils.BytesToObject({0}, {1}, 'int', 4)   Utils.bytesToObject({0}, {1}, 'int', 4) 
   long ToInt64(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 8).order(java.nio.ByteOrder.LITTLE_ENDIAN).getLong()   int.from_bytes({0}[{1}:{1}+8], byteorder="little")   Utils.BytesToObject({0}, {1}, 'long', 8)   Utils.bytesToObject({0}, {1}, 'long', 8) 
   float ToSingle(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getFloat()   struct.unpack('f', {0}[{1}:{1}+4])[0] (import struct)   Utils.BytesToObject({0}, {1}, 'float', 4)   Utils.bytesToObject({0}, {1}, 'float', 4) 
   ushort ToUInt16(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).getShort()   int.from_bytes({0}[{1}:{1}+2], byteorder="little")   Utils.BytesToObject({0}, {1}, 'ushort', 2)   Utils.bytesToObject({0}, {1}, 'ushort', 2) 
   uint ToUInt32(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).getInt()   int.from_bytes({0}[{1}:{1}+2], byteorder="little")   Utils.BytesToObject({0}, {1}, 'uint', 4)   Utils.bytesToObject({0}, {1}, 'uint', 4) 
   ulong ToUInt64(byte[], int)   java.nio.ByteBuffer.wrap({0}, {1}, 8).order(java.nio.ByteOrder.LITTLE_ENDIAN).getLong()   int.from_bytes({0}[{1}:{1}+8], byteorder="little")   Utils.BytesToObject({0}, {1}, 'ulong', 8)   Utils.bytesToObject({0}, {1}, 'ulong', 8) 
class boolboolean / java.lang.BooleanboolboolBooleanbool
static class Buffer     
   void BlockCopy(byte[], int, byte[], int, int)   model by operator 'for' in code    
   int ByteLength(byte[])   {0}.size()    
class bytebyte / java.lang.ByteintintNumberu8
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem   model by 'sprintf', format must be string lexem   model by code, format must be string lexem   model by code, format must be string lexem
   static byte Parse(string)   Utils.parseByte({0})   int({0})   int({0})   Utils.parseInt({0}) 
   static bool TryParse(string, out byte)   Utils.parseByte({0}, {1})   Utils.tryParseInt({0}, {1})   Utils.TryParseInt({0}, {1})   Utils.tryParseInt({0}, {1}) 
class CancelEventArgsCancelEventArgs (our service class)CancelEventArgs (our service class)CancelEventArgs (our service class)CancelEventArgs (our service class) 
   bool Cancel   {!}.cancel   {!}.cancel   {!}->cancel   {!}.cancel 
    .ctor()   .ctor()   .ctor()   .ctor()   .ctor() 
delegate CancelEventHandlerCancelEventHandler (our service class)EventHandler (our service class)EventHandler (our service class)EventHandler (our service class)NString
   void call(object, CancelEventArgs)   {!}.call({0}, {1})   {!}.call({0}, {1})   {!}->call({0}, {1})   {!}.call({0}, {1}) 
class charchar / java.lang.CharacterstrstringStringchar
   static int GetNumericValue(char)   Character.getNumericValue({0})    
   static bool IsDigit(char)   Character.isDigit({0})   str.isdigit({0})   Utils.IsDigit({0})   Utils.isDigit({0})   {0}.is_digit(10)
   static bool IsLetter(char)   Character.isLetter({0})   str.isalpha({0})   Utils.IsLetter({0})   Utils.isLetter({0})   {0}.is_alphabetic()
   static bool IsLetterOrDigit(char)   Character.isLetterOrDigit({0})   str.isalnum({0})   Utils.IsLetterOrDigit({0})   Utils.isLetterOrDigit({0})   ({0}.is_alphabetic() || {0}.is_digit(10))
   static bool IsLower(char)   Character.isLowerCase({0})   str.islower({0})   Utils.IsLowerCase({0})   Utils.isLowerCase({0})   {0}.is_lowercase()
   static bool IsPunctuation(char)   Utils.isPunctuation({0})   Utils.isPunctuation({0})    Utils.isPunctuation({0}) 
   static bool IsUpper(char)   Character.isUpperCase({0})   str.isupper({0})   Utils.IsUpperCase({0})   Utils.isUpperCase({0})   {0}.is_uppercase()
   static bool IsWhiteSpace(char)   Utils.isWhitespace({0})   Utils.isWhitespace({0})   Utils.IsWhitespace({0})   Utils.isWhitespace({0})   {0}.is_whitespace()
   static char ToLower(char)   Character.toLowerCase({0})   str.lower({0})   mb_convert_case({0}, MB_CASE_LOWER)   {0}.toLowerCase()   utils::char_to_lower({0})
   static char ToUpper(char)   Character.toUpperCase({0})   str.upper({0})   mb_convert_case({0}, MB_CASE_UPPER)   {0}.toUpperCase()   utils::char_to_upper({0})
class Collection<T> : IList [T]java.util.ArrayList<T>list<T>MyList (our service class)Array<T>NList (our service class)
    .ctor(IEnumerable<T>)   modeled by ArrayList   modeled by bytearray or list (depends on type)   .ctor({0})   .ctor({0}) 
    .ctor()   .ctor()   modeled by bytearray or list (depends on type)   .ctor()   .ctor()   NList::new()
enum CompressionModebooleanstrstrStringi32
    static Compress   true   'w'   'w'   'w'   0
    static Decompress   false   'r'   'r'   'r'   1
static class ConsoleSystem.out    
   object ReadKey()   System.in.read()   sys.stdin.read(1) (import sys)   
   string ReadLine()   Utils.consoleReadLine()   sys.stdin.readline() (import sys)   
   void Write(string, *)   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators
   void Write(?)   System.out.print({0})   print({0}, end="", flush=True)   print({0})   Model constant format string by operators   Model constant format string by operators
   void Write()   System.out.print()   print("", end="", flush=True)   print("")   process.stdout.write("") 
   void WriteLine()   System.out.println()   print("")   print("\r\n")   process.stdout.write("\r\n")   println!("\r\n")
   void WriteLine(?)   System.out.println({0})   print({0}, flush=True)   print({0}."\r\n")   Model constant format string by operators   Model constant format string by operators
   void WriteLine(string, *)   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators
class ConstructorInfojava.lang.reflect.Constructor    
   object Invoke(object[])   {!}.newInstance({0})    
static class Convert  (import base64)   
   byte[] FromBase64String(string)   java.util.Base64.getDecoder().decode(({0}).replace("\r", "").replace("\n", ""))   base64.decodestring(({0}).encode('utf-8', 'ignore'))   Utils.DecodeBase64({0})   Utils.decodeBase64({0}) 
   string ToBase64String(byte[])   new String(java.util.Base64.getEncoder().encode({0}))   base64.encodestring({0}).decode('utf-8', 'ignore')   Utils.EncodeBase64({0})   Utils.encodeBase64({0}) 
   long ToDouble(?)   Generate code by inner hardcode procedure    
   short ToInt16(?)   Generate code by inner hardcode procedure    
   int ToInt32(?)   Generate code by inner hardcode procedure    
   long ToInt64(?)   Generate code by inner hardcode procedure    
   long ToSingle(?)   Generate code by inner hardcode procedure    
   ushort ToUInt16(?)   Generate code by inner hardcode procedure    
   uint ToUInt32(?)   Generate code by inner hardcode procedure    
   long ToUInt64(?)   Generate code by inner hardcode procedure    
struct DateTimejava.time.LocalDateTimedatetime.datetime (import datetime)DateTimeDate 
   DateTime static MaxValue   java.time.LocalDateTime.MAX   datetime.datetime.max    Utils.MAX_DATE 
   DateTime static MinValue   java.time.LocalDateTime.MIN   datetime.datetime.min    Utils.MIN_DATE 
   DateTime Date { get; }   get: java.time.LocalDateTime.of({!}.toLocalDate(), java.time.LocalTime.of(0, 0))   get: Utils.getDate({!})   get: Utils.GetDate({!})   get: Utils.getDate({!}) 
   int Day { get; }   get: {!}.getDayOfMonth()   get: {!}.day   get: (int){!}->format("d")   get: {!}.getDate() 
   DayOfWeek DayOfWeek { get; }   get: {!}.getDayOfWeek()   get: {!}.weekday()   get: (int){!}->format("w")   get: {!}.getDay() 
   int DayOfYear { get; }   get: {!}.getDayOfYear()   get: {!}.timetuple().tm_yday   get: (int){!}->format("z")  
   int Hour { get; }   get: {!}.getHour()   get: {!}.hour   get: (int){!}->format("H")   get: {!}.getHours() 
   int Millisecond { get; }   get: ({!}.getNano() / 1000000)   get: ({!}.microsecond / 1000)   get: (int){!}->format("v")   get: {!}.getMilliseconds() 
   int Minute { get; }   get: {!}.getMinute()   get: {!}.minute   get: (int){!}->format("i")   get: {!}.getMinutes() 
   int Month { get; }   get: {!}.getMonthValue()   get: {!}.month   get: (int){!}->format("m")   get: Utils.getMonth({!}) 
   int Second { get; }   get: {!}.getSecond()   get: {!}.second   get: (int){!}->format("s")   get: {!}.getSeconds() 
   int Year { get; }   get: {!}.getYear()   get: {!}.year   get: (int){!}->format("Y")   get: {!}.getFullYear() 
   DateTime static Now { get; }   get: java.time.LocalDateTime.now()   get: datetime.datetime.now()   get: Utils.NowDateTime()   get: Utils.now() 
   DateTime static Today { get; }   get: java.time.LocalDateTime.of(java.time.LocalDate.now(), java.time.LocalTime.of(0, 0))   get: Utils.getDate(datetime.datetime.today())   get: Utils.GetDate(Utils::NowDateTime())   get: Utils.getDate(Utils.now()) 
    .ctor(*)   java.time.LocalDateTime.of({0=1}, {1=1}, {2=1}, {3=0}, {4=0}, {5=0})   datetime.datetime({0=1}, {1=1}, {2=1}, {3=0}, {4=0}, {5=0})   Utils.CreateDateTime({0=1}, {1=1}, {2=1}, {3=0}, {4=0}, {5=0})   new Date({0=1}, {1=1} - 1, {2=1}, {3=0}, {4=0}, {5=0}) 
   DateTime AddDays(int)   {!}.plusDays({0})   ({!} + datetime.timedelta(days={0}))    Utils.addDays({!}, {0}) 
   DateTime AddHours(int)   {!}.plusHours({0})   ({!} + datetime.timedelta(hours={0}))    Utils.addHours({!}, {0}) 
   DateTime AddMinutes(int)   {!}.plusMinutes({0})   ({!} + datetime.timedelta(minutes={0}))    Utils.addMinutes({!}, {0}) 
   DateTime AddMonths(int)   {!}.plusMonths({0})   ({!} + datetime.timedelta(days={0}*30))    Utils.addMonths({!}, {0}) 
   DateTime AddSeconds(int)   {!}.plusSeconds({0})   ({!} + datetime.timedelta(seconds={0}))    Utils.addSeconds({!}, {0}) 
   DateTime AddYears(int)   {!}.plusYears({0})   ({!} + datetime.timedelta(days={0}*365))    Utils.addYears({!}, {0}) 
   string ToShortDateString()   {!}.toLocalDate().toString()   Utils.getDateShortString({!})   {!}->format("Y.m.d");  
   string ToShortTimeString()   {!}.toLocalTime().toString()   Utils.getTimeShortString({!})   {!}->format("H.i.s");  
   static int DaysInMonth(int, int)   Utils.daysInMonth({0}, {1})   Utils.lastDayOfMonth({0}, {1})   Utils.DaysInMonth({0}, {1})   Utils.daysInMonth({0}, {1}) 
   static DateTime FromFileTime(long)   Utils.getDateTimeFromFileTime({0})    
   static DateTime FromFileTimeUtc(long)   Utils.getDateTimeFromFileTime({0})    
   static DateTime Parse(string)   java.time.LocalDateTime.parse({0})    
   static bool TryParse(string, ref DateTime)   Utils.parseDateTime({0}, {1})    
enum DayOfWeekjava.time.DayOfWeekintintint 
    static Friday   java.time.DayOfWeek.FRIDAY   4   5   5 
    static Monday   java.time.DayOfWeek.MONDAY   0   1   1 
    static Saturday   java.time.DayOfWeek.SATURDAY   5   6   6 
    static Sunday   java.time.DayOfWeek.SUNDAY   6   0   0 
    static Thursday   java.time.DayOfWeek.THURSDAY   3   4   4 
    static Tuesday   java.time.DayOfWeek.TUESDAY   1   2   2 
    static Wednesday   java.time.DayOfWeek.WEDNESDAY   2   3   3 
class DeflateStream : StreamDeflateStream (our service class)    
    .ctor(Stream, CompressionMode, *)   new DeflateStream({0}, {1}) DeflateStream works not equals in .NET and Java, better use GZipStream!    
class Dictionary<K, V> : IDictionaryjava.util.HashMap<K, V>dict<K, V>Dictionary (our service class)Hashtable (our service class)NDict (our service class)
    .ctor(IDictionary<K, V>)   .ctor({0})   .ctor({0})   .ctor({0})   .ctor({0}) 
    .ctor(int)   new java.util.HashMap()   dict()   new Dictionary()   new Hashtable() 
    .ctor()   .ctor()   .ctor()   .ctor()   .ctor()   NDict::new()
struct DictionaryEntryjava.util.Map.EntrytupleKeyValuePair (our service class)KeyValuePair (our service class) 
   object Key { get; }   get: {!}.getKey()   get: {!}[0]   get: {!}->key   get: {!}.key 
   object Value { get; }   get: {!}.getValue()   get: {!}[1]   get: {!}->value   get: {!}.value 
    .ctor(object, object)   .ctor({0}, {1})   .ctor({0}, {1})   .ctor({0}, {1})   .ctor({0}, {1}) 
static class Directory    
   object CreateDirectory(string)   (new java.io.File({0})).mkdir()   pathlib.Path({0}).mkdir(exist_ok=True) (import pathlib)   mkdir({0})   fs.mkdirSync({0}) 
   void Delete(string, *)   Utils.deleteDirectory(new java.io.File({0}))   shutil.rmtree({0}, ignore_errors=True) (import shutil)   Utils.DeleteDirectory({0})   Utils::deleteDirectory({0}) 
   bool Exists(string)   ((new java.io.File({0})).exists() && (new java.io.File({0})).isDirectory())   pathlib.Path({0}).is_dir() (import pathlib)   file_exists({0}) && is_dir({0})   fs.existsSync({0}) && fs.statSync({0}).isDirectory() 
   string GetCurrentDirectory()   (new java.io.File("")).getAbsolutePath()   os.getcwd() (import os)   
   string[] GetDirectories(string, string)   Utils.getDirectoryItems({0}, {1}, true)   [os.path.abspath(x) for x in os.listdir(os.path.join({0}, {1})) if os.path.isdir(os.path.join({0}, f))] (import os)   
   string[] GetDirectories(string)   Utils.getDirectoryItems({0}, null, true)   [os.path.abspath(x) for x in os.listdir({0}) if os.path.isdir(os.path.join({0}, f))] (import os)   
   string[] GetFiles(string, string)   Utils.getDirectoryItems({0}, {1}, false)   [os.path.abspath(x) for x in os.listdir(os.path.join({0}, {1})) if os.path.isfile(os.path.join({0}, f))] (import os)   
   string[] GetFiles(string)   Utils.getDirectoryItems({0}, null, false)   [os.path.abspath(x) for x in os.listdir({0}) if os.path.isfile(os.path.join({0}, f))] (import os)   
   void SetCurrentDirectory(string)   Utils.setCurrentDirectory({0})   os.chdir({0}) (import os)   
class DirectoryInfojava.io.Filepathlib.Path (import pathlib)   
   DateTime CreationTime { get; }   get: Utils.getFileCreationTime({!})   get: Utils.getDateTimeFromCtime(os.path.getmtime({!}.absolute())) (import os)   
   bool Exists { get; }   get: {!}.exists()   get: {!}.is_dir()   
   string FullName { get; }   get: {!}.getAbsolutePath()   get: {!}.absolute()   
   DateTime LastWriteTime { get; }   get: Utils.getFileModifiedTime({!})   get: Utils.getDateTimeFromCtime(os.path.getctime({!}.absolute())) (import os)   
   string Name { get; }   get: {!}.getPath()   get: {!}.name   
    .ctor(string)   .ctor({0})   .ctor({0})   
   void Create()   {!}.mkdir()   pathlib.Path({!}.absolute()).mkdir(exist_ok=True)   
   void Delete(*)   {!}.delete({0})   shutil.rmtree(pathlib.Path(dname).absolute(), ignore_errors=True) (import shutil)   
class doubledouble / java.lang.DoublefloatfloatNumberf64
   double static MaxValue   Double.MAX_VALUE    
   double static MinValue   -Double.MAX_VALUE    
   double static NaN   Double.NaN   math.nan (import math)   NAN   Number.NaN 
   double static NegativeInfinity   Double.NEGATIVE_INFINITY   -math.inf (import math)    Number.NEGATIVE_INFINITY 
   double static PositiveInfinity   Double.POSITIVE_INFINITY   math.inf (import math)    Number.POSITIVE_INFINITY 
   string ToString(NumberFormatInfo)   {0}.format({!})    
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem   model by 'sprintf', format must be string lexem   model by code, format must be string lexem   model by code, format must be string lexem
   static bool IsInfinity(double)   Double.isInfinite({0})   math.isinf({0}) (import math)   
   static bool IsNaN(double)   Double.isNaN({0})   math.isnan({0}) (import math)   is_nan({0})   isNaN({0}) 
   static bool IsNegativeInfinity(double)   ({0} == Double.NEGATIVE_INFINITY)   ({0} == -float('inf'))   
   static bool IsPositiveInfinity(double)   ({0} == Double.POSITIVE_INFINITY)   ({0} == float('inf'))   
   static double Parse(string)   Utils.parseDouble({0}, null)   float({0})   (float)({0})   Utils.parseFloat({0}) 
   static double Parse(string, ?)   Utils.parseDouble({0}, {2})    
   static bool TryParse(string, out double)   Utils.parseDouble({0}, null, {1})   Utils.tryParseFloat({0}, {1})   Utils.TryParseFloat({0}, {1})   Utils.tryParseFloat({0}, {1}) 
   static bool TryParse(string, ?)   Utils.parseDouble({0}, {2}, {3})    
class Encodingjava.nio.charset.CharsetstrstringStringignored in Rust
   Encoding static ASCII { get; }   get: java.nio.charset.Charset.forName("ASCII")   get: error ASCII not supported in python   get: error ASCII not supported in php   get: error ASCII not supported in js 
   Encoding static BigEndianUnicode { get; }   get: java.nio.charset.Charset.forName("UTF-16BE")   get: error this encoding not supported in python   get: error this encoding not supported in js   get: error this encoding not supported in js 
   Encoding static Unicode { get; }   get: java.nio.charset.Charset.forName("UTF-16LE")   get: error this encoding not supported in python   get: error this encoding not supported in php   get: error this encoding not supported in js 
   Encoding static UTF8 { get; }   get: java.nio.charset.Charset.forName("UTF-8")   get: "UTF-8"   get: "UTF-8"   get: "UTF-8"   get: "UTF-8"
   byte[] GetBytes(string)   Utils.encodeCharset({!}, {0})   modeled by 'encode', support only utf-8   Utils.EncodeString({!}, {0})   Utils.encodeString({!}, {0})   {0}.get_utf8()
   char[] GetChars(byte[], *)   Utils.decodeCharsetArr({!}, {0}, {1=0}, {2=-1})   modeled by 'decode', support only utf-8   
   byte[] GetPreamble()   Utils.preambleCharset({!})   Utils.preambleCharset({!})   Utils.GetEncodingPreamble({!})   Utils.getEncodingPreamble({!}) 
   string GetString(byte[], int, int)   Utils.decodeCharset({!}, {0}, {1}, {2})   modeled by 'decode', support only utf-8   Utils.DecodeString({!}, {0}, {1}, {2})   Utils.decodeString({!}, {0}, {1}, {2})   NString::from_utf8({0&}, {1}, {2})
   string GetString(byte[])   Utils.decodeCharset({!}, {0}, 0, -1)   modeled by 'decode', support only utf-8   Utils.DecodeString({!}, {0}, 0, -1)   Utils.decodeString({!}, {0}, 0, -1)   NString::from_utf8({0&}, 0, -1)
   string GetString(byte[], int)   Utils.decodeCharset({!}, {0}, {1}, -1)   modeled by 'decode', support only utf-8   Utils.DecodeString({!}, {0}, {1}, -1)   Utils.decodeString({!}, {0}, {1}, -1)   NString::from_utf8({0&}, {1}, -1)
   static Encoding GetEncoding(string)   Utils.getCharsetByName({0})    
   static Encoding GetEncoding(int)   Utils.getCharsetByName("windows-" + {0})    
class EndOfStreamException : Exceptionjava.io.EOFExceptionExceptionExceptionError 
static class Enum     
   object[] GetValues(?)   static method 'getValues' in generated wrapper class for enum    static method 'getValues' in generated wrapper class for enum   static method 'getValues' in generated wrapper class for enum 
   bool IsDefined(?)   static method 'isDefined' in generated wrapper class for enum   enum(v)   static method 'isDefined' in generated wrapper class for enum   static method 'isDefined' in generated wrapper class for enum   static method 'isDefined' in generated wrapper class for enum
   object Parse(?)   static method 'of' in generated wrapper class for enum   model by Unit.valToEnum(...)   static method 'of' in generated wrapper class for enum   static method 'of' in generated wrapper class for enum   static method 'of' in generated wrapper class for enum
   object ToObject(?)   static method 'of' in generated wrapper class for enum   enum(v)   static method 'of' in generated wrapper class for enum   static method 'of' in generated wrapper class for enum   static method 'of' in generated wrapper class for enum
class Environmentignored in Java    
   string static MachineName   Utils.getMachineName()    
   string static UserName   System.getProperty("user.name")    
class EventArgsjava.lang.Object    
   EventArgs static Empty   Utils.EMPTYEVENTARGS    
delegate EventHandler<T>EventHandler (our service class)EventHandler (our service class)EventHandler (our service class)EventHandler (our service class)NString<T>
   void call(object, T)   {!}.call({0}, {1})   {!}.call({0}, {1})   {!}->call({0}, {1})   {!}.call({0}, {1}) 
class Exceptionjava.lang.ExceptionExceptionExceptionErrorNString
   string Message { get; }   get: {!}.getMessage()   get: {!}.__str__()   get: {!}->getMessage()   get: {!}.message   get: {!}
    .ctor(string, Exception)   .ctor({0}, {1})   Utils.newException({0}, {1})   new Exception({0}, 0, {1})   new Error({0}) 
    .ctor(string)   .ctor({0})   Utils.newException({0}, None)   .ctor({0})   .ctor({0})   {0}
    .ctor()   .ctor()   .ctor()   .ctor()   .ctor()   NString::null()
static class File  (import pathlib)  
   void Copy(string, string, *)   Utils.copyFile({0}, {1})   shutil.copy({0}, {1}) (import shutil)   
   FileStream Create(string)   modeled by constructor of our service FileStream   modeled by open({0}, mode="...")   modeled by open({0}, mode="...")   modeled by constructor of our service FileStream 
   void Delete(string)   (new java.io.File({0})).delete()   pathlib.Path({0}).unlink()   unlink({0})   fs.unlinkSync({0}) 
   bool Exists(string)   ((new java.io.File({0})).exists() && (new java.io.File({0})).isFile())   pathlib.Path({0}).is_file()   file_exists({0}) && is_file({0})   fs.existsSync({0}) && fs.statSync({0}).isFile() 
   DateTime GetCreationTime(string)   Utils.getFileCreationTime(new java.io.File({0}))   Utils.getDateTimeFromCtime(os.path.getctime({0})) (import os)   
   DateTime GetCreationTimeUtc(string)   Utils.getFileCreationTime(new java.io.File({0}))    
   DateTime GetLastWriteTime(string)   Utils.getFileModifiedTime(new java.io.File({0}))   Utils.getDateTimeFromCtime(os.path.getmtime({0})) (import os)   
   DateTime GetLastWriteTimeUtc(string)   Utils.getFileModifiedTime(new java.io.File({0}))    
   void Move(string, string)   Utils.moveFile({0}, {1})   shutil.move({0}, {1}) (import shutil)    fs.renameSync({0}, {1}) 
   FileStream Open(string, *)   modeled by constructor of our service FileStream   modeled by open({0}, mode="...")   modeled by open({0}, mode="...")   modeled by constructor of our service FileStream 
   byte[] ReadAllBytes(string)   Utils.readAllBytes({0})   pathlib.Path({0}).read_bytes()   Utils.ReadAllBytes({0})   Utils.readAllBytes({0}) 
   string ReadAllText(string, *)   Utils.readAllText({0}, null)   Utils.fileReadAllText({0})   
   void WriteAllBytes(string, byte[])   Utils.writeAllBytes({0}, {1})   pathlib.Path({0}).write_bytes({1})   Utils.WriteAllBytes({0}, {1})   Utils.writeAllBytes({0}, {1}) 
   void WriteAllText(string, string, *)   Utils.writeAllText({0}, {1}, null)   Utils.fileWriteAllText({0}, {1})   
enum FileAccessjava.lang.Stringstrstringstringstr
    static Read   "r"   'r'   'r'   "r"   "r"
    static ReadWrite   "rw"   'rw'   'rw'   "rw"   "rw"
    static Write   "w"   'w'   'w'   "w"   "w"
class FileInfojava.io.Filepathlib.Path (import pathlib)FileInfo (our service class)FileInfo (our service class) 
   DateTime CreationTime { get; }   get: Utils.getFileCreationTime({!})   get: Utils.getDateTimeFromCtime(os.path.getmtime({!}.absolute())) (import os)   
   string DirectoryName { get; }   get: {!}.getAbsoluteFile().getParent()   get: {!}.parent.absolute()   get: {!}->dirname   get: {!}.dirname 
   bool Exists { get; }   get: {!}.exists()   get: {!}.is_file()   get: {!}->IsExists()   get: {!}.exists() 
   string FullName { get; }   get: {!}.getAbsolutePath()   get: {!}.absolute()   get: {!}->fullname   get: {!}.fullname 
   DateTime LastWriteTime { get; }   get: Utils.getFileModifiedTime({!})   get: Utils.getDateTimeFromCtime(os.path.getctime({!}.absolute())) (import os)   
   long Length { get; }   get: {!}.length()   get: {!}.stat().st_size   get: {!}->length   get: {!}.length 
   string Name { get; }   get: {!}.getPath()   get: {!}.name   get: {!}->name   get: {!}.name 
    .ctor(string)   .ctor({0})   .ctor({0})   .ctor({0})   .ctor({0}) 
   void Delete()   {!}.delete()   {!}.unlink()   {!}->Delete()   {!}.delete() 
enum FileModejava.lang.Stringstrstringstringstr
    static Append   "APPEND"   'append'   'append'   "APPEND"   "APPEND"
    static Create   "CREATE"   'create'   'create'   "CREATE"   "CREATE"
    static CreateNew   "CREATENEW"   'createnew'   'createnew'   "CREATENEW"   "CREATENEW"
    static Open   "OPEN"   'open'   'open'   "OPEN"   "OPEN"
    static OpenOrCreate   "OPENORCREATE"   'openorcreate'   'openorcreate'   "OPENORCREATE"   "OPENORCREATE"
    static Truncate   "TRUNCATE"   'truncate'   'truncate'   "TRUNCATE"   "TRUNCATE"
class FileNotFoundException : Exceptionjava.io.FileNotFoundExceptionFileNotFoundErrorExceptionError 
enum FileSharejava.lang.StringstrstringString 
    static Delete   "DELETE"   'delete'   'delete'   "DELETE" 
    static Inheritable   "INHERIT"   'inherit'   'inherit'   "INHERIT" 
    static None   ""   ''   ''   "" 
    static Read   "READ"   'read'   'read'   "READ" 
    static ReadWrite   "READWRITE"   'readwrite'   'readwrite'   "READWRITE" 
    static Write   "WRITE"   'write'   'write'   "WRITE" 
class FileStream : StreamFileStream (our service class)io.FileIO (import io)resourceFileStream (our service class)FileStream (our service class)
   string Name { get; }   get: {!}.getName()   get: {!}.name    get: {!}.name   get: {!}.get_name()
    .ctor(string, *)   modeled by constructor of our service FileStream   modeled by open({0}, mode="...")   modeled by open({0}, mode="...")   modeled by constructor of our service FileStream   modeled by constructor of our service FileStream
class floatfloat / java.lang.FloatfloatfloatNumberf32
   string ToString(NumberFormatInfo)   {0}.format({!})    
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem   model by 'sprintf', format must be string lexem   model by code, format must be string lexem   model by code, format must be string lexem
   static bool IsInfinity(float)   Float.isInfinite({0})   math.isinf({0}) (import math)   
   static bool IsNaN(float)   Float.isNaN({0})   math.isnan({0}) (import math)   
   static float Parse(string)   Utils.parseFloat({0}, null)   float({0})   (float)({0})   Utils.parseFloat({0}) 
   static float Parse(string, ?)   Utils.parseFloat({0}, {2})    
   static bool TryParse(string, out float)   Utils.parseFloat({0}, null, {1})   Utils.tryParseFloat({0}, {1})   Utils.TryParseFloat({0}, {1})   Utils.tryParseFloat({0}, {1}) 
   static bool TryParse(string, ?)   Utils.parseFloat({0}, {2}, {3})    
class FormatException : Exceptionjava.lang.NumberFormatExceptionExceptionExceptionError 
delegate Func<T, R>Func (our service class)    
   R call(T)   {!}.call({0})    
class GCjava.lang.System (import gc)   
   static void Collect()   System.gc()   gc.collect()   Ignored in PHP   Ignored in JS 
   static long GetTotalMemory(bool)   Utils.getTotalMemory({0})    
   static void SuppressFinalize(*)   Ignored in Java   Ignored in Python   Ignored in PHP   Ignored in JS 
class GroupRegexGroupWrapper (our service class)    
   int Index   {!}.index    
   int Length   {!}.length    
   string Value   {!}.value    
struct Guidjava.util.UUIDuuid.UUID (import uuid)   
   Guid static Empty { get; }   get: Utils.EMPTYUUID   get: Utils.EMPTYUUID   
    .ctor(string)   java.util.UUID.fromString({0})   .ctor({0})   
    .ctor(byte[])   Utils.getUUIDFromBytes({0})   uuid.UUID(bytes={0})   
    .ctor()   new java.util.UUID(0, 0)   {!}.uuid.UUID('{00000000-0000-0000-0000-000000000000}')()   
   bool Equals(object)   {!}.equals({0})   ({!} == {0})    {!}.equals({0}) 
   byte[] ToByteArray()   Utils.getBytesFromUUID({!})   {!}.bytes   
   static Guid NewGuid()   java.util.UUID.randomUUID()   uuid.uuid4()   
class GZipStream : StreamGZipStream (our service class)gzip.GzipFile (import gzip)resourceStream (our service class)GzStream (our service class)
    .ctor(Stream, CompressionMode, *)   new GZipStream({0}, {1})   gzip.GzipFile(fileobj={0}, mode={1})   Utils.GzipWrapper({0}, {1})   Utils.gzipWrapper({0}, {1})   GzStream::new({0}, {1})
class Hashtable : ICollection [DictionaryEntry]java.util.HashMapdictDictionary (our service class)Hashtable (our service class) 
   int Count { get; }   get: {!}.size()   get: len({!})   get: {!}->Count()   get: {!}.length   get: {!}.len()
   ICollection<T> Keys { get; }   get: {!}.keySet()   get: {!}.keys()   get: {!}->GetKeys()   get: {!}.keys 
   ICollection<T> Values { get; }   get: {!}.values()   get: {!}.values()   get: {!}->GetValues()   get: {!}.values 
   object this[object] { get; set; }   get: {!}.get({0})
   set: {!}.put({0}, {1})
   get: Utils.getHashtabVal({!}, {0})
   set: Utils.setHashtabVal({!}, {0}, {1})
   get: {!}->Get({0})
   set: {!}->Put({0}, {1})
   get: {!}.get({0})
   set: {!}.put({0}, {1})
 
    .ctor(Hashtable)   .ctor({0})   .ctor({0})   .ctor({0})   .ctor({0}) 
    .ctor(int)   new java.util.HashMap()   dict()   new Dictionary()   new Hashtable() 
    .ctor()   .ctor()   .ctor()   .ctor()   .ctor() 
   void Add(object, object)   {!}.put({0}, {1})   {!}[{0}] = {1}   {!}->Put({0}, {1})   {!}.put({0}, {1}) 
   void Clear()   {!}.clear()   {!}.clear()   {!}->Clear()   {!}.clear()   {!}.clear()
   bool Contains(object)   {!}.containsKey({0})   {0} in {!}   {!}->ContainsKey({0})   {!}.containsKey({0})   {!}.contains({0&})
   bool ContainsKey(object)   {!}.containsKey({0})   {0} in {!}   {!}->ContainsKey({0})   {!}.containsKey({0}) 
   bool ContainsValue(object)   {!}.containsValue({0})   {0} in {!}.values()   {!}->ContainsValue({0})   {!}.containsValue({0}) 
   IEnumerator<T> GetEnumerator()   {!}.entrySet()   iter({!})   {!}->GetEntries()->items   {!}.entries   {!}.vec.iter()
   void Remove(object)   {!}.remove({0})   if({0} in {!}): del {!}[{0}]   {!}->Remove({0})   {!}.remove({0})   {!}.remove({0&})
class HashTable<K, V> : Dictionaryjava.util.HashMap<K, V>dict<K, V>Dictionary (our service class)Hashtable (our service class) 
class HttpUtility     
   static string UrlDecode(string, Encoding)   java.net.URLDecoder.decode({0}, ({1}).name())    
   static string UrlEncode(string, Encoding)   java.net.URLEncoder.encode({0}, ({1}).name())    
interface ICloneablejava.lang.Cloneable    
   object Close()   {!}.clone()    
interface ICollection<T> : IEnumerable [T]java.util.Collection<T>list<T>MyList (our service class)Array<T>NList (our service class)
   int Count { get; }   get: {!}.size()   get: len({!})   get: {!}->count   get: {!}.length   get: {!}.len()
   void Add(T)   {!}.add({0})   {!}.append({0})   {!}->Add({0})   {!}.push({0})   {!}.add({0*})
   void Clear()   {!}.clear()   {!}.clear()   {!}->Clear()   {!}.splice(0, {!}.length)   {!}.clear()
   bool Contains(T)   {!}.contains({0})   {0} in {!}   {!}->Contains({0})   {!}.includes({0})   {!}.contains({0&})
   IEnumerator<T> GetEnumerator()   {!}.iterator()   {!}.__iter__()   {!}->items   {!}[Symbol.iterator]()   {!}.vec.iter()
   void Remove(T)   {!}.remove({0})   {!}.remove({0})   {!}->Remove({0})   Utils.removeItem({!}, {0})   {!}.remove({0&})
interface IComparable<T>java.lang.Comparable<T>    
   int CompareTo(T)   {!}.compareTo({0})   {!}.compareTo({0})   {!}->compareTo({0})   {!}.compareTo({0}) 
interface IComparer<T>java.util.Comparator<T>    
   int Compare(T, T)   {!}.compare({0}, {1})   {!}.compare({0}, {1})   {!}->Compare({0}, {1})   {!}.compare({0}, {1}) 
interface IDictionary<K, V> : ICollection [KeyValuePair]java.util.Map<K, V>dict<K, V>Dictionary (our service class)Hashtable (our service class)NDict (our service class)
   int Count { get; }   get: {!}.size()   get: len({!})   get: {!}->Count()   get: {!}.length   get: {!}.len()
   ICollection<T> Keys { get; }   get: {!}.keySet()   get: {!}.keys()   get: {!}->GetKeys()   get: {!}.keys   get: {!}.map.keys()
   ICollection<T> Values { get; }   get: {!}.values()   get: {!}.values()   get: {!}->GetValues()   get: {!}.values   get: {!}.map.values()
   V this[K] { get; set; }   get: {!}.get({0})
   set: {!}.put({0}, {1})
   get: {!}[{0}]
   set: {!}[{0}] = {1}
   get: {!}->Get({0})
   set: {!}->Put({0}, {1})
   get: {!}.get({0})
   set: {!}.put({0}, {1})
   get: {!}.get({0&})
   set: {!}.set({0&}, {1*})
   void Add(K, V)   {!}.put({0}, {1})   {!}[{0}] = {1}   {!}->Put({0}, {1})   {!}.put({0}, {1})   {!}.add({0*}, {1*})
   void Clear()   {!}.clear()   {!}.clear()   {!}->Clear()   {!}.clear()   {!}.clear()
   bool ContainsKey(K)   {!}.containsKey({0})   {0} in {!}   {!}->ContainsKey({0})   {!}.containsKey({0})   {!}.contains({0&})
   bool ContainsValue(V)   {!}.containsValue({0})   {0} in {!}.values()   {!}->ContainsValue({0})   {!}.containsValue({0})   {!}.contains_value({0&})
   IEnumerator<T> GetEnumerator()   {!}.entrySet()   iter({!})   {!}->GetEntries()->items   {!}.entries   {!}.map.iter()
   void Remove(K)   {!}.remove({0})   del {!}[{0}]   {!}->Remove({0})   {!}.remove({0})   {!}.remove({0&})
   bool TryGetValue(K, out V)   Utils.tryGetValue({!}, {0}, {1})   Utils.tryGetValue({!}, {0}, {1})   {!}->TryGetValue({0}, {1})   {!}.tryGetValue({0}, {1})   {!}.try_get_value({0}, NULL)
interface IDisposablejava.lang.AutoCloseable    
   void Dispose()   {!}.close()   {!}.close()   {!}->close()   {!}.close() 
interface IEnumerable<T> [T]java.lang.Iterable<T>    
   bool All(Predicate<T>)   Utils.allIterable({!}, {0})    
   bool All()   Utils.allIterable({!}, null)    
   bool Any(Predicate<T>)   Utils.anyIterable({!}, {0})    
   bool Any()   Utils.anyIterable({!}, null)    
   IEnumerable<T> Concat(IEnumerable<T>)   Utils.concatIterable({!}, {0})    
   int Count(Predicate<T>)   Utils.countIterable({!}, {0})    
   int Count()   Utils.countIterable({!}, null)    
   T ElementAt(int)   Utils.elementAtIterable({!}, {0}, null)    
   T ElementAtOrDefault(int)   Utils.elementAtOrDefaultIterable({!}, {0}, default(T) )    
   T First()   Utils.firstIterable({!}, null)    
   T FirstOrDefault(Predicate<T>)   Utils.firstOrDefaultIterable({!}, default(T) , {0})    
   T FirstOrDefault()   Utils.firstOrDefaultIterable({!}, default(T) , null)    
   IEnumerator<T> GetEnumerator()   {!}.iterator()   {!}.__iter__()    {!}[Symbol.iterator]() 
   T Last()   Utils.lastIterable({!}, null)    
   T LastOrDefault(Predicate<T>)   Utils.lastOrDefaultIterable({!}, default(T) , {0})    
   T LastOrDefault()   Utils.lastOrDefaultIterable({!}, default(T) , null)    
   IEnumerable<T> Reverse()   Utils.reverseIterable({!}, null)    
   IEnumerable<T> Select<R>(Func<T, R>)   Utils.selectIterable({!}, {0})    
   List<T> ToList()   Utils.toArrayList({!})    
   IEnumerable<T> Where(Predicate<T>)   Utils.whereIterable({!}, {0})    
interface IEnumerator<T>java.util.Iterator<T> Iterator<T>Enumerator<T> 
   T Current { get; }   get: {!}.next()   get: next({!})   get: {!}->current()   get: {!}.item 
   bool MoveNext()   {!}.hasNext()   {!}.move_next()   {!}->next()   {!}.moveNext() 
   void Reset()     {!}->rewind()   {!}.moveFirst() 
interface IList<T> : ICollection [T]java.util.List<T>list<T>MyList (our service class)Array<T>NList (our service class)
   T this[int] { get; set; }   get: {!}.get({0})
   set: Utils.putArrayValue({!}, {0}, {1})
   get: {!}[{0}]
   set: {!}[{0}] = {1}
   get: {!}->items[{0}]
   set: {!}->items[{0}] = {1}
   get: {!}[{0}]
   set: {!}[{0}] = {1}
   get: {!}.get({0})
   set: {!}.set({0}, {1*})
   int IndexOf(T)   {!}.indexOf({0})   Utils.indexOfList({!}, {0}, 0)   {!}->IndexOf({0})   {!}.indexOf({0})   {!}.index_of({0&}, 0, false)
   int IndexOf(T, int)   Utils.indexOf({!}, {0}, {1})   Utils.indexOfList({!}, {0}, {1})   {!}->IndexOf({0}, {1})   {!}.indexOf({0}, {1})   {!}.index_of({0&}, {1}, false)
   void Insert(int, T)   {!}.add({0}, {1})   {!}.insert({0}, {1})   {!}->Insert({0}, {1})   {!}.splice({0}, 0, {1})   {!}.insert({0}, {1*})
   int LastIndexOf(T, int)   Utils.lastIndexOf({!}, {0}, {1})   Utils.lastIndexOfList({!}, {0}, {1})   {!}->LastIndexOf({0}, {1})   {!}.lastIndexOf({0}, {1})   {!}.index_of({0&}, {1}, true)
   int LastIndexOf(T)   {!}.lastIndexOf({0})   Utils.lastIndexOfList({!}, {0}, 0)   {!}->LastIndexOf({0})   {!}.lastIndexOf({0})   {!}.index_of({0&}, 0, true)
   void RemoveAt(int)   {!}.remove({0})   del {!}[{0}]   {!}->RemoveAt({0})   {!}.splice({0}, 1)   {!}.remove_at({0})
   void Swap(int, int)       {!}.swap({0}, {1})
class IndexOutOfRangeException : Exceptionjava.lang.IndexOutOfBoundsExceptionExceptionOutOfRangeExceptionError 
class intint / java.lang.IntegerintintNumberi32
   int static MaxValue   Integer.MAX_VALUE    
   int static MinValue   Integer.MIN_VALUE    
   string ToString(NumberFormatInfo)   {0}.format({!})    
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem   model by 'sprintf', format must be string lexem   model by code, format must be string lexem   model by code, format must be string lexem
   static int Parse(string, NumberStyles, *)   Utils.parseInteger({0}, {1}, {2=null})    
   static int Parse(string)   Utils.parseInteger({0}, 0, null)   int({0})   int({0})   Utils.parseInt({0}) 
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out int)   Utils.parseInteger({0}, {1}, {2}, {3})    
   static bool TryParse(string, out int)   Utils.parseInteger({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})   Utils.TryParseInt({0}, {1})   Utils.tryParseInt({0}, {1}) 
class InvalidOperationException : Exceptionjava.lang.UnsupportedOperationExceptionExceptionExceptionError 
class IOException : Exceptionjava.io.IOExceptionExceptionExceptionError 
interface KeyValuePair<K, V>java.util.Map.Entry<K, V>tuple<K, V>KeyValuePair (our service class)KeyValuePair (our service class)NKeyPairValue (our service class)
   K Key { get; }   get: {!}.getKey()   get: {!}[0]   get: {!}->key   get: {!}.key   get: {!}.key
   V Value { get; }   get: {!}.getValue()   get: {!}[1]   get: {!}->value   get: {!}.value   get: {!}.value
    .ctor(K, V)   .ctor({0}, {1})   .ctor({0}, {1})   .ctor({0}, {1})   .ctor({0}, {1}) 
class List<T> : IList [T]java.util.ArrayList<T>list<T>MyList (our service class)Array<T>NList (our service class)
   int Capacity { get; set; }   get: Utils.getCapacity({!})
   set: {!}.ensureCapacity({0})
    
    .ctor(int)   .ctor({0})   modeled by bytearray or list (depends on type)   new MyList()   new Array()   NList::with_capacity({0})
    .ctor(IEnumerable<T>)   modeled by ArrayList   modeled by bytearray or list (depends on type)   MyList::CreateFrom({0})   Array.from({0}) 
    .ctor()   .ctor()   modeled by bytearray or list (depends on type)   .ctor()   .ctor()   NList::new()
   void AddRange(IEnumerable<T>)   Utils.addToArrayList({!}, {0})   {!}.extend({0})   {!}->AddRange({0})   {!}.splice({!}.length, 0, ...{0})   {!}.add_range({0*})
   bool Exists(Predicate<T>)   Utils.existsList({!}, {0})    
   T Find(Predicate<T>)   Utils.findList({!}, {0})    
   List<T> FindAll(Predicate<T>)   Utils.findAllList({!}, {0})    
   int FindIndex(int, int, Predicate<T>)   Utils.findIndexList({!}, {2}, {0}, {1})    
   int FindIndex(Predicate<T>)   Utils.findIndexList({!}, {0}, 0, 0)    
   int FindIndex(int, Predicate<T>)   Utils.findIndexList({!}, {1}, {0}, 0)    
   T FindLast(Predicate<T>)   Utils.findLastList({!}, {0})    
   int FindLastIndex(Predicate<T>)   Utils.findLastIndexList({!}, {0}, 0, 0)    
   int FindLastIndex(int, Predicate<T>)   Utils.findLastIndexList({!}, {1}, {0}, 0)    
   int FindLastIndex(int, int, Predicate<T>)   Utils.findLastIndexList({!}, {2}, {0}, {1})    
   void ForEach(Action<T>)   Utils.forEachList({!}, {0})    
   void InsertRange(int, IEnumerable<T>)   Utils.insertToArrayList({!}, {1}, {0})   {!}[{0}:{0}] = {1}   {!}->InsertRange({0}, {1})   {!}.splice({0}, 0, ...{1})   {!}.insert_range({0}, {1*})
   void RemoveRange(int, int)   for(int jjj = {0} + {1} - 1, mmm = {0}; jjj >= mmm; jjj--) {!}.remove(jjj)   del {!}[{0}:{0}+{1}]   {!}->RemoveRange({0}, {1})   {!}.splice({0}, {1})   {!}.remove_range({0}, {1})
   void Reverse()   java.util.Collections.reverse({!})   {!}.reverse()   {!}->Reverse()   {!}.reverse() 
   void Sort()   java.util.Collections.sort({!})   modeled by sort()   modeled by Sort() or usort()   modeled by sort() 
   void Sort(IComparer<T>)   {!}.sort({0})   modeled by sort()   modeled by Sort() or usort()   modeled by sort() 
   T[] ToArray()   modeled by toArray   modeled by toArray   {!}->ToArray()   {!} 
   bool TrueForAll(Predicate<T>)   Utils.trueForAllList({!}, {0})    
class longlong / java.lang.Longintfloatwarning: JavaScript not support long, use inti64
   long static MaxValue   Long.MAX_VALUE    
   long static MinValue   Long.MIN_VALUE    
   string ToString(NumberFormatInfo)   {0}.format({!})    
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem   model by 'sprintf', format must be string lexem   model by code, format must be string lexem   model by code, format must be string lexem
   static long Parse(string, NumberStyles, *)   Utils.parseLong({0}, {1}, {2=null})    
   static long Parse(string)   Utils.parseLong({0}, 0, null)   int({0})   Utils.ParseLong({0})   Utils.parseInt({0}) 
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out long)   Utils.parseLong({0}, {1}, {2}, {3})    
   static bool TryParse(string, out long)   Utils.parseLong({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})   Utils.TryParseLong({0}, {1})   Utils.tryParseInt({0}, {1}) 
class MatchRegexMatchWrapper (our service class)    
   int Index   {!}.index    
   int Length   {!}.length    
   bool Success   {!}.success    
   string Value   {!}.value    
   List<T> Groups { get; }   get: {!}.groups    
   Match NextMatch()   {!}.nextMatch()    
class MatchCollection     
static class Mathjava.lang.Mathmath (import math) Math 
   double E   Math.E   math.e    Math.E 
   double PI   Math.PI   math.pi    Math.PI 
   long Abs(long)   Math.abs({0})   math.fabs({0})   abs({0})   Math.abs({0}) 
   float Abs(float)   Math.abs({0})   math.fabs({0})   abs({0})   Math.abs({0}) 
   double Abs(double)   Math.abs({0})   math.fabs({0})   abs({0})   Math.abs({0}) 
   int Abs(int)   Math.abs({0})   math.fabs({0})   abs({0})   Math.abs({0}) 
   double Acos(double)   Math.acos({0})   math.acos({0})   acos({0})   Math.acos({0}) 
   double Asin(double)   Math.asin({0})   math.asin({0})   asin({0})   Math.asin({0}) 
   double Atan(double)   Math.atan({0})   math.atan({0})   atan({0})   Math.atan({0}) 
   double Atan2(double)   Math.atan2({0})    atan2({0})   Math.atan2({0}) 
   double Ceiling(double)   Math.ceil({0})   math.ceil({0})   ceil({0})   Math.ceil({0}) 
   double Cos(double)   Math.cos({0})   math.cos({0})   cos({0})   Math.cos({0}) 
   double Cosh(double)   Math.cosh({0})   math.cosh({0})   cosh({0})   Math.cosh({0}) 
   double Exp(double)   Math.exp({0})   math.exp({0})   exp({0})   Math.exp({0}) 
   double Floor(double)   Math.floor({0})   math.floor({0})   floor({0})   Math.floor({0}) 
   double Log(double, double)   (Math.log({0})/Math.log({1}))   math.log({0}, {1})   log({0}, {1})   (Math.log({0})/Math.log({1})) 
   double Log(double)   Math.log({0})   math.log({0})   log({0})   Math.log({0}) 
   double Log10(double)   Math.log10({0})   math.log10({0})   log10({0})   Math.log10({0}) 
   float Max(float, float)   Math.max({0}, {1})   min({0}, {1})   max({0}, {1})   Math.max({0}, {1}) 
   int Max(int, int)   Math.max({0}, {1})   max({0}, {1})   max({0}, {1})   Math.max({0}, {1}) 
   long Max(long, long)   Math.max({0}, {1})   max({0}, {1})   max({0}, {1})   Math.max({0}, {1}) 
   double Max(double, double)   Math.max({0}, {1})   max({0}, {1})   max({0}, {1})   Math.max({0}, {1}) 
   long Min(long, long)   Math.min({0}, {1})   min({0}, {1})   min({0}, {1})   Math.min({0}, {1}) 
   float Min(float, float)   Math.min({0}, {1})   min({0}, {1})   min({0}, {1})   Math.min({0}, {1}) 
   double Min(double, double)   Math.min({0}, {1})   min({0}, {1})   min({0}, {1})   Math.min({0}, {1}) 
   int Min(int, int)   Math.min({0}, {1})   min({0}, {1})   min({0}, {1})   Math.min({0}, {1}) 
   double Pow(double, double)   Math.pow({0}, {1})   math.pow({0}, {1})   pow({0})   Math.pow({0}, {1}) 
   double Round(double)   Math.round({0})   round({0}, 0)   round({0})   Math.round({0}) 
   double Round(double, int)   Utils.mathRound({0}, {1})   round({0}, {1})   round({0}, {1})   Utils.mathRound({0}, {1}) 
   int Sign(double)   ((int)Math.signum({0}))    min(1, max(-1, {0}))   Math.sign({0}) 
   double Sin(double)   Math.sin({0})   math.sin({0})   sin({0})   Math.sin({0}) 
   double Sinh(double)   Math.sinh({0})   math.sinh({0})   sinh({0})   Math.sinh({0}) 
   double Sqrt(double)   Math.sqrt({0})   math.sqrt({0})   sqrt({0})   Math.sqrt({0}) 
   double Tan(double)   Math.tan({0})   math.tan({0})   tan({0})   Math.tan({0}) 
   double Tanh(double)   Math.tanh({0})   math.tanh({0})   tanh({0})   Math.tanh({0}) 
   double Truncate(double)   Utils.mathTruncate({0})   math.trunc({0})   Utils.MathTruncate({0})   Utils.mathTruncate({0}) 
class MemoryStream : StreamMemoryStream (our service class)io.BytesIO (import io)resourceMemoryStream (our service class)MemoryStream (our service class)
    .ctor(byte[], bool)   .ctor({0}, {1})   .ctor({0}, {1})   
    .ctor(byte[], int, int, *)   new MemoryStream({0}, {1}, {2})    
    .ctor(int)   .ctor({0})   .ctor({0})   fopen("php://memory", "w+b")   .ctor({0})   MemoryStream::with_capacity({0})
    .ctor()   .ctor()   .ctor()   fopen("php://memory", "w+b")   .ctor()   MemoryStream::new()
    .ctor(byte[])   .ctor({0})   .ctor({0})   Utils.CreateMemoryStream({0})   .ctor({0})   MemoryStream::from_list({0&})
   byte[] ToArray()   {!}.toByteArray()   bytearray({!}.getvalue())   Utils.GetArrayStream({!})   {!}.toByteArray()   {!}.to_list()
   void WriteTo(Stream)   {!}.writeTo({0})   shutil.copyfileobj({!}, {0}) (import shutil)     {!}.write_to({0})
enum NormalizationFormjava.text.Normalizer.FormstrNormalizerString 
    static FormC   java.text.Normalizer.Form.NFC   'NFC'   Normalizer::FORM_C   'NFC' 
    static FormD   java.text.Normalizer.Form.NFD   'NFD'   Normalizer::FORM_D   'NFD' 
    static FormKC   java.text.Normalizer.Form.NFKC   'NFKC'   Normalizer::FORM_KC   'NFKC' 
    static FormKD   java.text.Normalizer.Form.NFKD   'NFKD'   Normalizer::FORM_KD   'NFKD' 
class NotImplementedException : Exceptionjava.lang.UnsupportedOperationExceptionNotImplementedErrorExceptionError 
class NotSupportedException : Exceptionjava.lang.UnsupportedOperationExceptionExceptionExceptionError 
class NullReferenceException : Exceptionjava.lang.NullPointerExceptionExceptionRuntimeExceptionReferenceError 
class NumberFormatInfojava.text.DecimalFormat    
   string NegativeSign { get; set; }   get: {!}.getNegativePrefix()
   set: {!}.setNegativePrefix({0})
    
   string NumberDecimalSeparator { get; set; }   get: String.valueOf({!}.getDecimalFormatSymbols().getDecimalSeparator())
   set: Utils.setDecimalSeparator({!}, {0})
    
   string PositiveSign { get; set; }   get: {!}.getPositivePrefix()
   set: {!}.setPositivePrefix({0})
    
    .ctor()   .ctor()    
enum NumberStylesint    
    static AllowHexSpecifier   512    
    static Any   511    
    static HexNumber   515    
class objectjava.lang.ObjectobjectstdClassObject 
   bool Equals(object)   {!}.equals({0})   {!}.equals({0})    {!}.equals({0}) 
   int GetHashCode()   {!}.hashCode()   {!}.__hash__()   
   Type GetType()   {!}.getClass()   type({!})   
   object MemberwiseClone()   generate method in class   generate method in class   generate method in class   generate method in class 
   string ToString()   {!}.toString()   Generate code by inner hardcode procedure   {!}->__toString()   {!}.toString()   Generate code by inner hardcode procedure
   static bool ReferenceEquals(object, object)   Utils.referenceEquals({0}, {1})    ({0} === {1})  
class ObjectDisposedException : Exceptionjava.lang.ExceptionExceptionExceptionError 
class OutOfMemoryException : Exceptionjava.lang.OutOfMemoryErrorMemoryErrorExceptionError 
class OverflowException : Exceptionjava.lang.StackOverflowErrorOverflowErrorOverflowExceptionError 
static class Path  (import pathlib)   
   string ChangeExtension(string, string)   Utils.changeFileExt({0}, {1})   pathlib.PurePath({0}).with_suffix({1})   
   string Combine(string, string)   (new java.io.File({0}, (new java.io.File({1})).getPath())).getPath()   pathlib.PurePath({0}).joinpath({1})    path.join({0}, {1}) (import path) 
   string GetDirectoryName(string)   (new java.io.File({0})).getAbsoluteFile().getParent()   pathlib.PurePath({0}).parent.absolute()   dirname({0})   path.dirname({0}) (import path) 
   string GetExtension(string)   Utils.getFileExt({0})   pathlib.PurePath({0}).suffix   ".".pathinfo("kos.tmp", PATHINFO_EXTENSION)   path.extname({0}) (import path) 
   string GetFileName(string)   (new java.io.File({0})).getName()   pathlib.PurePath({0}).name   basename({0})   path.basename({0}) (import path) 
   string GetFileNameWithoutExtension(string)   Utils.getFileWithoutExt({0})   Utils.getFilenameWithoutExt({0})   
   string GetFullPath(string)   Utils.getFullPath({0})   pathlib.PurePath({0}).absolute()   realpath({0})   path.resolve({0}) (import path) 
   string GetPathRoot(string)   Utils.getRootPath({0})   pathlib.PurePath({0}).root   
   string GetTempFileName()   Utils.getTempFileName()    
   string GetTempPath()   (new java.io.File(System.getProperty(\"java.io.tmpdir\"))).getName()    
   bool IsPathRooted(string)   Utils.isPathRooted({0})   pathlib.PurePath({0}).is_absolute()    path.isAbsolute({0}) (import path) 
class PathTooLongException : Exceptionjava.lang.ExceptionExceptionExceptionError 
delegate Predicate<T>Predicate (our service class)    
   bool call(T)   call    
class ProgressChangedEventArgsProgressEventArgs (our service class)ProgressEventArgs (our service class)ProgressEventArgs (our service class)ProgressEventArgs (our service class) 
   int ProgressPercentage { get; }   get: {!}.getProgressPercentage()   get: {!}.progressPercentage   get: {!}->progressPercentage   get: {!}.progressPercentage 
   object UserState { get; }   get: {!}.getUserState()   get: {!}.userState   get: {!}->userState   get: {!}.userState 
    .ctor(int, object)   .ctor({0}, {1})   .ctor({0}, {1})   .ctor({0}, {1})   .ctor({0}, {1}) 
delegate ProgressChangedEventHandlerProgressEventHandler (our service class)EventHandler (our service class)EventHandler (our service class)EventHandler (our service class)NString
   void call(object, ProgressChangedEventArgs)   {!}.call({0}, {1})   {!}.call({0}, {1})   {!}->call({0}, {1})   {!}.call({0}, {1}) 
class PropertyChangedEventArgsPropertyChangedEventArgs (our service class)PropertyChangedEventArgs (our service class)   
   int PropertyName { get; }   get: {!}.getPropertyName()   get: {!}.propertyName   
    .ctor(string)   .ctor({0})   .ctor({0})   
delegate PropertyChangedEventHandlerPropertyChangedEventHandler (our service class)EventHandler (our service class)EventHandler (our service class)EventHandler (our service class) 
   void call(object, PropertyChangedEventArgs)   {!}.call({0}, {1})   {!}.call({0}, {1})   {!}->call({0}, {1})   {!}.call({0}, {1}) 
struct Randomjava.util.Random    
    .ctor(long)   .ctor({0})    
    .ctor()   .ctor()    
   int Next()   {!}.nextInt()    
   int Next(int)   {!}.nextInt({0})    
   void NextBytes(byte[])   {!}.nextBytes({0})    
   double NextDouble()   {!}.nextDouble()    
class Regexjava.util.regex.Pattern    
    .ctor(string, *)   Generate code by inner hardcode procedure    
   bool IsMatch(string)   Utils.isMatchRegex({!}, {0})    
   Match Match(string, *)   Utils.createMatchRegex({!}, {0}, {1=0})    
   List<T> Matches(string, *)   Utils.matchesRegex({!}, {0}, {1=0})    
   string[] Split(string, int)   {!}.split({0}, {1})    
   string[] Split(string)   {!}.split({0})    
   static string[] Split(string, string, *)   Generate code by inner hardcode procedure    
enum RegexOptionsjava.util.regex.Pattern    
    static ECMAScript   Ignored in Java    
    static IgnoreCase   java.util.regex.Pattern.CASE_INSENSITIVE | java.util.regex.Pattern.UNICODE_CASE    
    static Multiline   java.util.regex.Pattern.MULTILINE    
    static Singleline   java.util.regex.Pattern.DOTALL    
class sbytebyte / java.lang.ByteintintNumberi8
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem   model by 'sprintf', format must be string lexem   model by code, format must be string lexem   model by code, format must be string lexem
   static sbyte Parse(string)   Utils.parseByte({0})   int({0})   int({0})   Utils.parseInt({0}) 
   static bool TryParse(string, out sbyte)   Utils.parseByte({0}, {1})   Utils.tryParseInt({0}, {1})   Utils.TryParseInt({0}, {1})   Utils.tryParseInt({0}, {1}) 
class SecurityException : Exceptionjava.lang.SecurityExceptionExceptionExceptionError 
enum SeekOriginintio (import io)intintint
    static Begin   0   io.SEEK_SET   SEEK_SET   0   0
    static Current   1   io.SEEK_CUR   SEEK_CUR   1   1
    static End   2   io.SEEK_END   SEEK_END   2   2
class shortshort / java.lang.ShortintintNumberi16
   short static MaxValue   32767   32767   32767   32767 
   string ToString(NumberFormatInfo)   {0}.format({!})    
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem   model by 'sprintf', format must be string lexem   model by code, format must be string lexem   model by code, format must be string lexem
   static short Parse(string, NumberStyles, *)   Utils.parseShort({0}, {1}, {2=null})    
   static short Parse(string)   Utils.parseShort({0}, 0, null)   int({0})   int({0})   Utils.parseInt({0}) 
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out short)   Utils.parseShort({0}, {1}, {2}, {3})    
   static bool TryParse(string, out short)   Utils.parseShort({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})   Utils.TryParseInt({0}, {1})   Utils.tryParseInt({0}, {1}) 
class SortedDictionary<K, V> : Dictionaryjava.util.HashMap<K, V>dict<K, V>warning: SortedDictionary not supported in PHP, use simple Dictionarywarning: SortedDictionary not supported in JS, use simple Dictionarywarning: SortedDictionary not supported in RUST, use simple Dictionary
class Stack<T> : ICollection [T]java.util.Stack<T>  Array<T> 
   T Peek()   {!}.peek()     {!}[{!}.length - 1] 
   T Pop()   {!}.pop()     {!}.pop() 
   void Push(T)   {!}.push({0})     {!}.push({0}) 
class StackOverflowException : Exceptionjava.lang.StackOverflowErrorStackOverflowErrorExceptionError 
class StopwatchStopwatch (our service class)Stopwatch (our service class)Stopwatch (our service class)Stopwatch (our service class)Stopwatch (our service class)
   TimeSpan Elapsed { get; }   get: {!}.getElapsed()   get: {!}.elapsed   
   long ElapsedMilliseconds { get; }   get: {!}.getElapsedMilliseconds()   get: {!}.elapsedMilliseconds   get: {!}->GetElapsedMilliseconds()   get: {!}.elapsedMilliseconds   get: {!}.elapsed_milliseconds()
   bool IsRunning { get; }   get: {!}.isRunning()   get: {!}.isrunning   get: {!}->IsRunning()   get: {!}.isRunning 
    .ctor()   .ctor()   .ctor()   .ctor()   .ctor()   Stopwatch::new()
   void Reset()   {!}.reset()   {!}.reset()   {!}->Reset()   {!}.reset()   {!}.reset()
   void Start()   {!}.start()   {!}.start()   {!}->Start()   {!}.start()   {!}.start()
   void Stop()   {!}.stop()   {!}.stop()   {!}->Stop()   {!}.stop()   {!}.stop()
   static Stopwatch StartNew()   Utils.startNewStopwatch()   Stopwatch()   new Stopwatch()   new Stopwatch()   Stopwatch::new()
class StreamStream (our service class)io.IOBase (import io)resourceStream (our service class)IStream (our service class)
   bool CanRead { get; }   get: {!}.canRead()   get: {!}.readable   
   bool CanSeek { get; }   get: {!}.canSeek()   get: {!}.seekable   
   bool CanWrite { get; }   get: {!}.canWrite()   get: {!}.writable   
   long Length { get; }   get: {!}.length()   get: Utils.getLengthIO({!})   get: Utils.GetLengthStream({!})   get: {!}.length   get: {!}.len()
   long Position { get; set; }   get: {!}.getPosition()
   set: {!}.setPosition({0})
   get: {!}.tell()
   set: {!}.seek({0}, io.SEEK_SET)
   get: ftell({!})
   set: fseek({!}, {0}, SEEK_SET)
   get: {!}.position
   set: {!}.position = {0}
   get: {!}.get_position()
   set: {!}.set_position({0})
   void Close()   {!}.close()   {!}.close()   fclose({!})   {!}.close()   {!}.close()
   void Dispose()   {!}.close()   {!}.close()   fclose({!})   {!}.close()   {!}.close()
   void Flush()   {!}.flush()   {!}.flush()   fflush({!})   {!}.flush()   {!}.flush()
   int Read(byte[], int, int)   {!}.read({0}, {1}, {2})   Utils.readIO({!}, {0}, {1}, {2})   Utils.ReadStream({!}, {0}, {1}, {2})   {!}.read({0}, {1}, {2})   {!}.read({0}, {1}, {2})
   int ReadByte()   {!}.read()   Utils.readByteIO({!})   Utils.ReadByteStream({!})   {!}.readByte()   {!}.read_byte()
   long Seek(long, SeekOrigin)   {!}.seek({0}, {1})   {!}.seek({0}, {1})   fseek({!}, {0}, {1})   {!}.seek({0}, {1})   {!}.seek({0}, {1})
   void SetLength(long)   {!}.setLength({0})   {!}.truncate({0})   ftruncate({!}, {0})   {!}.setLength({0})   {!}.set_len({0})
   int Write(byte[], int, int)   {!}.write({0}, {1}, {2})   Utils.writeIO({!}, {0}, {1}, {2})   Utils.WriteStream({!}, {0}, {1}, {2})   {!}.write({0}, {1}, {2})   {!}.write({0&}, {1}, {2})
   void WriteByte(byte)   {!}.write({0})   Utils.writeByteIO({!}, {0})   Utils.WriteByteStream({!}, {0})   {!}.writeByte({0})   {!}.write_byte({0})
class StreamReader : TextReaderjava.io.BufferedReader    
   Stream BaseStream { get; }   get: BaseStream of StreamReader not supported in Java java.io.BufferedReader    
    .ctor(string, ?)   new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream({0}), {1}))    
    .ctor(string)   new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream({0})))    
class string [char]java.lang.StringstrstringStringNString (our service class)
   string static Empty   ""   ""   ""   ""   NString::empty()
   int Length { get; }   get: {!}.length()   get: len({!})   get: mb_strlen({!})   get: {!}.length   get: {!}.len()
   char this[int] { get; }   get: {!}.charAt({0})   get: {!}[{0}]   get: mb_substr({!}, {0}, 1)   get: {!}[{0}]   get: {!}.get({0})
    .ctor(char, int)   Utils.createString({0}, {1})     {0}.repeat({1}) 
    .ctor(char[], int, int)   .ctor({0}, {1}, {2})   .ctor({0}, {1}, {2})   
    .ctor()   .ctor()   .ctor()    .ctor()   NString::empty()
    .ctor(char[])   .ctor({0})   .ctor({0})    .ctor({0})   NString::from_chars({0})
   int CompareTo(string)   {!}.compareTo({0})    Utils.CompareStrings({!}, {0}, FALSE)   {!}.localeCompare({0})   NString::compare_strings({!}, {0&}, false)
   bool Contains(string)   ({!}.indexOf({0}) >= 0)   {0} in {!}   Utils.IndexOfString({!}, {0}, 0) >= 0   {!}.includes({0})   {!}.index_of_string({0&}, 0, false) >= 0
   bool EndsWith(string)   {!}.endsWith({0})   {!}.endswith({0})   Utils.EndsWithString({!}, {0}, FALSE)   {!}.endsWith({0})   {!}.ends_with({0&}, false)
   bool EndsWith(string, StringComparison)   Utils.endsWithString({!}, {0}, {1})   Utils.endsWithString({!}, {0}, {1})   Utils.EndsWithString({!}, {0}, {1})   Utils.endsWithString({!}, {0}, {1})   {!}.ends_with({0&}, {1})
   string Format(string, *)   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators
   IEnumerator<T> GetEnumerator()   {!}.toCharArray()    
   int IndexOf(string, int)   {!}.indexOf({0}, {1})   Utils.indexOfList({!}, {0}, {1})   Utils.IndexOfString({!}, {0}, {1})   {!}.indexOf({0}, {1})   {!}.index_of_string({0&}, {1}, false)
   int IndexOf(char)   {!}.indexOf({0})   {!}.find({0})   Utils.IndexOfString({!}, {0})   {!}.indexOf({0})   {!}.index_of_char({0}, 0, false)
   int IndexOf(string)   {!}.indexOf({0})   {!}.find({0})   Utils.IndexOfString({!}, {0})   {!}.indexOf({0})   {!}.index_of_string({0&}, 0, false)
   int IndexOf(char, int)   {!}.indexOf({0}, {1})   Utils.indexOfList({!}, {0}, {1})   Utils.IndexOfString({!}, {0}, {1})   {!}.indexOf({0}, {1})   {!}.index_of_char({0}, {1}, false)
   int IndexOfAny(char[], *)   Utils.indexOfAny({!}, {0}, {1=0}, {2=0})    
   int LastIndexOf(string)   {!}.lastIndexOf({0})   {!}.rfind({0})   Utils.LastIndexOfString({!}, {0})   {!}.lastIndexOf({0})   {!}.index_of_string({0&}, 0, true)
   int LastIndexOf(string, int)   {!}.lastIndexOf({0}, {1})   Utils.lastIndexOfList({!}, {0}, {1})   Utils.LastIndexOfString({!}, {0}, {1})   {!}.lastIndexOf({0}, {1})   {!}.index_of_string({0&}, {1}, true)
   int LastIndexOf(char, int)   {!}.lastIndexOf({0}, {1})   Utils.lastIndexOfList({!}, {0}, {1})   Utils.LastIndexOfString({!}, {0}, {1})   {!}.lastIndexOf({0}, {1})   {!}.index_of_char({0}, {1}, true)
   int LastIndexOf(char)   {!}.lastIndexOf({0})   {!}.rfind({0})   Utils.LastIndexOfString({!}, {0})   {!}.lastIndexOf({0})   {!}.index_of_char({0}, 0, true)
   string Normalize()   java.text.Normalizer.normalize({!}, java.text.Normalizer.Form.NFC)   unicodedata.normalize('NFC', {!}) (import unicodedata)   normalizer_normalize({!})   {!}.normalize() 
   string Normalize(NormalizationForm)   java.text.Normalizer.normalize({!}, {0})   unicodedata.normalize({0}, {!}) (import unicodedata)   normalizer_normalize({!}, {0})   {!}.normalize({0}) 
   string Remove(int, int)   Utils.removeString({!}, {0=0}, {1=0})    
   string Replace(string, string)   {!}.replace({0}, {1})   {!}.replace({0}, {1})   str_replace({0}, {1}, {!})   Utils.replaceString({!}, {0}, {1})   {!}.replace_string({0&}, {1&})
   string Replace(char, char)   {!}.replace({0}, {1})   {!}.replace({0}, {1})   str_replace({0}, {1}, {!})   Utils.replaceString({!}, {0}, {1})   {!}.replace_char({0}, {1})
   string[] Split(string, *)   Utils.split({!}, {0}, {1=false})   Utils.splitString({!}, {0}, {1=False})   Utils.SplitString({!}, {0}, {1=FALSE})   Utils.splitString({!}, {0}, {1=false}) 
   string[] Split(char, char)   Utils.split({!}, String.valueOf({0}) + String.valueOf({1}), false)   Utils.splitString({!}, {0} + {1}, False)   Utils.SplitString({!}, {0}. {1}, FALSE)   Utils.splitString({!}, {0} + {1}, false) 
   string[] Split(char[], *)   Utils.split({!}, new String({0}), {1=false})   Utils.splitString({!}, {0}, {1=False})   Utils.SplitString({!}, {0}, {1=FALSE})   Utils.splitString({!}, {0}, {1=false}) 
   string[] Split(char)   Utils.split({!}, String.valueOf({0}), false)   Utils.splitString({!}, {0}, False)   Utils.SplitString({!}, {0}, FALSE)   Utils.splitString({!}, {0}, false)   {!}.split_char({0}, false)
   string[] Split(char, char, char)   Utils.split({!}, String.valueOf({0}) + String.valueOf({1}) + String.valueOf({2}), false)   Utils.splitString({!}, {0} + {1} + {2}, False)   Utils.SplitString({!}, {0}. {1}.{2}, FALSE)   Utils.splitString({!}, {0} + {1} + {2}, false) 
   bool StartsWith(string)   {!}.startsWith({0})   {!}.startswith({0})   Utils.StartsWithString({!}, {0}, FALSE)   {!}.startsWith({0})   {!}.starts_with({0&}, false)
   bool StartsWith(string, StringComparison)   Utils.startsWithString({!}, {0}, {1})   Utils.startsWithString({!}, {0}, {1})   Utils.StartsWithString({!}, {0}, {1})   Utils.startsWithString({!}, {0}, {1})   {!}.starts_with({0&}, {1})
   string Substring(int)   {!}.substring({0})   {!}[{0}:]   mb_substr({!}, {0})   {!}.substring({0})   {!}.substring({0}, 0)
   string Substring(int, int)   {!}.substring({0}, {0} + {1})   {!}[{0}:{0}+{1}]   mb_substr({!}, {0}, {1})   {!}.substring({0}, {0} + {1})   {!}.substring({0}, {1})
   char[] ToCharArray()   {!}.toCharArray()     {!}.split(''); 
   string ToLower()   {!}.toLowerCase()   {!}.lower()   mb_convert_case({!}, MB_CASE_LOWER)   {!}.toLowerCase()   {!}.to_lowercase()
   string ToUpper()   {!}.toUpperCase()   {!}.upper()   mb_convert_case({!}, MB_CASE_UPPER)   {!}.toUpperCase()   {!}.to_uppercase()
   string Trim()   {!}.trim()   {!}.strip()   trim({!})   {!}.trim()   {!}.trim()
   string TrimEnd()   Utils.trimEnd({!})   Utils.trimEndString({!})   chop({!})   Utils.trimEndString({!})   {!}.trim_end()
   string TrimStart()   Utils.trimStart({!})   Utils.trimStartString({!})   ltrim({!})   Utils.trimStartString({!})   {!}.trim_start()
   static int Compare(string, string, ?)   Utils.stringsCompare({0}, {1}, {2})   Utils.compareStrings({0}, {1}, {2})   Utils.CompareStrings({0}, {1}, {2})   Utils.compareStrings({0}, {1}, {2})   NString::compare_strings({0&}, {1&}, {2})
   static int Compare(string, string)   Utils.stringsCompare({0}, {1}, false)   Utils.compareStrings({0}, {1}, False)   Utils.CompareStrings({0}, {1}, FALSE)   Utils.compareStrings({0}, {1}, false)   NString::compare_strings({0&}, {1&}, false)
   static bool IsNullOrEmpty(string)   Utils.isNullOrEmpty({0})   Utils.isNullOrEmpty({0})   {0} == NULL   Utils.isNullOrEmpty({0})   {0}.is_empty()
   static bool IsNullOrWhiteSpace(string)   Utils.isNullOrWhiteSpace({0})   Utils.isNullOrWhiteSpace({0})    Utils.isNullOrWhiteSpace({0}) 
   static string Join(string, IEnumerable<T>)   String.join({0}, {1})   Utils.joinStrings({0}, {1})   Utils.JoinStrings({0}, {1})   {1}.join({0}) 
class StringBuilderjava.lang.StringBuilderio.StringIO (import io)StringBuilder (our service class)StringBuilder (our service class)StringBuilder (our service class)
   int Length { get; set; }   get: {!}.length()
   set: {!}.setLength({0})
   get: {!}.tell()
   set: Utils.setLengthStringIO({!}, {0})
   get: {!}->Length()
   set: {!}->SetLength({0})
   get: {!}.length
   set: {!}.length = {0}
   get: {!}.len()
   set: {!}.set_len({0})
   char this[int] { get; set; }   get: {!}.charAt({0})
   set: {!}.setCharAt({0}, {1})
   get: Utils.getCharAtStringIO({!}, {0})
   set: Utils.setCharAtStringIO({!}, {0}, {1})
   get: {!}->CharAt({0})
   set: {!}->SetCharAt({0}, {1})
   get: {!}.charAt({0})
   set: {!}.setCharAt({0}, {1})
   get: {!}.get({0})
   set: {!}.set({0}, {1})
    .ctor()   .ctor()   .ctor()   .ctor()   .ctor()   StringBuilder::null()
    .ctor(?)   .ctor({0})   Utils.newStringIO({0})   .ctor({0})   .ctor({0})   StringBuilder::from_string({0&})
   StringBuilder Append(?)   {!}.append({0})   print({0}, end="", file={!})   {!}->Append({0})   {!}.append({0})   Model constant format string by operators
   StringBuilder Append(char, int)   Utils.append({!}, {0}, {1})    
   StringBuilder AppendFormat(string, *)   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators   Model constant format string by operators
   StringBuilder Insert(int, ?)   {!}.insert({0}, {1})   Utils.insertStringIO({!}, {0}, {1})   {!}->Insert({0}, {1})   {!}.insert({0}, {1})   Model constant format string by operators
   StringBuilder Remove(int, int)   {!}.delete({0}, {0} + {1})   Utils.removeStringIO({!}, {0}, {1})   {!}->Remove({0}, {1})   {!}.remove({0}, {1})   {!}.remove({0}, {1})
   StringBuilder Replace(char, char)   Utils.replace({!}, {0}, {1})   Utils.replaceStringIO({!}, {0}, {1})   {!}->Replace({0}, {1})   {!}.replace({0}, {1})   {!}.replace_char({0}, {1})
   StringBuilder Replace(string, string)   Utils.replace({!}, {0}, {1})   Utils.replaceStringIO({!}, {0}, {1})   {!}->Replace({0}, {1})   {!}.replace({0}, {1}) 
enum StringComparisonbooleanboolboolbooleanbool
    static CurrentCulture   false   False   FALSE   false   false
    static CurrentCultureIgnoreCase   true   True   TRUE   true   true
    static InvariantCulture   false   False   FALSE   false   false
    static InvariantCultureIgnoreCase   true   True   TRUE   true   true
    static Ordinal   false   False   FALSE   false   false
    static OrdinalIgnoreCase   true   True   TRUE   true   true
class StringReader : TextReaderjava.io.StringReaderio.StringIO (import io)   
    .ctor(string)   new java.io.BufferedReader(new java.io.StringReader({0}))   .ctor({0})   
enum StringSplitOptionsbooleanboolboolBooleanbool
    static None   false   False   FALSE   false   false
    static RemoveEmptyEntries   true   True   TRUE   true   true
class TargetInvocationException : Exceptionjava.lang.reflect.InvocationTargetExceptionExceptionExceptionError 
class TextReader : IDisposablejava.io.BufferedReaderio.TextIOBase (import io)   
   void Close()   {!}.close()   {!}.close()   
   void Dispose()   {!}.close()   {!}.close()   {!}->close()   {!}.close() 
   int Read(char[], int, int)   {!}.read({0}, {1}, {2})    
   int Read()   {!}.read()    
   string ReadLine()   {!}.readLine()   Utils.readLineIO({!})   
class Threadjava.lang.Thread    
   bool IsAlive { get; }   get: {!}.isAlive()    
    .ctor(object)   .ctor({0})    
   void Abort()   {!}.interrupt()    
   void Interrupt()   {!}.interrupt()    
   void Start()   {!}.start()    
   void Start(object)   generate special code for model start thread with parameter    
   static void Sleep(long)   Thread.sleep({0})    
delegate ThreadStartjava.lang.Runnable    
   void call()   {!}.run()    
struct TimeSpanjava.time.Durationdatetime.timedelta (import datetime)   
   long TotalDays { get; }   get: {!}.toDays()   get: {!}.days   
   long TotalHours { get; }   get: {!}.toHours()   get: ({!}.total_seconds() // 3600)   
   long TotalMilliseconds { get; }   get: {!}.toMillis()   get: ({!}.total_seconds() * 1000)   
   long TotalMinutes { get; }   get: {!}.toMinutes()   get: ({!}.total_seconds() // 60)   
   long TotalSeconds { get; }   get: {!}.getSeconds()   get: int({!}.total_seconds())   
   static TimeSpan FromDays(long)   java.time.Duration.ofDays({0})    
   static TimeSpan FromHours(long)   java.time.Duration.ofHours({0})    
   static TimeSpan FromMilliseconds(long)   java.time.Duration.ofMillis({0})    
   static TimeSpan FromMinutes(long)   java.time.Duration.ofMinutes({0})    
   static TimeSpan FromSeconds(long)   java.time.Duration.ofSeconds({0})    
class Typejava.lang.Class    
   string FullName { get; }   get: {!}.getName()    
   string Name { get; }   get: {!}.getSimpleName()    
   ConstructorInfo GetConstructor(Type[])   {!}.getDeclaredConstructor({0})    
   ConstructorInfo[] GetConstructors()   {!}.getDeclaredConstructors()    
class uintint / java.lang.IntegerintintNumberu32
   ulong static MaxValue   4294967295L   4294967295   4294967295   4294967295 
   int static MinValue     
   string ToString(NumberFormatInfo)   {0}.format({!})    
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem   model by 'sprintf', format must be string lexem   model by code, format must be string lexem   model by code, format must be string lexem
   static uint Parse(string, NumberStyles, *)   Utils.parseInteger({0}, {1}, {2=null})    
   static uint Parse(string)   Utils.parseInteger({0}, 0, null)   int({0})   int({0})   Utils.parseInt({0}) 
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out uint)   Utils.parseInteger({0}, {1}, {2}, {3})    
   static bool TryParse(string, out uint)   Utils.parseInteger({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})   Utils.TryParseInt({0}, {1})   Utils.tryParseInt({0}, {1}) 
class ulonglong / java.lang.Longintfloatwarning: JavaScript not support long, use intu64
   string ToString(NumberFormatInfo)   {0}.format({!})    
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem   model by 'sprintf', format must be string lexem   model by code, format must be string lexem   model by code, format must be string lexem
   static ulong Parse(string, NumberStyles, *)   Utils.parseLong({0}, {1}, {2=null})    
   static ulong Parse(string)   Utils.parseLong({0}, 0, null)   int({0})   Utils.ParseLong({0})   Utils.parseInt({0}) 
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out ulong)   Utils.parseLong({0}, {1}, {2}, {3})    
   static bool TryParse(string, out ulong)   Utils.parseLong({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})   Utils.TryParseLong({0}, {1})   Utils.tryParseInt({0}, {1}) 
class Urijava.net.URI    
   string AbsoluteUri { get; }   get: {!}.toASCIIString()    
   string Authority { get; }   get: {!}.getAuthority()    
   string Fragment { get; }   get: Utils.encodeUri({!}.getFragment())    
   string Host { get; }   get: {!}.getHost()    
   bool IsAbsolute { get; }   get: {!}.isAbsolute()    
   string LocalPath { get; }   get: Utils.encodeUri({!}.getPath())    
   int Port { get; }   get: {!}.getPort()    
   string Query { get; }   get: Utils.encodeUri({!}.getQuery())    
   string Scheme { get; }   get: {!}.getScheme()    
    .ctor(string)   .ctor({0})    
   Uri MakeRelativeUri(Uri)   {!}.relativize({0})    
   static bool TryCreate(string, UriKind, out Uri)   Utils.parseUri({0}, {2})    
class UriFormatException : Exceptionjava.net.URISyntaxExceptionExceptionExceptionError 
enum UriKindint    
    static Absolute   1    
    static Relative   2    
    static RelativeOrAbsolute   0    
class ushortshort / java.lang.ShortintintNumberu16
   uint static MaxValue   65535   65535   65535   65535 
   string ToString(string)   model by String.format(format, val), format must be string lexem   model by 'format', format must be string lexem   model by 'sprintf', format must be string lexem   model by code, format must be string lexem   model by code, format must be string lexem
   static ushort Parse(string, NumberStyles, *)   Utils.parseShort({0}, {1}, {2=null})    
   static ushort Parse(string)   Utils.parseShort({0}, 0, null)   int({0})   int({0})   Utils.parseInt({0}) 
   static bool TryParse(string, NumberStyles, NumberFormatInfo, out ushort)   Utils.parseShort({0}, {1}, {2}, {3})    
   static bool TryParse(string, out ushort)   Utils.parseShort({0}, 0, null, {1})   Utils.tryParseInt({0}, {1})   Utils.TryParseInt({0}, {1})   Utils.tryParseInt({0}, {1}) 
class WebClientWebclient (our service class)    
   byte[] DownloadData(Uri)   {!}.downloadData({0})    
   byte[] DownloadData(string)   {!}.downloadData({0})    
   string DownloadString(string)   {!}.downloadString({0})    
   string DownloadString(Uri)   {!}.downloadString({0})    
   byte[] UploadData(string, byte[])   {!}.uploadData({0}, {1})    
   byte[] UploadData(Uri, byte[])   {!}.uploadData({0}, {1})    
class XmlAttributeorg.w3c.dom.NodetupleDOMAttrXmlAttribute (our service class) 
   string InnerText { get; }   get: {!}.getTextContent()   get: {!}[1]   get: {!}->value   get: {!}.value 
   string LocalName { get; }   get: Utils.getXmlLocalName({!})   get: {!}[0]   get: {!}->name   get: {!}.local_name 
   string Name { get; }   get: {!}.getNodeName()   get: {!}[0]   get: {!}->name   get: {!}.name 
   string Value { get; set; }   get: {!}.getNodeValue()
   set: {!}.setNodeValue({0})
   get: {!}[1]
   set: {!}[0] = {0}
   get: {!}->value
   set: {!}->value = {0}
   get: {!}.value 
class XmlAttributeCollection [XmlAttribute]org.w3c.dom.NamedNodeMapdictarrayArray 
   int Count { get; }   get: {!}.getLength()   get: len({!})   get: count({!})   get: {!}.length 
   XmlAttribute this[string] { get; }   get: Utils.getXmlAttrByName({!}, {0})   get: Utils.getXmlAttrByName({!}, {0})   get: Utils.GetXmlAttrByName({!}, {0})   get: Utils.getXmlAttrByName({!}, {0}) 
   XmlAttribute this[int] { get; }   get: {!}.item({0})   get: Utils.getXmlAttrByIndex({!}, {0})   get: {!}[{0}]   get: {!}[{0}] 
class XmlDocumentXmlDocumentWrapper (our service class)xml.etree.ElementTree.Element (import xml.etree)DOMDocumentXmlDocument (our service class) 
   XmlNode DocumentElement { get; }   get: {!}.doc.getDocumentElement()   get: {!}.getroot()   get: {!}->documentElement   get: {!}.document_element 
   bool PreserveWhitespace { get; set; }   get: {!}.getPreserveWhitespace() PreserveWhitespace not supported in Java (always true)
   set: {!}.setPreserveWhitespace({0}) PreserveWhitespace not supported in Java (always true)
    get: {!}->preserveWhiteSpace
   set: {!}->preserveWhiteSpace = {0}
   get: {!}.preserve_whitespace
   set: {!}.preserve_whitespace = {0}
 
    .ctor()   .ctor()   .ctor()   .ctor()   .ctor() 
   void Load(Stream)   {!}.load({0})   {!} = xml.etree.ElementTree.parse({0})   Utils.loadStreamDom({!}, {0})   {!}.loadStream({0}) 
   void Load(string)   {!}.doc = {!}.db.parse({0})   {!} = xml.etree.ElementTree.parse({0})   {!}->load({0})   {!}.loadFile({0}) 
   void LoadXml(string)   {!}.doc = {!}.db.parse(new org.xml.sax.InputSource(new java.io.StringReader({0})))   {!} = Utils.parseXmlFromString({0})   {!}->loadXml({0})   {!}.loadXml({0}) 
class XmlException : Exceptionjavax.xml.stream.XMLStreamExceptionExceptionExceptionError 
class XmlNodeorg.w3c.dom.Nodexml.etree.ElementTree.Element (import xml.etree)DOMElementXmlNode (our service class) 
   XmlAttributeCollection Attributes { get; }   get: modeled by method getAttributes   get: {!}.attrib   get: {!}->attributes   get: {!}.attributes 
   XmlNodeList ChildNodes { get; }   get: modeled by method getChildNodes   get: {!}   get: ({!}->childNodes ?? [])   get: {!}.child_nodes 
   bool HasChildNodes { get; }   get: {!}.hasChildNodes()   get: len({!}) > 0   get: ({!}->childNodes != null && count({!}->childNodes) > 0)   get: {!}.child_nodes.length > 0 
   string InnerText { get; }   get: {!}.getTextContent()   get: Utils.getXmlInnerText({!})   get: Utils.GetContentFromNode({!})   get: {!}.inner_text 
   string LocalName { get; }   get: Utils.getXmlLocalName({!})   get: {!}.tag   get: Utils.GetNameFromNode({!})   get: {!}.local_name 
   string Name { get; }   get: {!}.getNodeName()   get: {!}.tag   get: Utils.GetNameFromNode({!})   get: {!}.name 
   XmlNode NextSibling { get; }   get: {!}.getNextSibling()    get: {!}->nextSibling  
   XmlNode ParentNode { get; }   get: {!}.getParentNode()    get: {!}->parentNode  
   XmlNode PreviousSibling { get; }   get: {!}.getPreviousSibling() {!}->previousSibling    
   string Value { get; set; }   get: {!}.getNodeValue()
   set: {!}.setNodeValue({0})
   get: {!}.text
   set: {!}.text = {0}
   get: Utils.GetTextFromNode({!})
   set: {!}->textContent = {0}
   get: {!}.value 
   IEnumerator<T> GetEnumerator()   modeled by method getChildNodes   {!}   {!}->childNodes   {!}.child_nodes 
class XmlNodeList [XmlNode]org.w3c.dom.NodeListlistarrayArray 
   int Count { get; }   get: {!}.getLength()   get: len({!})   get: count({!})   get: {!}.length 
   XmlNode this[int] { get; }   get: {!}.item({0})   get: {!}[{0}]   get: {!}[{0}]   get: {!}[{0}] 
class XmlWriterXmlWriterWrapper (our service class)XmlWriter (our service class)XmlWriterWrapper (our service class)XmlWriter (our service class) 
   void Close()   {!}.close()   {!}.close()   {!}->Close()   {!}.close() 
   void Dispose()   {!}.close()   {!}.close()   {!}->Close()   {!}.close() 
   void Flush()   {!}.flush()   {!}.flush()   {!}->xml->Flush()   {!}.flush() 
   void WriteAttributeString(string, string)   {!}.wr.writeAttribute({0}, {1})   {!}.write_attribute_string({0}, {1})   {!}->xml->writeAttribute({0}, {1})   {!}.writeAttributeString({0}, {1}) 
   void WriteAttributeString(string, string, string, string)   {!}.wr.writeAttribute({0}, ({2} == null) ? "" : ({2}), {1}, {3})   {!}.write_attribute_string3({0}, {1}, {2}, {3})   {!}->xml->writeAttributeNs({0}, {1}, {2}, {3})   {!}.writeAttributeString3({0}, {1}, {2}, {3}) 
   void WriteAttributeString(string, string, string)   {!}.wr.writeAttribute("p2", {1}, {0}, {2}) Must set prefix for attribute with namespace   {!}.write_attribute_string2({0}, {1}, {2})   {!}->xml->writeAttributeNs("p2", {0}, {1}, {2})   {!}.writeAttributeString2({0}, {1}, {2}) 
   void WriteCData(string)   {!}.wr.writeCData({0})   {!}.write_cdata({0})   {!}->xml->writeCdata({0})   {!}.writeCdata({0}) 
   void WriteChars(char[])   {!}.wr.writeCharacters({0})    {!}->xml->text({0})   {!}.writeString({0}) 
   void WriteComment(string)   {!}.wr.writeComment({0})   {!}.write_comment({0})   {!}->xml->writeComment({0})   {!}.writeComment({0}) 
   void WriteElementString(string, string)   {!}.writeElementString({0}, {1})   {!}.write_element_string({0}, {1})   {!}->xml->writeElement({0}, {1})   {!}.writeElementString({0}, {1}) 
   void WriteEndDocument()   {!}.wr.writeEndDocument()   {!}.write_end_document()   {!}->xml->endDocument()   {!}.writeEndDocument() 
   void WriteEndElement()   {!}.wr.writeEndElement()   {!}.write_end_element()   {!}->xml->endElement()   {!}.writeEndElement() 
   void WriteProcessingInstruction(string)   {!}.wr.writeProcessingInstruction({0})    
   void WriteStartDocument(*)   {!}.wr.writeStartDocument({!}.encoding, "1.0")   {!}.write_start_document()   {!}->xml->startDocument("1.0", "utf-8")   {!}.writeStartDocument({0}) 
   void WriteStartElement(string, string)   {!}.wr.writeStartElement({1}, {0})   {!}.write_start_element2({0}, {1})   {!}->xml->startElementNS(NULL, {0}, {1})   {!}.writeStartElement2({0}, {1}) 
   void WriteStartElement(string)   {!}.wr.writeStartElement({0})   {!}.write_start_element({0})   {!}->xml->startElement({0})   {!}.writeStartElement({0}) 
   void WriteStartElement(string, string, string)   {!}.wr.writeStartElement({0}, {1}, {2})   {!}.write_start_element3({0}, {1}, {2})   {!}->xml->startElementNS({0}, {1}, {2})   {!}.writeStartElement3({0}, {1}, {2}) 
   void WriteString(string)   {!}.wr.writeCharacters({0})   {!}.write_string({0})   {!}->xml->text({0})   {!}.writeString({0}) 
   void WriteValue(?)   {!}.wr.writeCharacters(String.valueOf({0}))   {!}.write_value({0})   {!}->xml->text(strval({0}))   {!}.writeValue({0}) 
   static XmlWriter Create(string, *)   new XmlWriterWrapper({0}, {1=null})   XmlWriter.create_file({0}, {1=null})   XmlWriterWrapper::CreateToFile({0}, {1=NULL})   XmlWriter.createFile({0}, {1=NULL}) 
   static XmlWriter Create(Stream, *)   new XmlWriterWrapper({0}, {1=null})   XmlWriter.create_stream({0}, {1=null})    XmlWriter.createStream({0}, {1=NULL}) 
   static XmlWriter Create(StringBuilder, *)   new XmlWriterWrapper({0}, {1=null})   XmlWriter.create_string({0}, {1=null})   XmlWriterWrapper::CreateToStringBuilder({0}, {1=NULL})   XmlWriter.createString({0}, {1=NULL}) 
class XmlWriterSettingsXmlWriterSettings (our service class)XmlWriterSettings (our service class)XmlWriterSettings (our service class)XmlWriterSettings (our service class) 
   Encoding Encoding { get; set; }   get: {!}.getEncoding()
   set: {!}.setEncoding({0})
   get: {!}.encoding
   set: {!}.encoding = {0}
   get: {!}->encoding
   set: {!}->encoding = {0}
   get: {!}.encoding
   set: {!}.encoding = {0}
 
   bool Indent { get; set; }   get: {!}.getIndent()
   set: {!}.setIndent({0})
   get: {!}.indent
   set: {!}.indent = {0}
    get: {!}.indent
   set: {!}.indent = {0}
 
   string IndentChars { get; set; }   get: {!}.getIndentChars()
   set: {!}.setIndentChars({0})
   get: {!}.indentChars
   set: {!}.indentChars = {0}
    get: {!}.indentChars
   set: {!}.indentChars = {0}