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

C# class or memberJava analogPython analogPHP analogJavaScript 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 JS
   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
   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
   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
   Type[] GetTypes()   Generate code by inner hardcode procedure   
   static Assembly GetCallingAssembly()   Ignored in Java   Ignored in Python   Ignored in PHP   Ignored in JS
   static Assembly GetEntryAssembly()   Ignored in Java   Ignored in Python   Ignored in PHP   Ignored in JS
   static Assembly GetExecutingAssembly()   Ignored in Java   Ignored in Python   Ignored in PHP   Ignored in JS
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})
   void AreNotEqual(object, object)   org.junit.Assert.assertNotEquals({0}, {1})   self.assertNotEquals({0}, {1})    assert.notEqual({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})
   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})
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.BooleanboolboolBoolean
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.ByteintintNumber
   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
   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)
   void call(object, CancelEventArgs)   {!}.call({0}, {1})   {!}.call({0}, {1})   {!}->call({0}, {1})   {!}.call({0}, {1})
class charchar / java.lang.CharacterstrstringString
   static int GetNumericValue(char)   Character.getNumericValue({0})   
   static bool IsDigit(char)   Character.isDigit({0})   str.isdigit({0})   Utils.IsDigit({0})   Utils.isDigit({0})
   static bool IsLetter(char)   Character.isLetter({0})   str.isalpha({0})   Utils.IsLetter({0})   Utils.isLetter({0})
   static bool IsLetterOrDigit(char)   Character.isLetterOrDigit({0})   str.isalnum({0})   Utils.IsLetterOrDigit({0})   Utils.isLetterOrDigit({0})
   static bool IsLower(char)   Character.isLowerCase({0})   str.islower({0})   Utils.IsLowerCase({0})   Utils.isLowerCase({0})
   static bool IsUpper(char)   Character.isUpperCase({0})   str.isupper({0})   Utils.IsUpperCase({0})   Utils.isUpperCase({0})
   static bool IsWhiteSpace(char)   Utils.isWhitespace({0})   Utils.isWhitespace({0})   Utils.IsWhitespace({0})   Utils.isWhitespace({0})
   static char ToLower(char)   Character.toLowerCase({0})   str.lower({0})   mb_convert_case({0}, MB_CASE_LOWER)   {0}.toLowerCase()
   static char ToUpper(char)   Character.toUpperCase({0})   str.upper({0})   mb_convert_case({0}, MB_CASE_UPPER)   {0}.toUpperCase()
class Collection<T> : IList [T]java.util.ArrayList<T>list<T>MyList (our service class)Array<T>
    .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()
