/Generated/v4.1/Java.Util.cs

// Copyright (C) 2014 dot42

//

// Original filename: Java.Util.cs

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

// 

//     http://www.apache.org/licenses/LICENSE-2.0

// 

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

#pragma warning disable 1717
namespace Java.Util
{
		/// <summary>
		/// <para>An <c> IllegalFormatCodePointException </c> will be thrown if an invalid Unicode code point (defined by Character#isValidCodePoint(int)) is passed as a parameter to a Formatter.</para><para><para>java.lang.RuntimeException </para></para>    
		/// </summary>
		/// <java-name>
		/// java/util/IllegalFormatCodePointException
		/// </java-name>
		[Dot42.DexImport("java/util/IllegalFormatCodePointException", AccessFlags = 33)]
		public partial class IllegalFormatCodePointException : global::Java.Util.IllegalFormatException, global::Java.Io.ISerializable
 /* scope: __dot42__ */ 
		{
				/// <summary>
				/// <para>Constructs a new <c> IllegalFormatCodePointException </c> which is specified by the invalid Unicode code point.</para><para></para>        
				/// </summary>
				[Dot42.DexImport("<init>", "(I)V", AccessFlags = 1)]
				public IllegalFormatCodePointException(int c) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Returns the invalid Unicode code point.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the invalid Unicode code point. </para>
				/// </returns>
				/// <java-name>
				/// getCodePoint
				/// </java-name>
				[Dot42.DexImport("getCodePoint", "()I", AccessFlags = 1)]
				public virtual int GetCodePoint() /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <java-name>
				/// getMessage
				/// </java-name>
				[Dot42.DexImport("getMessage", "()Ljava/lang/String;", AccessFlags = 1)]
				public override string GetMessage() /* MethodBuilder.Create */ 
				{
						return default(string);
				}

				[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
				internal IllegalFormatCodePointException() /* TypeBuilder.AddDefaultConstructor */ 
				{
				}

				/// <summary>
				/// <para>Returns the invalid Unicode code point.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the invalid Unicode code point. </para>
				/// </returns>
				/// <java-name>
				/// getCodePoint
				/// </java-name>
				public int CodePoint
				{
				[Dot42.DexImport("getCodePoint", "()I", AccessFlags = 1)]
						get{ return GetCodePoint(); }
				}

		}

		/// <summary>
		/// <para>AbstractSequentialList is an abstract implementation of the List interface. This implementation does not support adding. A subclass must implement the abstract method listIterator().</para><para><para>1.2 </para></para>    
		/// </summary>
		/// <java-name>
		/// java/util/AbstractSequentialList
		/// </java-name>
		[Dot42.DexImport("java/util/AbstractSequentialList", AccessFlags = 1057, Signature = "<E:Ljava/lang/Object;>Ljava/util/AbstractList<TE;>;")]
		public abstract partial class AbstractSequentialList<E> : global::Java.Util.AbstractList<E>
 /* scope: __dot42__ */ 
		{
				/// <summary>
				/// <para>Constructs a new instance of this AbstractSequentialList. </para>        
				/// </summary>
				[Dot42.DexImport("<init>", "()V", AccessFlags = 4)]
				protected internal AbstractSequentialList() /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Inserts the specified object into this List at the specified location. The object is inserted before any previous element at the specified location. If the location is equal to the size of this List, the object is added at the end. </para><para>Concrete implementations that would like to support the add functionality must override this method.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// add
				/// </java-name>
				[Dot42.DexImport("add", "(ILjava/lang/Object;)V", AccessFlags = 1, Signature = "(ITE;)V")]
				public override void Add(int location, E @object) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Inserts the objects in the specified Collection at the specified location in this List. The objects are added in the order they are returned from the collection's iterator.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para><c> true </c> if this List is modified, <c> false </c> otherwise. </para>
				/// </returns>
				/// <java-name>
				/// addAll
				/// </java-name>
				[Dot42.DexImport("addAll", "(ILjava/util/Collection;)Z", AccessFlags = 1, Signature = "(ILjava/util/Collection<+TE;>;)Z")]
				public override bool AddAll(int location, global::Java.Util.ICollection<E> collection) /* MethodBuilder.Create */ 
				{
						return default(bool);
				}

				/// <summary>
				/// <para>Returns the element at the specified location in this list.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the element at the specified index. </para>
				/// </returns>
				/// <java-name>
				/// get
				/// </java-name>
				[Dot42.DexImport("get", "(I)Ljava/lang/Object;", AccessFlags = 1, Signature = "(I)TE;")]
				public override E Get(int location) /* MethodBuilder.Create */ 
				{
						return default(E);
				}

				/// <summary>
				/// <para>Returns an iterator on the elements of this list. The elements are iterated in the same order as they occur in the list.</para><para><para>Iterator </para></para>        
				/// </summary>
				/// <returns>
				/// <para>an iterator on the elements of this list. </para>
				/// </returns>
				/// <java-name>
				/// iterator
				/// </java-name>
				[Dot42.DexImport("iterator", "()Ljava/util/Iterator;", AccessFlags = 1, Signature = "()Ljava/util/Iterator<TE;>;")]
				public override global::Java.Util.IIterator<E> Iterator() /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IIterator<E>);
				}

