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

C# class or member	Java analog	Python analog	PHP analog	JavaScript analog	Rust analog
delegate Action<T>	Action (our service class)
void call(T)	{!}.call({0})
class AppDomain	ignored in Java	ignored 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 : Exception	java.lang.Exception	Exception	RuntimeException	Error
class ArgumentException : Exception	java.lang.IllegalArgumentException	Exception	InvalidArgumentException	Error
class ArgumentNullException : Exception	java.lang.IllegalArgumentException	Exception	InvalidArgumentException	Error
class ArgumentOutOfRangeException : Exception	java.lang.IndexOutOfBoundsException	Exception	InvalidArgumentException	Error
static class Array
void Clear(?)	Generate code by inner hardcode procedure
void Copy(?)	model by operator 'for' in code	Utils.copyArray({0}, {1}, {2}, {3}, {4})		model by operator 'for' in code
void Copy(?)	model by operator 'for' in code	Utils.copyArray({0}, 0, {1}, 0, {2})		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		MyList	Array
class Assembly	ignored in Java	ignored in Python	ignored in PHP	ignored in JS	ignored 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 Assert	org.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 Attribute	warning: Inherited class ignored in Java	warning: Inherited class ignored in Python	warning: Inherited class ignored in PHP	warning: 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}+4], 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)
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}+4], 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)
class bool	boolean / java.lang.Boolean	bool	bool	Boolean	bool
static class Buffer
void BlockCopy(byte[], int, byte[], int, int)	model by operator 'for' in code
int ByteLength(byte[])	{0}.size()
class byte	byte / java.lang.Byte	int	int	Number	u8
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 CancelEventArgs	CancelEventArgs (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 CancelEventHandler	CancelEventHandler (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 char	char / java.lang.Character	str	string	String	char
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 CompressionMode	boolean	str	str	String	i32
static Compress	true	'w'	'w'	'w'	0
static Decompress	false	'r'	'r'	'r'	1
static class Console	System.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 ConstructorInfo	java.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 DateTime	java.time.LocalDateTime	datetime.datetime (import datetime)	DateTime	Date
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");	{!}.toDateString()
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 DayOfWeek	java.time.DayOfWeek	int	int	int
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 : Stream	DeflateStream (our service class)	warning this is not exists in real Python (import zlib)		Stream (our service class)
.ctor(Stream, bool, CompressionMode)	new DeflateStream({0}, {2}, {1})
.ctor(Stream, CompressionMode, *)	new DeflateStream({0}, {1}, false)			Utils.deflateWrapper({0}, {1})
static byte[] CompressDeflate(byte[])		zlib.compress({0}, -15)		Utils.compressDeflate({0})
static byte[] CompressZlib(byte[])		zlib.compress({0})		Utils.compressZlib({0})
static byte[] DecompressDeflate(byte[])		zlib.decompress({0}, -15)		Utils.decompressDeflate({0})
static byte[] DecompressZlib(byte[])		zlib.decompress({0})		Utils.decompressZlib({0})
class Dictionary<K, V> : IDictionary	java.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 DictionaryEntry	java.util.Map.Entry	tuple	KeyValuePair (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 DirectoryInfo	java.io.File	pathlib.Path (import pathlib)		DirectoryInfo (our service class)
DateTime CreationTime { get; }	get: Utils.getFileCreationTime({!})	get: Utils.getDateTimeFromCtime(os.path.getmtime({!}.absolute())) (import os)
bool Exists { get; }	get: {!}.exists()	get: {!}.is_dir()		get: {!}.exists()
string FullName { get; }	get: {!}.getAbsolutePath()	get: {!}.absolute()		get: {!}.fullname
DateTime LastWriteTime { get; }	get: Utils.getFileModifiedTime({!})	get: Utils.getDateTimeFromCtime(os.path.getctime({!}.absolute())) (import os)
string Name { get; }	get: {!}.getPath()	get: {!}.name		get: {!}.name
.ctor(string)	.ctor({0})	.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 double	double / java.lang.Double	float	float	Number	f64
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 Encoding	java.nio.charset.Charset	str	string	String	ignored 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		Array.from(Utils.decodeString({!}, {0}, 0, -1))
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})			Utils.getCharsetByName({0})
static Encoding GetEncoding(int)	Utils.getCharsetByName("windows-" + {0})
class EndOfStreamException : Exception	java.io.EOFException	Exception	Exception	Error
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 Environment	ignored in Java
string static MachineName	Utils.getMachineName()
string static UserName	System.getProperty("user.name")
class EventArgs	java.lang.Object	object		Object
EventArgs static Empty	Utils.EMPTYEVENTARGS	None		null
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 Exception	java.lang.Exception	Exception	Exception	Error	NString
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)		fs.copyFile({0}, {1})
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 FileAccess	java.lang.String	str	string	string	str
static Read	"r"	'r'	'r'	"r"	"r"
static ReadWrite	"rw"	'rw'	'rw'	"rw"	"rw"
static Write	"w"	'w'	'w'	"w"	"w"
class FileInfo	java.io.File	pathlib.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 FileMode	java.lang.String	str	string	string	str
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 : Exception	java.io.FileNotFoundException	FileNotFoundError	Exception	Error
enum FileShare	java.lang.String	str	string	String
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 : Stream	FileStream (our service class)	FileStream (our service class)	resource	FileStream (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 float	float / java.lang.Float	float	float	Number	f32
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 : Exception	java.lang.NumberFormatException	Exception	Exception	Error
delegate Func<T, R>	Func (our service class)
R call(T)	{!}.call({0})
class GC	java.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 Group	RegexGroupWrapper (our service class)
int Index	{!}.index
int Length	{!}.length
string Value	{!}.value
struct Guid	java.util.UUID	uuid.UUID (import uuid)		String
Guid static Empty	Utils.EMPTYUUID	Utils.EMPTYUUID		"00000000-0000-0000-0000-000000000000"
.ctor(string)	java.util.UUID.fromString({0})	.ctor({0})		{0}
.ctor(byte[])	Utils.getUUIDFromBytes({0})	uuid.UUID(bytes=bytes({0}))		Utils.bytesToUUID({0})
.ctor()	new java.util.UUID(0, 0)	uuid.UUID('{00000000-0000-0000-0000-000000000000}')		"00000000-0000-0000-0000-000000000000"
bool Equals(object)	{!}.equals({0})	({!} == {0})		{!} == {0}
byte[] ToByteArray()	Utils.getBytesFromUUID({!})	{!}.bytes
static Guid NewGuid()	java.util.UUID.randomUUID()	uuid.uuid4()		Utils.createUUID()
class GZipStream : Stream	GZipStream (our service class)	gzip.GzipFile (import gzip)	resource	Stream (our service class)	GzStream (our service class)
.ctor(Stream, CompressionMode, *)	new GZipStream({0}, {1})	Stream(gzip.GzipFile(fileobj={0}.getstream(), mode={1}))	Utils.GzipWrapper({0}, {1})	Utils.gzipWrapper({0}, {1})	GzStream::new({0}, {1})
static byte[] Compress(byte[])				Utils.compressGzip({0})
static byte[] Decompress(byte[])				Utils.decompressGzip({0})
class Hashtable : ICollection [DictionaryEntry]	java.util.HashMap	dict	Dictionary (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> : Dictionary	java.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 ICloneable	java.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 IDisposable	java.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 : Exception	java.lang.IndexOutOfBoundsException	Exception	OutOfRangeException	Error
class int	int / java.lang.Integer	int	int	Number	i32
int static MaxValue	Integer.MAX_VALUE	2147483647		2147483647
int static MinValue	Integer.MIN_VALUE	-2147483648		-2147483648
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 : Exception	java.lang.UnsupportedOperationException	Exception	Exception	Error
class IOException : Exception	java.io.IOException	Exception	Exception	Error
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})	({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 long	long / java.lang.Long	int	float	warning: JavaScript not support long, use int	i64
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 Match	RegexMatchWrapper (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 Math	java.lang.Math	math (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 : Stream	MemoryStream (our service class)	MemoryStream (our service class)	resource	MemoryStream (our service class)	MemoryStream (our service class)
.ctor(byte[], bool)	new MemoryStream({0})	MemoryStream({0})	Utils.CreateMemoryStream({0})	new MemoryStream({0})	MemoryStream::from_list({0&})
.ctor(byte[], int, int)	new MemoryStream({0}, {1}, {2})	MemoryStream({0}[{1} : ({1} + {2})])		new MemoryStream({0}, {1}, {2})
.ctor(byte[], int, int, bool)	new MemoryStream({0}, {1}, {2})	MemoryStream({0}[{1} : ({1} + {2})])		new MemoryStream({0}, {1}, {2})
.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&})
.ctor(int)	.ctor({0})	.ctor({0})	fopen("php://memory", "w+b")	.ctor({0})	MemoryStream::with_capacity({0})
byte[] ToArray()	{!}.toByteArray()	{!}.toarray()	Utils.GetArrayStream({!})	{!}.toByteArray()	{!}.to_list()
void WriteTo(Stream)	{!}.writeTo({0})	{!}.writeto({0})		{!}.writeTo({0})	{!}.write_to({0})
enum NormalizationForm	java.text.Normalizer.Form	str	Normalizer	String
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 : Exception	java.lang.UnsupportedOperationException	NotImplementedError	Exception	Error
class NotSupportedException : Exception	java.lang.UnsupportedOperationException	Exception	Exception	Error
class NullReferenceException : Exception	java.lang.NullPointerException	Exception	RuntimeException	ReferenceError
class NumberFormatInfo	java.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 NumberStyles	int
static AllowHexSpecifier	512
static Any	511
static HexNumber	515
class object	java.lang.Object	object	stdClass	Object
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 : Exception	java.lang.Exception	Exception	Exception	Error
class OutOfMemoryException : Exception	java.lang.OutOfMemoryError	MemoryError	Exception	Error
class OverflowException : Exception	java.lang.StackOverflowError	OverflowError	OverflowException	Error
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.Path({0}).resolve()	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 : Exception	java.lang.Exception	Exception	Exception	Error
delegate Predicate<T>	Predicate (our service class)
bool call(T)	call
class ProgressChangedEventArgs	ProgressEventArgs (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 ProgressChangedEventHandler	ProgressEventHandler (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 PropertyChangedEventArgs	PropertyChangedEventArgs (our service class)	PropertyChangedEventArgs (our service class)
int PropertyName { get; }	get: {!}.getPropertyName()	get: {!}.propertyName
.ctor(string)	.ctor({0})	.ctor({0})
delegate PropertyChangedEventHandler	PropertyChangedEventHandler (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 Random	java.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 Regex	java.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 RegexOptions	java.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 sbyte	byte / java.lang.Byte	int	int	Number	i8
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 : Exception	java.lang.SecurityException	Exception	Exception	Error
enum SeekOrigin	int	int	int	int	int
static Begin	0	0	SEEK_SET	0	0
static Current	1	1	SEEK_CUR	1	1
static End	2	2	SEEK_END	2	2
class short	short / java.lang.Short	int	int	Number	i16
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> : Dictionary	java.util.HashMap<K, V>	dict<K, V>	warning: SortedDictionary not supported in PHP, use simple Dictionary	warning: SortedDictionary not supported in JS, use simple Dictionary	warning: 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 : Exception	java.lang.StackOverflowError	StackOverflowError	Exception	Error
class Stopwatch	Stopwatch (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 Stream	Stream (our service class)	Stream (our service class)	resource	Stream (our service class)	IStream (our service class)
bool CanRead { get; }	get: {!}.canRead()	get: {!}.readable		get: {!}.canRead()
bool CanSeek { get; }	get: {!}.canSeek()	get: {!}.seekable		get: {!}.canSeek()
bool CanWrite { get; }	get: {!}.canWrite()	get: {!}.writable		get: {!}.canWrite()
long Length { get; }	get: {!}.length()	get: {!}.length	get: Utils.GetLengthStream({!})	get: {!}.length	get: {!}.len()
long Position { get; set; }	get: {!}.getPosition() set: {!}.setPosition({0})	get: {!}.position set: {!}.position = {0}	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})	{!}.read({0}, {1}, {2})	Utils.ReadStream({!}, {0}, {1}, {2})	{!}.read({0}, {1}, {2})	{!}.read({0}, {1}, {2})
int ReadByte()	{!}.read()	{!}.readbyte()	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})	{!}.length = {0}	ftruncate({!}, {0})	{!}.setLength({0})	{!}.set_len({0})
int Write(byte[], int, int)	{!}.write({0}, {1}, {2})	{!}.write({0}, {1}, {2})	Utils.WriteStream({!}, {0}, {1}, {2})	{!}.write({0}, {1}, {2})	{!}.write({0&}, {1}, {2})
void WriteByte(byte)	{!}.write({0})	{!}.writebyte({0})	Utils.WriteByteStream({!}, {0})	{!}.writeByte({0})	{!}.write_byte({0})
class StreamReader : TextReader	java.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.String	str	string	String	NString (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})		new String({0}.slice({1}, {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})	Utils.indexOfAny({!}, {0}, {1=0}, {2=0})		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 StringBuilder	java.lang.StringBuilder	io.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(int)	new StringBuilder()	io.StringIO()		new StringBuilder()	StringBuilder::null()
.ctor(string)	.ctor({0})	Utils.newStringIO({0})	.ctor({0})	.ctor({0})	StringBuilder::from_string({0&})
StringBuilder Append(char, int)	Utils.append({!}, {0}, {1})
StringBuilder Append(?)	{!}.append({0})	print({0}, end="", file={!})	{!}->Append({0})	{!}.append({0})	Model constant format string by operators
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 StringComparison	boolean	bool	bool	boolean	bool
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 : TextReader	java.io.StringReader	io.StringIO (import io)
.ctor(string)	new java.io.BufferedReader(new java.io.StringReader({0}))	.ctor({0})
enum StringSplitOptions	boolean	bool	bool	Boolean	bool
static None	false	False	FALSE	false	false
static RemoveEmptyEntries	true	True	TRUE	true	true
class TargetInvocationException : Exception	java.lang.reflect.InvocationTargetException	Exception	Exception	Error
class TextReader : IDisposable	java.io.BufferedReader	io.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 Thread	java.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 ThreadStart	java.lang.Runnable
void call()	{!}.run()
struct TimeSpan	java.time.Duration	datetime.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 Type	java.lang.Class	str		String
string FullName { get; }	get: {!}.getName()
string Name { get; }	get: {!}.getSimpleName()	get: {!}		get: {!}
ConstructorInfo GetConstructor(Type[])	{!}.getDeclaredConstructor({0})
ConstructorInfo[] GetConstructors()	{!}.getDeclaredConstructors()
class uint	int / java.lang.Integer	int	int	Number	u32
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 ulong	long / java.lang.Long	int	float	warning: JavaScript not support long, use int	u64
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 Uri	java.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 string EscapeDataString(string, Encoding)	java.net.URLEncoder.encode({0}, ({1}).name())
static string EscapeDataString(string)	java.net.URLEncoder.encode({0}, "UTF-8")
static string EscapeUriString(string, Encoding)	java.net.URLEncoder.encode({0}, ({1}).name())
static string EscapeUriString(string)	java.net.URLEncoder.encode({0}, "UTF-8")
static bool TryCreate(string, UriKind, out Uri)	Utils.parseUri({0}, {2})
class UriFormatException : Exception	java.net.URISyntaxException	Exception	Exception	Error
enum UriKind	int
static Absolute	1
static Relative	2
static RelativeOrAbsolute	0
class ushort	short / java.lang.Short	int	int	Number	u16
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 WebClient	Webclient (our service class)	WebClient (our service class)		WebClient (our service class)
byte[] DownloadData(Uri)	{!}.downloadData({0})
byte[] DownloadData(string)	{!}.downloadData({0})	{!}.download_data({0})		{!}.downloadData({0})
string DownloadString(string)	{!}.downloadString({0})
string DownloadString(Uri)	{!}.downloadString({0})
byte[] UploadData(string, byte[])	{!}.uploadData({0}, {1})	{!}.upload_data({0}, {1})		{!}.uploadData({0}, {1})
byte[] UploadData(Uri, byte[])	{!}.uploadData({0}, {1})
class XmlAttribute	org.w3c.dom.Node	tuple	DOMAttr	XmlAttribute (our service class)
string InnerText { get; }	get: {!}.getTextContent()	get: {!}[1]	get: {!}->value	get: {!}.value
string LocalName { get; }	get: Utils.getXmlLocalName({!})	get: Utils.getXmlAttrLocalName({!})	get: {!}->name	get: {!}.local_name
string Name { get; }	get: {!}.getNodeName()	get: Utils.getXmlAttrName({!})	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.NamedNodeMap	dict	array	Array
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 XmlDocument	XmlDocumentWrapper (our service class)	xml.etree.ElementTree.Element (import xml.etree)	DOMDocument	XmlDocument (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})	{!} = Utils.parseXmlFromStream({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 : Exception	javax.xml.stream.XMLStreamException	Exception	Exception	Error
class XmlNode	org.w3c.dom.Node	xml.etree.ElementTree.Element (import xml.etree)	DOMElement	XmlNode (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: Utils.getXmlLocalName({!})	get: Utils.GetNameFromNode({!})	get: {!}.local_name
string Name { get; }	get: {!}.getNodeName()	get: Utils.getXmlName({!})	get: Utils.GetNameFromNode({!})	get: {!}.name
XmlNode NextSibling { get; }	get: {!}.getNextSibling()		get: {!}->nextSibling
XmlNode ParentNode { get; }	get: {!}.getParentNode()		get: {!}->parentNode	get: {!}.parent_node
XmlNode PreviousSibling { get; }	get: {!}.getPreviousSibling()		get: {!}->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.NodeList	list	array	Array
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 XmlWriter	XmlWriterWrapper (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()
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=None})	XmlWriterWrapper::CreateToFile({0}, {1=NULL})	XmlWriter.createFile({0}, {1=NULL})
static XmlWriter Create(Stream, *)	new XmlWriterWrapper({0}, {1=null})	XmlWriter.create_stream({0}, {1=None})		XmlWriter.createStream({0}, {1=NULL})
static XmlWriter Create(StringBuilder, *)	new XmlWriterWrapper({0}, {1=null})	XmlWriter.create_string({0}, {1=None})	XmlWriterWrapper::CreateToStringBuilder({0}, {1=NULL})	XmlWriter.createString({0}, {1=NULL})
class XmlWriterSettings	XmlWriterSettings (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}