enum CompressionModebooleanstrstrString
    static Compress   true   'w'   'w'   'w'
    static Decompress   false   'r'   'r'   'r'
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
   void Write(?)   System.out.print({0})   print({0}, end="", flush=True)   print({0})   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")
   void WriteLine(?)   System.out.println({0})   print({0}, flush=True)   print({0}."\r\n")   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
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  
   DateTime static MinValue   java.time.LocalDateTime.MIN   datetime.datetime.min  
   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: ({!}.getMonth() + 1)
   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}))  
   DateTime AddHours(int)   {!}.plusHours({0})   ({!} + datetime.timedelta(hours={0}))  
   DateTime AddMinutes(int)   {!}.plusMinutes({0})   ({!} + datetime.timedelta(minutes={0}))  
   DateTime AddMonths(int)   {!}.plusMonths({0})   ({!} + datetime.timedelta(days={0}*30))  
   DateTime AddSeconds(int)   {!}.plusSeconds({0})   ({!} + datetime.timedelta(seconds={0}))  
   DateTime AddYears(int)   {!}.plusYears({0})   ({!} + datetime.timedelta(days={0}*365))  
   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   int.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)
    .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()
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.DoublefloatfloatNumber
   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
   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.CharsetstrstringString
   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"
   byte[] GetBytes(string)   Utils.encodeCharset({!}, {0})   modeled by 'encode', support only utf-8   Utils.EncodeString({!}, {0})   Utils.encodeString({!}, {0})
   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[], *)   Utils.decodeCharset({!}, {0}, {1=0}, {2=-1})   modeled by 'decode', support only utf-8   Utils.DecodeString({!}, {0}, {1=0}, {2=-1})   Utils.decodeString({!}, {0}, {1=0}, {2=-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
   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
   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
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)
   void call(object, T)   {!}.call({0}, {1})   {!}.call({0}, {1})   {!}->call({0}, {1})   {!}.call({0}, {1})
class Exceptionjava.lang.ExceptionExceptionExceptionError
   string Message { get; }   get: {!}.getMessage()   get: {!}.__str__()   get: {!}->getMessage()   get: {!}.message
    .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})
    .ctor()   .ctor()   .ctor()   .ctor()   .ctor()
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.Stringstrstringstring
    static Read   "r"   'r'   'r'   "r"
    static ReadWrite   "rw"   'rw'   'rw'   "rw"
    static Write   "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.Stringstrstringstring
    static Append   "APPEND"   'append'   'append'   "APPEND"
    static Create   "CREATE"   'create'   'create'   "CREATE"
    static CreateNew   "CREATENEW"   'createnew'   'createnew'   "CREATENEW"
    static Open   "OPEN"   'open'   'open'   "OPEN"
    static OpenOrCreate   "OPENORCREATE"   'openorcreate'   'openorcreate'   "OPENORCREATE"
    static 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)
   string Name { get; }   get: {!}.getName()   get: {!}.name    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
class floatfloat / java.lang.FloatfloatfloatNumber
   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
   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)
    .ctor(Stream, CompressionMode, *)   new GZipStream({0}, {1})   gzip.GzipFile(fileobj={0}, mode={1})   Utils.GzipWrapper({0}, {1})   Utils.gzipWrapper({0}, {1})
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>
   int Count { get; }   get: {!}.size()   get: len({!})   get: {!}->count   get: {!}.length
   void Add(T)   {!}.add({0})   {!}.append({0})   {!}->Add({0})   {!}.push({0})
   void Clear()   {!}.clear()   {!}.clear()   {!}->Clear()   {!}.splice(0, {!}.length)
   bool Contains(T)   {!}.contains({0})   {0} in {!}   {!}->Contains({0})   {!}.includes({0})
   IEnumerator<T> GetEnumerator()   {!}.iterator()   {!}.__iter__()   {!}->items   {!}[Symbol.iterator]()
   void Remove(T)   {!}.remove({0})   {!}.remove({0})   {!}->Remove({0})   Utils.removeItem({!}, {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)
   int Count { get; }   get: {!}.size()   get: len({!})   get: {!}->Count()   get: {!}.length
   ICollection<T> Keys { get; }   get: {!}.keySet()   get: {!}.keys()   get: {!}->GetKeys()   get: {!}.keys
   ICollection<T> Values { get; }   get: {!}.values()   get: {!}.values()   get: {!}->GetValues()   get: {!}.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})
   void Add(K, V)   {!}.put({0}, {1})   {!}[{0}] = {1}   {!}->Put({0}, {1})   {!}.put({0}, {1})
   void Clear()   {!}.clear()   {!}.clear()   {!}->Clear()   {!}.clear()
   bool ContainsKey(K)   {!}.containsKey({0})   {0} in {!}   {!}->ContainsKey({0})   {!}.containsKey({0})
   bool ContainsValue(V)   {!}.containsValue({0})   {0} in {!}.values()   {!}->ContainsValue({0})   {!}.containsValue({0})
   IEnumerator<T> GetEnumerator()   {!}.entrySet()   iter({!})   {!}->GetEntries()->items   {!}.entries
   void Remove(K)   {!}.remove({0})   del {!}[{0}]   {!}->Remove({0})   {!}.remove({0})
   bool TryGetValue(K, out V)   Utils.tryGetValue({!}, {0}, {1})   Utils.tryGetValue({!}, {0}, {1})   {!}->TryGetValue({0}, {1})   {!}.tryGetValue({0}, {1})
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>
   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}
   int IndexOf(T)   {!}.indexOf({0})   Utils.indexOfList({!}, {0}, 0)   {!}->IndexOf({0})   {!}.indexOf({0})
   int IndexOf(T, int)   Utils.indexOf({!}, {0}, {1})   Utils.indexOfList({!}, {0}, {1})   {!}->IndexOf({0}, {1})   {!}.indexOf({0}, {1})
   void Insert(int, T)   {!}.add({0}, {1})   {!}.insert({0}, {1})   {!}->Insert({0}, {1})   {!}.splice({0}, 0, {1})
   int LastIndexOf(T, int)   Utils.lastIndexOf({!}, {0}, {1})   Utils.lastIndexOfList({!}, {0}, {1})   {!}->LastIndexOf({0}, {1})   {!}.lastIndexOf({0}, {1})
   int LastIndexOf(T)   {!}.lastIndexOf({0})   Utils.lastIndexOfList({!}, {0}, 0)   {!}->LastIndexOf({0})   {!}.lastIndexOf({0})
   void RemoveAt(int)   {!}.remove({0})   del {!}[{0}]   {!}->RemoveAt({0})   {!}.splice({0}, 1)