				/// <summary>
				/// <para>Returns a list iterator on the elements of this list. The elements are iterated in the same order as they occur in the list. The iteration starts at the specified location.</para><para><para>ListIterator </para></para>        
				/// </summary>
				/// <returns>
				/// <para>a ListIterator on the elements of this list. </para>
				/// </returns>
				/// <java-name>
				/// listIterator
				/// </java-name>
				[Dot42.DexImport("listIterator", "(I)Ljava/util/ListIterator;", AccessFlags = 1025, Signature = "(I)Ljava/util/ListIterator<TE;>;")]
				public override global::Java.Util.IListIterator<E> ListIterator(int location) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IListIterator<E>);
				}

				/// <summary>
				/// <para>Removes the object at the specified location from this list.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the removed object. </para>
				/// </returns>
				/// <java-name>
				/// remove
				/// </java-name>
				[Dot42.DexImport("remove", "(I)Ljava/lang/Object;", AccessFlags = 1, Signature = "(I)TE;")]
				public override E Remove(int location) /* MethodBuilder.Create */ 
				{
						return default(E);
				}

				/// <summary>
				/// <para>Replaces the element at the specified location in this list with the specified object.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the previous element at the index. </para>
				/// </returns>
				/// <java-name>
				/// set
				/// </java-name>
				[Dot42.DexImport("set", "(ILjava/lang/Object;)Ljava/lang/Object;", AccessFlags = 1, Signature = "(ITE;)TE;")]
				public override E Set(int location, E @object) /* MethodBuilder.Create */ 
				{
						return default(E);
				}

		}

		/// <summary>
		/// <para><c> Collections </c> contains static methods which operate on <c> Collection </c> classes.</para><para><para>1.2 </para></para>    
		/// </summary>
		/// <java-name>
		/// java/util/Collections
		/// </java-name>
		[Dot42.DexImport("java/util/Collections", AccessFlags = 33)]
		public partial class Collections
 /* scope: __dot42__ */ 
		{
				/// <summary>
				/// <para>An empty immutable instance of List. </para>        
				/// </summary>
				/// <java-name>
				/// EMPTY_LIST
				/// </java-name>
				[Dot42.DexImport("EMPTY_LIST", "Ljava/util/List;", AccessFlags = 25)]
				public static readonly global::Java.Util.IList<object> EMPTY_LIST;
				/// <summary>
				/// <para>An empty immutable instance of Set. </para>        
				/// </summary>
				/// <java-name>
				/// EMPTY_SET
				/// </java-name>
				[Dot42.DexImport("EMPTY_SET", "Ljava/util/Set;", AccessFlags = 25)]
				public static readonly global::Java.Util.ISet<object> EMPTY_SET;
				/// <summary>
				/// <para>An empty immutable instance of Map. </para>        
				/// </summary>
				/// <java-name>
				/// EMPTY_MAP
				/// </java-name>
				[Dot42.DexImport("EMPTY_MAP", "Ljava/util/Map;", AccessFlags = 25)]
				public static readonly global::Java.Util.IMap<object, object> EMPTY_MAP;
				[Dot42.DexImport("<init>", "()V", AccessFlags = 0)]
				internal Collections() /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Performs a binary search for the specified element in the specified sorted list. The list needs to be already sorted in natural sorting order. Searching in an unsorted array has an undefined result. It's also undefined which element is found if there are multiple occurrences of the same element.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the non-negative index of the element, or a negative index which is the <c> -index - 1 </c> where the element would be inserted </para>
				/// </returns>
				/// <java-name>
				/// binarySearch
				/// </java-name>
				[Dot42.DexImport("binarySearch", "(Ljava/util/List;Ljava/lang/Object;)I", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/List<+Ljava/lang/Comparable<-TT;>;>;TT;)I")]
				public static int BinarySearch<T>(global::Java.Util.IList<global::System.IComparable<T>> list, T @object) /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <summary>
				/// <para>Performs a binary search for the specified element in the specified sorted list using the specified comparator. The list needs to be already sorted according to the comparator passed. Searching in an unsorted array has an undefined result. It's also undefined which element is found if there are multiple occurrences of the same element.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the non-negative index of the element, or a negative index which is the <c> -index - 1 </c> where the element would be inserted. </para>
				/// </returns>
				/// <java-name>
				/// binarySearch
				/// </java-name>
				[Dot42.DexImport("binarySearch", "(Ljava/util/List;Ljava/lang/Object;Ljava/util/Comparator;)I", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/List<+TT;>;TT;Ljava/util/Comparator<-TT;>;)I")]
				public static int BinarySearch<T>(global::Java.Util.IList<T> list, T @object, global::Java.Util.IComparator<T> comparator) /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <summary>
				/// <para>Copies the elements from the source list to the destination list. At the end both lists will have the same objects at the same index. If the destination array is larger than the source list, the elements in the destination list with <c> index &gt;= source.size() </c> will be unchanged.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// copy
				/// </java-name>
				[Dot42.DexImport("copy", "(Ljava/util/List;Ljava/util/List;)V", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/List<-TT;>;Ljava/util/List<+TT;>;)V")]
				public static void Copy<T>(global::Java.Util.IList<T> destination, global::Java.Util.IList<T> source) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Returns an <c> Enumeration </c> on the specified collection.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>an Enumeration. </para>
				/// </returns>
				/// <java-name>
				/// enumeration
				/// </java-name>
				[Dot42.DexImport("enumeration", "(Ljava/util/Collection;)Ljava/util/Enumeration;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/Collection<TT;>;)Ljava/util/Enumeration<TT;>;")]
				public static global::Java.Util.IEnumeration<T> Enumeration<T>(global::Java.Util.ICollection<T> collection) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IEnumeration<T>);
				}

				/// <summary>
				/// <para>Fills the specified list with the specified element.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// fill
				/// </java-name>
				[Dot42.DexImport("fill", "(Ljava/util/List;Ljava/lang/Object;)V", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/List<-TT;>;TT;)V")]
				public static void Fill<T>(global::Java.Util.IList<T> list, T @object) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Searches the specified collection for the maximum element.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the maximum element in the Collection. </para>
				/// </returns>
				/// <java-name>
				/// max
				/// </java-name>
				[Dot42.DexImport("max", "(Ljava/util/Collection;)Ljava/lang/Object;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;:Ljava/lang/Comparable<-TT;>;>(Ljava/util/Collection<+TT;>;)" +
    "TT;")]
				public static T Max<T>(global::Java.Util.ICollection<T> collection) /* MethodBuilder.Create */ 
				{
						return default(T);
				}

				/// <summary>
				/// <para>Searches the specified collection for the maximum element using the specified comparator.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the maximum element in the Collection. </para>
				/// </returns>
				/// <java-name>
				/// max
				/// </java-name>
				[Dot42.DexImport("max", "(Ljava/util/Collection;Ljava/util/Comparator;)Ljava/lang/Object;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/Collection<+TT;>;Ljava/util/Comparator<-TT;>;)T" +
    "T;")]
				public static T Max<T>(global::Java.Util.ICollection<T> collection, global::Java.Util.IComparator<T> comparator) /* MethodBuilder.Create */ 
				{
						return default(T);
				}

				/// <summary>
				/// <para>Searches the specified collection for the minimum element.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the minimum element in the collection. </para>
				/// </returns>
				/// <java-name>
				/// min
				/// </java-name>
				[Dot42.DexImport("min", "(Ljava/util/Collection;)Ljava/lang/Object;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;:Ljava/lang/Comparable<-TT;>;>(Ljava/util/Collection<+TT;>;)" +
    "TT;")]
				public static T Min<T>(global::Java.Util.ICollection<T> collection) /* MethodBuilder.Create */ 
				{
						return default(T);
				}

				/// <summary>
				/// <para>Searches the specified collection for the minimum element using the specified comparator.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the minimum element in the collection. </para>
				/// </returns>
				/// <java-name>
				/// min
				/// </java-name>
				[Dot42.DexImport("min", "(Ljava/util/Collection;Ljava/util/Comparator;)Ljava/lang/Object;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/Collection<+TT;>;Ljava/util/Comparator<-TT;>;)T" +
    "T;")]
				public static T Min<T>(global::Java.Util.ICollection<T> collection, global::Java.Util.IComparator<T> comparator) /* MethodBuilder.Create */ 
				{
						return default(T);
				}

				/// <summary>
				/// <para>Returns a list containing the specified number of the specified element. The list cannot be modified. The list is serializable.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a list containing <c> length </c> copies of the element. </para>
				/// </returns>
				/// <java-name>
				/// nCopies
				/// </java-name>
				[Dot42.DexImport("nCopies", "(ILjava/lang/Object;)Ljava/util/List;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(ITT;)Ljava/util/List<TT;>;")]
				public static global::Java.Util.IList<T> NCopies<T>(int length, T @object) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IList<T>);
				}

				/// <summary>
				/// <para>Modifies the specified <c> List </c> by reversing the order of the elements.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// reverse
				/// </java-name>
				[Dot42.DexImport("reverse", "(Ljava/util/List;)V", AccessFlags = 9, Signature = "(Ljava/util/List<*>;)V")]
				public static void Reverse(global::Java.Util.IList<object> list) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>A comparator which reverses the natural order of the elements. The <c> Comparator </c> that's returned is Serializable.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a <c> Comparator </c> instance. </para>
				/// </returns>
				/// <java-name>
				/// reverseOrder
				/// </java-name>
				[Dot42.DexImport("reverseOrder", "()Ljava/util/Comparator;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>()Ljava/util/Comparator<TT;>;")]
				public static global::Java.Util.IComparator<T> ReverseOrder<T>() /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IComparator<T>);
				}

				/// <summary>
				/// <para>Returns a Comparator that reverses the order of the <c> Comparator </c> passed. If the <c> Comparator </c> passed is <c> null </c> , then this method is equivalent to reverseOrder(). </para><para>The <c> Comparator </c> that's returned is Serializable if the <c> Comparator </c> passed is serializable or <c> null </c> .</para><para><para>1.5 </para></para>        
				/// </summary>
				/// <returns>
				/// <para>a <c> Comparator </c> instance. </para>
				/// </returns>
				/// <java-name>
				/// reverseOrder
				/// </java-name>
				[Dot42.DexImport("reverseOrder", "(Ljava/util/Comparator;)Ljava/util/Comparator;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/Comparator<TT;>;)Ljava/util/Comparator<TT;>;")]
				public static global::Java.Util.IComparator<T> ReverseOrder<T>(global::Java.Util.IComparator<T> c) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IComparator<T>);
				}

				/// <summary>
				/// <para>Moves every element of the list to a random new position in the list.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// shuffle
				/// </java-name>
				[Dot42.DexImport("shuffle", "(Ljava/util/List;)V", AccessFlags = 9, Signature = "(Ljava/util/List<*>;)V")]
				public static void Shuffle(global::Java.Util.IList<object> list) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Moves every element of the list to a random new position in the list using the specified random number generator.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// shuffle
				/// </java-name>
				[Dot42.DexImport("shuffle", "(Ljava/util/List;Ljava/util/Random;)V", AccessFlags = 9, Signature = "(Ljava/util/List<*>;Ljava/util/Random;)V")]
				public static void Shuffle(global::Java.Util.IList<object> list, global::System.Random random) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Returns a set containing the specified element. The set cannot be modified. The set is serializable.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a set containing the element. </para>
				/// </returns>
				/// <java-name>
				/// singleton
				/// </java-name>
				[Dot42.DexImport("singleton", "(Ljava/lang/Object;)Ljava/util/Set;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(TE;)Ljava/util/Set<TE;>;")]
				public static global::Java.Util.ISet<E> Singleton<E>(E @object) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISet<E>);
				}

				/// <summary>
				/// <para>Returns a list containing the specified element. The list cannot be modified. The list is serializable.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a list containing the element. </para>
				/// </returns>
				/// <java-name>
				/// singletonList
				/// </java-name>
				[Dot42.DexImport("singletonList", "(Ljava/lang/Object;)Ljava/util/List;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(TE;)Ljava/util/List<TE;>;")]
				public static global::Java.Util.IList<E> SingletonList<E>(E @object) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IList<E>);
				}

				/// <summary>
				/// <para>Returns a Map containing the specified key and value. The map cannot be modified. The map is serializable.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a Map containing the key and value. </para>
				/// </returns>
				/// <java-name>
				/// singletonMap
				/// </java-name>
				[Dot42.DexImport("singletonMap", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;", AccessFlags = 9, Signature = "<K:Ljava/lang/Object;V:Ljava/lang/Object;>(TK;TV;)Ljava/util/Map<TK;TV;>;")]
				public static global::Java.Util.IMap<K, V> SingletonMap<K, V>(K key, V value) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IMap<K, V>);
				}

				/// <summary>
				/// <para>Sorts the specified list in ascending natural order. The algorithm is stable which means equal elements don't get reordered.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// sort
				/// </java-name>
				[Dot42.DexImport("sort", "(Ljava/util/List;)V", AccessFlags = 9, Signature = "<T::Ljava/lang/Comparable<-TT;>;>(Ljava/util/List<TT;>;)V")]
				public static void Sort<T>(global::Java.Util.IList<T> list) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Sorts the specified list using the specified comparator. The algorithm is stable which means equal elements don't get reordered.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// sort
				/// </java-name>
				[Dot42.DexImport("sort", "(Ljava/util/List;Ljava/util/Comparator;)V", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/List<TT;>;Ljava/util/Comparator<-TT;>;)V")]
				public static void Sort<T>(global::Java.Util.IList<T> list, global::Java.Util.IComparator<T> comparator) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Swaps the elements of list <c> list </c> at indices <c> index1 </c> and <c> index2 </c> .</para><para><para>1.4 </para></para>        
				/// </summary>
				/// <java-name>
				/// swap
				/// </java-name>
				[Dot42.DexImport("swap", "(Ljava/util/List;II)V", AccessFlags = 9, Signature = "(Ljava/util/List<*>;II)V")]
				public static void Swap(global::Java.Util.IList<object> list, int index1, int index2) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Replaces all occurrences of Object <c> obj </c> in <c> list </c> with <c> newObj </c> . If the <c> obj </c> is <c> null </c> , then all occurrences of <c> null </c> are replaced with <c> newObj </c> .</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>true, if at least one occurrence of <c> obj </c> has been found in <c> list </c> . </para>
				/// </returns>
				/// <java-name>
				/// replaceAll
				/// </java-name>
				[Dot42.DexImport("replaceAll", "(Ljava/util/List;Ljava/lang/Object;Ljava/lang/Object;)Z", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/List<TT;>;TT;TT;)Z")]
				public static bool ReplaceAll<T>(global::Java.Util.IList<T> list, T obj, T obj2) /* MethodBuilder.Create */ 
				{
						return default(bool);
				}

				/// <summary>
				/// <para>Rotates the elements in <c> list </c> by the distance <c> dist </c> </para><para>e.g. for a given list with elements [1, 2, 3, 4, 5, 6, 7, 8, 9, 0], calling rotate(list, 3) or rotate(list, -7) would modify the list to look like this: [8, 9, 0, 1, 2, 3, 4, 5, 6, 7]</para><para></para>        
				/// </summary>
				/// <java-name>
				/// rotate
				/// </java-name>
				[Dot42.DexImport("rotate", "(Ljava/util/List;I)V", AccessFlags = 9, Signature = "(Ljava/util/List<*>;I)V")]
				public static void Rotate(global::Java.Util.IList<object> lst, int dist) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Searches the <c> list </c> for <c> sublist </c> and returns the beginning index of the first occurrence. </para><para>-1 is returned if the <c> sublist </c> does not exist in <c> list </c> .</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the beginning index of the first occurrence of <c> sublist </c> in <c> list </c> , or -1. </para>
				/// </returns>
				/// <java-name>
				/// indexOfSubList
				/// </java-name>
				[Dot42.DexImport("indexOfSubList", "(Ljava/util/List;Ljava/util/List;)I", AccessFlags = 9, Signature = "(Ljava/util/List<*>;Ljava/util/List<*>;)I")]
				public static int IndexOfSubList(global::Java.Util.IList<object> list, global::Java.Util.IList<object> sublist) /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <summary>
				/// <para>Searches the <c> list </c> for <c> sublist </c> and returns the beginning index of the last occurrence. </para><para>-1 is returned if the <c> sublist </c> does not exist in <c> list </c> .</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the beginning index of the last occurrence of <c> sublist </c> in <c> list </c> , or -1. </para>
				/// </returns>
				/// <java-name>
				/// lastIndexOfSubList
				/// </java-name>
				[Dot42.DexImport("lastIndexOfSubList", "(Ljava/util/List;Ljava/util/List;)I", AccessFlags = 9, Signature = "(Ljava/util/List<*>;Ljava/util/List<*>;)I")]
				public static int LastIndexOfSubList(global::Java.Util.IList<object> list, global::Java.Util.IList<object> sublist) /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <summary>
				/// <para>Returns an <c> ArrayList </c> with all the elements in the <c>       enumeration </c> . The elements in the returned <c> ArrayList </c> are in the same order as in the <c> enumeration </c> .</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>an <c> ArrayList </c> from <c> enumeration </c> . </para>
				/// </returns>
				/// <java-name>
				/// list
				/// </java-name>
				[Dot42.DexImport("list", "(Ljava/util/Enumeration;)Ljava/util/ArrayList;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/Enumeration<TT;>;)Ljava/util/ArrayList<TT;>;")]
				public static global::Java.Util.ArrayList<T> List<T>(global::Java.Util.IEnumeration<T> enumeration) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ArrayList<T>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified collection which synchronizes all access to the collection.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a synchronized Collection. </para>
				/// </returns>
				/// <java-name>
				/// synchronizedCollection
				/// </java-name>
				[Dot42.DexImport("synchronizedCollection", "(Ljava/util/Collection;)Ljava/util/Collection;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/Collection<TT;>;)Ljava/util/Collection<TT;>;")]
				public static global::Java.Util.ICollection<T> SynchronizedCollection<T>(global::Java.Util.ICollection<T> collection) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ICollection<T>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified List which synchronizes all access to the List.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a synchronized List. </para>
				/// </returns>
				/// <java-name>
				/// synchronizedList
				/// </java-name>
				[Dot42.DexImport("synchronizedList", "(Ljava/util/List;)Ljava/util/List;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/List<TT;>;)Ljava/util/List<TT;>;")]
				public static global::Java.Util.IList<T> SynchronizedList<T>(global::Java.Util.IList<T> list) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IList<T>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified map which synchronizes all access to the map.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a synchronized Map. </para>
				/// </returns>
				/// <java-name>
				/// synchronizedMap
				/// </java-name>
				[Dot42.DexImport("synchronizedMap", "(Ljava/util/Map;)Ljava/util/Map;", AccessFlags = 9, Signature = "<K:Ljava/lang/Object;V:Ljava/lang/Object;>(Ljava/util/Map<TK;TV;>;)Ljava/util/Map" +
    "<TK;TV;>;")]
				public static global::Java.Util.IMap<K, V> SynchronizedMap<K, V>(global::Java.Util.IMap<K, V> map) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IMap<K, V>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified set which synchronizes all access to the set.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a synchronized set. </para>
				/// </returns>
				/// <java-name>
				/// synchronizedSet
				/// </java-name>
				[Dot42.DexImport("synchronizedSet", "(Ljava/util/Set;)Ljava/util/Set;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(Ljava/util/Set<TE;>;)Ljava/util/Set<TE;>;")]
				public static global::Java.Util.ISet<E> SynchronizedSet<E>(global::Java.Util.ISet<E> set) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISet<E>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified sorted map which synchronizes all access to the sorted map.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a synchronized sorted map. </para>
				/// </returns>
				/// <java-name>
				/// synchronizedSortedMap
				/// </java-name>
				[Dot42.DexImport("synchronizedSortedMap", "(Ljava/util/SortedMap;)Ljava/util/SortedMap;", AccessFlags = 9, Signature = "<K:Ljava/lang/Object;V:Ljava/lang/Object;>(Ljava/util/SortedMap<TK;TV;>;)Ljava/ut" +
    "il/SortedMap<TK;TV;>;")]
				public static global::Java.Util.ISortedMap<K, V> SynchronizedSortedMap<K, V>(global::Java.Util.ISortedMap<K, V> map) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISortedMap<K, V>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified sorted set which synchronizes all access to the sorted set.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a synchronized sorted set. </para>
				/// </returns>
				/// <java-name>
				/// synchronizedSortedSet
				/// </java-name>
				[Dot42.DexImport("synchronizedSortedSet", "(Ljava/util/SortedSet;)Ljava/util/SortedSet;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(Ljava/util/SortedSet<TE;>;)Ljava/util/SortedSet<TE;>;")]
				public static global::Java.Util.ISortedSet<E> SynchronizedSortedSet<E>(global::Java.Util.ISortedSet<E> set) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISortedSet<E>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified collection which throws an <c> UnsupportedOperationException </c> whenever an attempt is made to modify the collection.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>an unmodifiable collection. </para>
				/// </returns>
				/// <java-name>
				/// unmodifiableCollection
				/// </java-name>
				[Dot42.DexImport("unmodifiableCollection", "(Ljava/util/Collection;)Ljava/util/Collection;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(Ljava/util/Collection<+TE;>;)Ljava/util/Collection<TE;>;")]
				public static global::Java.Util.ICollection<E> UnmodifiableCollection<E>(global::Java.Util.ICollection<E> collection) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ICollection<E>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified list which throws an <c> UnsupportedOperationException </c> whenever an attempt is made to modify the list.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>an unmodifiable List. </para>
				/// </returns>
				/// <java-name>
				/// unmodifiableList
				/// </java-name>
				[Dot42.DexImport("unmodifiableList", "(Ljava/util/List;)Ljava/util/List;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(Ljava/util/List<+TE;>;)Ljava/util/List<TE;>;")]
				public static global::Java.Util.IList<E> UnmodifiableList<E>(global::Java.Util.IList<E> list) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IList<E>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified map which throws an <c> UnsupportedOperationException </c> whenever an attempt is made to modify the map.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a unmodifiable map. </para>
				/// </returns>
				/// <java-name>
				/// unmodifiableMap
				/// </java-name>
				[Dot42.DexImport("unmodifiableMap", "(Ljava/util/Map;)Ljava/util/Map;", AccessFlags = 9, Signature = "<K:Ljava/lang/Object;V:Ljava/lang/Object;>(Ljava/util/Map<+TK;+TV;>;)Ljava/util/M" +
    "ap<TK;TV;>;")]
				public static global::Java.Util.IMap<K, V> UnmodifiableMap<K, V>(global::Java.Util.IMap<K, V> map) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IMap<K, V>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified set which throws an <c> UnsupportedOperationException </c> whenever an attempt is made to modify the set.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a unmodifiable set </para>
				/// </returns>
				/// <java-name>
				/// unmodifiableSet
				/// </java-name>
				[Dot42.DexImport("unmodifiableSet", "(Ljava/util/Set;)Ljava/util/Set;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(Ljava/util/Set<+TE;>;)Ljava/util/Set<TE;>;")]
				public static global::Java.Util.ISet<E> UnmodifiableSet<E>(global::Java.Util.ISet<E> set) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISet<E>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified sorted map which throws an <c> UnsupportedOperationException </c> whenever an attempt is made to modify the sorted map.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a unmodifiable sorted map </para>
				/// </returns>
				/// <java-name>
				/// unmodifiableSortedMap
				/// </java-name>
				[Dot42.DexImport("unmodifiableSortedMap", "(Ljava/util/SortedMap;)Ljava/util/SortedMap;", AccessFlags = 9, Signature = "<K:Ljava/lang/Object;V:Ljava/lang/Object;>(Ljava/util/SortedMap<TK;+TV;>;)Ljava/u" +
    "til/SortedMap<TK;TV;>;")]
				public static global::Java.Util.ISortedMap<K, V> UnmodifiableSortedMap<K, V>(global::Java.Util.ISortedMap<K, V> map) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISortedMap<K, V>);
				}

				/// <summary>
				/// <para>Returns a wrapper on the specified sorted set which throws an <c> UnsupportedOperationException </c> whenever an attempt is made to modify the sorted set.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a unmodifiable sorted set. </para>
				/// </returns>
				/// <java-name>
				/// unmodifiableSortedSet
				/// </java-name>
				[Dot42.DexImport("unmodifiableSortedSet", "(Ljava/util/SortedSet;)Ljava/util/SortedSet;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(Ljava/util/SortedSet<TE;>;)Ljava/util/SortedSet<TE;>;")]
				public static global::Java.Util.ISortedSet<E> UnmodifiableSortedSet<E>(global::Java.Util.ISortedSet<E> set) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISortedSet<E>);
				}

				/// <summary>
				/// <para>Returns the number of elements in the <c> Collection </c> that match the <c> Object </c> passed. If the <c> Object </c> is <c> null </c> , then the number of <c> null </c> elements is returned.</para><para><para>1.5 </para></para>        
				/// </summary>
				/// <returns>
				/// <para>the number of matching elements. </para>
				/// </returns>
				/// <java-name>
				/// frequency
				/// </java-name>
				[Dot42.DexImport("frequency", "(Ljava/util/Collection;Ljava/lang/Object;)I", AccessFlags = 9, Signature = "(Ljava/util/Collection<*>;Ljava/lang/Object;)I")]
				public static int Frequency(global::Java.Util.ICollection<object> c, object o) /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <summary>
				/// <para>Returns a type-safe empty, immutable List.</para><para><para>1.5 </para><para>EMPTY_LIST </para></para>        
				/// </summary>
				/// <returns>
				/// <para>an empty List. </para>
				/// </returns>
				/// <java-name>
				/// emptyList
				/// </java-name>
				[Dot42.DexImport("emptyList", "()Ljava/util/List;", AccessFlags = 25, Signature = "<T:Ljava/lang/Object;>()Ljava/util/List<TT;>;")]
				public static global::Java.Util.IList<T> EmptyList<T>() /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IList<T>);
				}

				/// <summary>
				/// <para>Returns a type-safe empty, immutable Set.</para><para><para>1.5 </para><para>EMPTY_SET </para></para>        
				/// </summary>
				/// <returns>
				/// <para>an empty Set. </para>
				/// </returns>
				/// <java-name>
				/// emptySet
				/// </java-name>
				[Dot42.DexImport("emptySet", "()Ljava/util/Set;", AccessFlags = 25, Signature = "<T:Ljava/lang/Object;>()Ljava/util/Set<TT;>;")]
				public static global::Java.Util.ISet<T> EmptySet<T>() /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISet<T>);
				}

				/// <summary>
				/// <para>Returns a type-safe empty, immutable Map.</para><para><para>1.5 </para><para>EMPTY_MAP </para></para>        
				/// </summary>
				/// <returns>
				/// <para>an empty Map. </para>
				/// </returns>
				/// <java-name>
				/// emptyMap
				/// </java-name>
				[Dot42.DexImport("emptyMap", "()Ljava/util/Map;", AccessFlags = 25, Signature = "<K:Ljava/lang/Object;V:Ljava/lang/Object;>()Ljava/util/Map<TK;TV;>;")]
				public static global::Java.Util.IMap<K, V> EmptyMap<K, V>() /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IMap<K, V>);
				}

				/// <summary>
				/// <para>Returns a dynamically typesafe view of the specified collection. Trying to insert an element of the wrong type into this collection throws a <c> ClassCastException </c> . At creation time the types in <c> c </c> are not checked for correct type.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a typesafe collection. </para>
				/// </returns>
				/// <java-name>
				/// checkedCollection
				/// </java-name>
				[Dot42.DexImport("checkedCollection", "(Ljava/util/Collection;Ljava/lang/Class;)Ljava/util/Collection;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(Ljava/util/Collection<TE;>;Ljava/lang/Class<TE;>;)Ljava/ut" +
    "il/Collection<TE;>;")]
				public static global::Java.Util.ICollection<E> CheckedCollection<E>(global::Java.Util.ICollection<E> c, global::System.Type type) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ICollection<E>);
				}

				/// <summary>
				/// <para>Returns a dynamically typesafe view of the specified map. Trying to insert an element of the wrong type into this map throws a <c> ClassCastException </c> . At creation time the types in <c> m </c> are not checked for correct type.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a typesafe map. </para>
				/// </returns>
				/// <java-name>
				/// checkedMap
				/// </java-name>
				[Dot42.DexImport("checkedMap", "(Ljava/util/Map;Ljava/lang/Class;Ljava/lang/Class;)Ljava/util/Map;", AccessFlags = 9, Signature = "<K:Ljava/lang/Object;V:Ljava/lang/Object;>(Ljava/util/Map<TK;TV;>;Ljava/lang/Clas" +
    "s<TK;>;Ljava/lang/Class<TV;>;)Ljava/util/Map<TK;TV;>;")]
				public static global::Java.Util.IMap<K, V> CheckedMap<K, V>(global::Java.Util.IMap<K, V> m, global::System.Type keyType, global::System.Type valueType) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IMap<K, V>);
				}

				/// <summary>
				/// <para>Returns a dynamically typesafe view of the specified list. Trying to insert an element of the wrong type into this list throws a <c> ClassCastException </c> . At creation time the types in <c> list </c> are not checked for correct type.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a typesafe list. </para>
				/// </returns>
				/// <java-name>
				/// checkedList
				/// </java-name>
				[Dot42.DexImport("checkedList", "(Ljava/util/List;Ljava/lang/Class;)Ljava/util/List;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(Ljava/util/List<TE;>;Ljava/lang/Class<TE;>;)Ljava/util/Lis" +
    "t<TE;>;")]
				public static global::Java.Util.IList<E> CheckedList<E>(global::Java.Util.IList<E> list, global::System.Type type) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IList<E>);
				}

				/// <summary>
				/// <para>Returns a dynamically typesafe view of the specified set. Trying to insert an element of the wrong type into this set throws a <c> ClassCastException </c> . At creation time the types in <c> s </c> are not checked for correct type.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a typesafe set. </para>
				/// </returns>
				/// <java-name>
				/// checkedSet
				/// </java-name>
				[Dot42.DexImport("checkedSet", "(Ljava/util/Set;Ljava/lang/Class;)Ljava/util/Set;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(Ljava/util/Set<TE;>;Ljava/lang/Class<TE;>;)Ljava/util/Set<" +
    "TE;>;")]
				public static global::Java.Util.ISet<E> CheckedSet<E>(global::Java.Util.ISet<E> s, global::System.Type type) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISet<E>);
				}

				/// <summary>
				/// <para>Returns a dynamically typesafe view of the specified sorted map. Trying to insert an element of the wrong type into this sorted map throws a <c> ClassCastException </c> . At creation time the types in <c> m </c> are not checked for correct type.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a typesafe sorted map. </para>
				/// </returns>
				/// <java-name>
				/// checkedSortedMap
				/// </java-name>
				[Dot42.DexImport("checkedSortedMap", "(Ljava/util/SortedMap;Ljava/lang/Class;Ljava/lang/Class;)Ljava/util/SortedMap;", AccessFlags = 9, Signature = "<K:Ljava/lang/Object;V:Ljava/lang/Object;>(Ljava/util/SortedMap<TK;TV;>;Ljava/lan" +
    "g/Class<TK;>;Ljava/lang/Class<TV;>;)Ljava/util/SortedMap<TK;TV;>;")]
				public static global::Java.Util.ISortedMap<K, V> CheckedSortedMap<K, V>(global::Java.Util.ISortedMap<K, V> m, global::System.Type keyType, global::System.Type valueType) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISortedMap<K, V>);
				}

				/// <summary>
				/// <para>Returns a dynamically typesafe view of the specified sorted set. Trying to insert an element of the wrong type into this sorted set throws a <c> ClassCastException </c> . At creation time the types in <c> s </c> are not checked for correct type.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a typesafe sorted set. </para>
				/// </returns>
				/// <java-name>
				/// checkedSortedSet
				/// </java-name>
				[Dot42.DexImport("checkedSortedSet", "(Ljava/util/SortedSet;Ljava/lang/Class;)Ljava/util/SortedSet;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(Ljava/util/SortedSet<TE;>;Ljava/lang/Class<TE;>;)Ljava/uti" +
    "l/SortedSet<TE;>;")]
				public static global::Java.Util.ISortedSet<E> CheckedSortedSet<E>(global::Java.Util.ISortedSet<E> s, global::System.Type type) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISortedSet<E>);
				}

				/// <summary>
				/// <para>Adds all the specified elements to the specified collection.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>true if the collection changed during insertion. </para>
				/// </returns>
				/// <java-name>
				/// addAll
				/// </java-name>
				[Dot42.DexImport("addAll", "(Ljava/util/Collection;[Ljava/lang/Object;)Z", AccessFlags = 137, Signature = "<T:Ljava/lang/Object;>(Ljava/util/Collection<-TT;>;[TT;)Z")]
				public static bool AddAll<T>(global::Java.Util.ICollection<T> c, params T[] a) /* MethodBuilder.Create */ 
				{
						return default(bool);
				}

				/// <summary>
				/// <para>Returns whether the specified collections have no elements in common.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para><c> true </c> if the collections have no elements in common, <c> false </c> otherwise. </para>
				/// </returns>
				/// <java-name>
				/// disjoint
				/// </java-name>
				[Dot42.DexImport("disjoint", "(Ljava/util/Collection;Ljava/util/Collection;)Z", AccessFlags = 9, Signature = "(Ljava/util/Collection<*>;Ljava/util/Collection<*>;)Z")]
				public static bool Disjoint(global::Java.Util.ICollection<object> c1, global::Java.Util.ICollection<object> c2) /* MethodBuilder.Create */ 
				{
						return default(bool);
				}

				/// <summary>
				/// <para>Returns a set backed by <c> map </c> .</para><para><para>1.6 </para></para>        
				/// </summary>
				/// <java-name>
				/// newSetFromMap
				/// </java-name>
				[Dot42.DexImport("newSetFromMap", "(Ljava/util/Map;)Ljava/util/Set;", AccessFlags = 9, Signature = "<E:Ljava/lang/Object;>(Ljava/util/Map<TE;Ljava/lang/Boolean;>;)Ljava/util/Set<TE;" +
    ">;")]
				public static global::Java.Util.ISet<E> NewSetFromMap<E>(global::Java.Util.IMap<E, bool?> map) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.ISet<E>);
				}

				/// <summary>
				/// <para>Returns a last-in, first-out queue as a view of <c> deque </c> .</para><para><para>1.6 </para></para>        
				/// </summary>
				/// <java-name>
				/// asLifoQueue
				/// </java-name>
				[Dot42.DexImport("asLifoQueue", "(Ljava/util/Deque;)Ljava/util/Queue;", AccessFlags = 9, Signature = "<T:Ljava/lang/Object;>(Ljava/util/Deque<TT;>;)Ljava/util/Queue<TT;>;")]
				public static global::Java.Util.IQueue<T> AsLifoQueue<T>(global::Java.Util.IDeque<T> deque) /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IQueue<T>);
				}

		}

		/// <summary>
		/// <para>This abstract class provides a simple wrapper for objects of type <c> EventListener </c> . </para>    
		/// </summary>
		/// <java-name>
		/// java/util/EventListenerProxy
		/// </java-name>
		[Dot42.DexImport("java/util/EventListenerProxy", AccessFlags = 1057)]
		public abstract partial class EventListenerProxy : global::Java.Util.IEventListener
 /* scope: __dot42__ */ 
		{
				/// <summary>
				/// <para>Creates a new <c> EventListener </c> proxy instance.</para><para></para>        
				/// </summary>
				[Dot42.DexImport("<init>", "(Ljava/util/EventListener;)V", AccessFlags = 1)]
				public EventListenerProxy(global::Java.Util.IEventListener listener) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Returns the wrapped <c> EventListener </c> .</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the wrapped <c> EventListener </c> . </para>
				/// </returns>
				/// <java-name>
				/// getListener
				/// </java-name>
				[Dot42.DexImport("getListener", "()Ljava/util/EventListener;", AccessFlags = 1)]
				public virtual global::Java.Util.IEventListener GetListener() /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.IEventListener);
				}

				[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]
				internal EventListenerProxy() /* TypeBuilder.AddDefaultConstructor */ 
				{
				}

				/// <summary>
				/// <para>Returns the wrapped <c> EventListener </c> .</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the wrapped <c> EventListener </c> . </para>
				/// </returns>
				/// <java-name>
				/// getListener
				/// </java-name>
				public global::Java.Util.IEventListener Listener
				{
				[Dot42.DexImport("getListener", "()Ljava/util/EventListener;", AccessFlags = 1)]
						get{ return GetListener(); }
				}

		}

		/// <summary>
		/// <para>Class <c> AbstractCollection </c> is an abstract implementation of the <c>   Collection </c> interface. A subclass must implement the abstract methods <c>   iterator() </c> and <c> size() </c> to create an immutable collection. To create a modifiable collection it's necessary to override the <c> add() </c> method that currently throws an <c> UnsupportedOperationException </c> .</para><para><para>1.2 </para></para>    
		/// </summary>
		/// <java-name>
		/// java/util/AbstractCollection
		/// </java-name>
		[Dot42.DexImport("java/util/AbstractCollection", AccessFlags = 1057, Signature = "<E:Ljava/lang/Object;>Ljava/lang/Object;Ljava/util/Collection<TE;>;")]
		public abstract partial class AbstractCollection<E> : global::Java.Util.ICollection<E>
 /* scope: __dot42__ */ 
		{