class IndexOutOfRangeException : Exceptionjava.lang.IndexOutOfBoundsExceptionExceptionOutOfRangeExceptionError
class intint / java.lang.IntegerintintNumber
   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
   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)
   K Key { get; }   get: {!}.getKey()   get: {!}[0]   get: {!}->key   get: {!}.key
   V Value { get; }   get: {!}.getValue()   get: {!}[1]   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>
   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()
    .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()
   void AddRange(IEnumerable<T>)   Utils.addToArrayList({!}, {0})   {!}.extend({0})   {!}->AddRange({0})   {!}.splice({!}.length, 0, ...{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})
   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})
   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 int
   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
   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)
    .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})
    .ctor()   .ctor()   .ctor()   fopen("php://memory", "w+b")   .ctor()
    .ctor(byte[])   .ctor({0})   .ctor({0})   Utils.CreateMemoryStream({0})   .ctor({0})
   byte[] ToArray()   {!}.toByteArray()   bytearray({!}.getvalue())   Utils.GetArrayStream({!})   {!}.toByteArray()
   void WriteTo(Stream)   {!}.writeTo({0})   shutil.copyfileobj({!}, {0}) (import shutil)  
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()
   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)
   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   
   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.ByteintintNumber
   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
   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)intint
    static Begin   0   io.SEEK_SET   SEEK_SET   0
    static Current   1   io.SEEK_CUR   SEEK_CUR   1
    static End   2   io.SEEK_END   SEEK_END   2
class shortshort / java.lang.ShortintintNumber
   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
   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 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)
   TimeSpan Elapsed { get; }   get: {!}.getElapsed()   get: {!}.elapsed  
   long ElapsedMilliseconds { get; }   get: {!}.getElapsedMilliseconds()   get: {!}.elapsedMilliseconds   get: {!}->GetElapsedMilliseconds()   get: {!}.elapsedMilliseconds
   bool IsRunning { get; }   get: {!}.isRunning()   get: {!}.isrunning   get: {!}->IsRunning()   get: {!}.isRunning
    .ctor()   .ctor()   .ctor()   .ctor()   .ctor()
   void Reset()   {!}.reset()   {!}.reset()   {!}->Reset()   {!}.reset()
   void Start()   {!}.start()   {!}.start()   {!}->Start()   {!}.start()
   void Stop()   {!}.stop()   {!}.stop()   {!}->Stop()   {!}.stop()
   static Stopwatch StartNew()   Utils.startNewStopwatch()   Stopwatch()   new Stopwatch()   new Stopwatch()
class StreamStream (our service class)io.IOBase (import io)resourceStream (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
   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}
   void Close()   {!}.close()   {!}.close()   fclose({!})   {!}.close()
   void Dispose()   {!}.close()   {!}.close()   fclose({!})   {!}.close()
   void Flush()   {!}.flush()   {!}.flush()   fflush({!})   {!}.flush()
   int Read(byte[], int, int)   {!}.read({0}, {1}, {2})   Utils.readIO({!}, {0}, {1}, {2})   Utils.ReadStream({!}, {0}, {1}, {2})   {!}.read({0}, {1}, {2})
   int ReadByte()   {!}.read()   Utils.readByteIO({!})   Utils.ReadByteStream({!})   {!}.readByte()
   long Seek(long, SeekOrigin)   {!}.seek({0}, {1})   {!}.seek({0}, {1})   fseek({!}, {0}, {1})   {!}.seek({0}, {1})
   void SetLength(long)   {!}.setLength({0})   {!}.truncate({0})   ftruncate({!}, {0})   {!}.setLength({0})
   int Write(byte[], int, int)   {!}.write({0}, {1}, {2})   Utils.writeIO({!}, {0}, {1}, {2})   Utils.WriteStream({!}, {0}, {1}, {2})   {!}.write({0}, {1}, {2})
   void WriteByte(byte)   {!}.write({0})   Utils.writeByteIO({!}, {0})   Utils.WriteByteStream({!}, {0})   {!}.writeByte({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.StringstrstringString
   string static Empty   ""   ""   ""   ""
   int Length { get; }   get: {!}.length()   get: len({!})   get: mb_strlen({!})   get: {!}.length
   char this[int] { get; }   get: {!}.charAt({0})   get: {!}[{0}]   get: mb_substr({!}, {0}, 1)   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()
    .ctor(char[])   .ctor({0})   .ctor({0})    .ctor({0})
   int CompareTo(string)   {!}.compareTo({0})    Utils.CompareStrings({!}, {0}, FALSE)   {!}.localeCompare({0})
   bool Contains(string)   ({!}.indexOf({0}) >= 0)   {0} in {!}   Utils.IndexOfString({!}, {0}, 0) >= 0   {!}.includes({0})
   bool EndsWith(string)   {!}.endsWith({0})   {!}.endswith({0})   Utils.EndsWithString({!}, {0}, FALSE)   {!}.endsWith({0})
   bool EndsWith(string, StringComparison)   Utils.endsWithString({!}, {0}, {1})   Utils.endsWithString({!}, {0}, {1})   Utils.EndsWithString({!}, {0}, {1})   Utils.endsWithString({!}, {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
   IEnumerator<T> GetEnumerator()   {!}.toCharArray()   
   int IndexOf(string, int)   {!}.indexOf({0}, {1})   Utils.indexOfList({!}, {0}, {1})   Utils.IndexOfString({!}, {0}, {1})   {!}.indexOf({0}, {1})
   int IndexOf(char)   {!}.indexOf({0})   {!}.find({0})   Utils.IndexOfString({!}, {0})   {!}.indexOf({0})
   int IndexOf(char, int)   {!}.indexOf({0}, {1})   Utils.indexOfList({!}, {0}, {1})   Utils.IndexOfString({!}, {0}, {1})   {!}.indexOf({0}, {1})
   int IndexOf(string)   {!}.indexOf({0})   {!}.find({0})   Utils.IndexOfString({!}, {0})   {!}.indexOf({0})
   int IndexOfAny(char[], *)   Utils.indexOfAny({!}, {0}, {1=0}, {2=0})   
   int LastIndexOf(string)   {!}.lastIndexOf({0})   {!}.rfind({0})   Utils.LastIndexOfString({!}, {0})   {!}.lastIndexOf({0})
   int LastIndexOf(string, int)   {!}.lastIndexOf({0}, {1})   Utils.lastIndexOfList({!}, {0}, {1})   Utils.LastIndexOfString({!}, {0}, {1})   {!}.lastIndexOf({0}, {1})
   int LastIndexOf(char, int)   {!}.lastIndexOf({0}, {1})   Utils.lastIndexOfList({!}, {0}, {1})   Utils.LastIndexOfString({!}, {0}, {1})   {!}.lastIndexOf({0}, {1})
   int LastIndexOf(char)   {!}.lastIndexOf({0})   {!}.rfind({0})   Utils.LastIndexOfString({!}, {0})   {!}.lastIndexOf({0})
   string Normalize(NormalizationForm)   java.text.Normalizer.normalize({!}, {0})   unicodedata.normalize({0}, {!}) (import unicodedata)   normalizer_normalize({!}, {0})   {!}.normalize({0})
   string Normalize()   java.text.Normalizer.normalize({!}, java.text.Normalizer.Form.NFC)   unicodedata.normalize('NFC', {!}) (import unicodedata)   normalizer_normalize({!})   {!}.normalize()
   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})
   string Replace(char, char)   {!}.replace({0}, {1})   {!}.replace({0}, {1})   str_replace({0}, {1}, {!})   Utils.replaceString({!}, {0}, {1})
   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)
   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, 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})
   bool StartsWith(string, StringComparison)   Utils.startsWithString({!}, {0}, {1})   Utils.startsWithString({!}, {0}, {1})   Utils.StartsWithString({!}, {0}, {1})   Utils.startsWithString({!}, {0}, {1})
   string Substring(int, int)   {!}.substring({0}, {0} + {1})   {!}[{0}:{0}+{1}]   mb_substr({!}, {0}, {1})   {!}.substring({0}, {0} + {1})
   string Substring(int)   {!}.substring({0})   {!}[{0}:]   mb_substr({!}, {0})   {!}.substring({0})
   char[] ToCharArray()   {!}.toCharArray()     {!}.split('');
   string ToLower()   {!}.toLowerCase()   {!}.lower()   mb_convert_case({!}, MB_CASE_LOWER)   {!}.toLowerCase()
   string ToUpper()   {!}.toUpperCase()   {!}.upper()   mb_convert_case({!}, MB_CASE_UPPER)   {!}.toUpperCase()
   string Trim()   {!}.trim()   {!}.strip()   trim({!})   {!}.trim()
   string TrimEnd()   Utils.trimEnd({!})   Utils.trimEndString({!})   chop({!})   Utils.trimEndString({!})
   string TrimStart()   Utils.trimStart({!})   Utils.trimStartString({!})   ltrim({!})   Utils.trimStartString({!})
   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)
   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})
   static bool IsNullOrEmpty(string)   Utils.isNullOrEmpty({0})   Utils.isNullOrEmpty({0})   {0} == NULL   Utils.isNullOrEmpty({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)
   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}
   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})
    .ctor()   .ctor()   .ctor()   .ctor()   .ctor()
    .ctor(?)   .ctor({0})   Utils.newStringIO({0})   .ctor({0})   .ctor({0})
   StringBuilder Append(?)   {!}.append({0})   print({0}, end="", file={!})   {!}->Append({0})   {!}.append({0})
   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
   StringBuilder Insert(int, ?)   {!}.insert({0}, {1})   Utils.insertStringIO({!}, {0}, {1})   {!}->Insert({0}, {1})   {!}.insert({0}, {1})
   StringBuilder Remove(int, int)   {!}.delete({0}, {0} + {1})   Utils.removeStringIO({!}, {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})
   StringBuilder Replace(string, string)   Utils.replace({!}, {0}, {1})   Utils.replaceStringIO({!}, {0}, {1})   {!}->Replace({0}, {1})   {!}.replace({0}, {1})
enum StringComparisonbooleanboolboolboolean
    static CurrentCulture   false   False   FALSE   false
    static CurrentCultureIgnoreCase   true   True   TRUE   true
    static InvariantCulture   false   False   FALSE   false
    static InvariantCultureIgnoreCase   true   True   TRUE   true
    static Ordinal   false   False   FALSE   false
    static OrdinalIgnoreCase   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 StringSplitOptionsbooleanboolboolBoolean
    static None   false   False   FALSE   false
    static RemoveEmptyEntries   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.IntegerintintNumber
   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
   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 int
   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
   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.ShortintintNumber
   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
   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}