/Generated/v4.1/Org.Apache.Http.Message.cs

// Copyright (C) 2014 dot42

//

// Original filename: Org.Apache.Http.Message.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 Org.Apache.Http.Message
{
		/// <summary>
		/// <para>Basic implementation for parsing header values into elements. Instances of this class are stateless and thread-safe. Derived classes are expected to maintain these properties.</para><para><para> </para><simplesectsep></simplesectsep><para> </para><simplesectsep></simplesectsep><para> </para><simplesectsep></simplesectsep><para> </para><simplesectsep></simplesectsep><para>and others</para><para></para><title>Revision:</title><para>595670 </para></para><para><para>4.0 </para></para>    
		/// </summary>
		/// <java-name>
		/// org/apache/http/message/BasicHeaderValueParser
		/// </java-name>
		[Dot42.DexImport("org/apache/http/message/BasicHeaderValueParser", AccessFlags = 33)]
		public partial class BasicHeaderValueParser : global::Org.Apache.Http.Message.IHeaderValueParser
 /* scope: __dot42__ */ 
		{
				/// <summary>
				/// <para>A default instance of this class, for use as default or fallback. Note that BasicHeaderValueParser is not a singleton, there can be many instances of the class itself and of derived classes. The instance here provides non-customized, default behavior. </para>        
				/// </summary>
				/// <java-name>
				/// DEFAULT
				/// </java-name>
				[Dot42.DexImport("DEFAULT", "Lorg/apache/http/message/BasicHeaderValueParser;", AccessFlags = 25)]
				public static readonly global::Org.Apache.Http.Message.BasicHeaderValueParser DEFAULT;
				[Dot42.DexImport("<init>", "()V", AccessFlags = 1)]
				public BasicHeaderValueParser() /* MethodBuilder.Create */ 
				{
				}

				/// <java-name>
				/// parseElements
				/// </java-name>
				[Dot42.DexImport("parseElements", "(Ljava/lang/String;Lorg/apache/http/message/HeaderValueParser;)[Lorg/apache/http/" +
    "HeaderElement;", AccessFlags = 25)]
				public static global::Org.Apache.Http.IHeaderElement[] ParseElements(string buffer, global::Org.Apache.Http.Message.IHeaderValueParser cursor) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeaderElement[]);
				}

				/// <java-name>
				/// parseElements
				/// </java-name>
				[Dot42.DexImport("parseElements", "(Lorg/apache/http/util/CharArrayBuffer;Lorg/apache/http/message/ParserCursor;)[Lo" +
    "rg/apache/http/HeaderElement;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IHeaderElement[] ParseElements(global::Org.Apache.Http.Util.CharArrayBuffer buffer, global::Org.Apache.Http.Message.ParserCursor cursor) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeaderElement[]);
				}

				/// <java-name>
				/// parseHeaderElement
				/// </java-name>
				[Dot42.DexImport("parseHeaderElement", "(Ljava/lang/String;Lorg/apache/http/message/HeaderValueParser;)Lorg/apache/http/H" +
    "eaderElement;", AccessFlags = 25)]
				public static global::Org.Apache.Http.IHeaderElement ParseHeaderElement(string buffer, global::Org.Apache.Http.Message.IHeaderValueParser cursor) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeaderElement);
				}

				/// <java-name>
				/// parseHeaderElement
				/// </java-name>
				[Dot42.DexImport("parseHeaderElement", "(Lorg/apache/http/util/CharArrayBuffer;Lorg/apache/http/message/ParserCursor;)Lor" +
    "g/apache/http/HeaderElement;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IHeaderElement ParseHeaderElement(global::Org.Apache.Http.Util.CharArrayBuffer buffer, global::Org.Apache.Http.Message.ParserCursor cursor) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeaderElement);
				}

				/// <summary>
				/// <para>Creates a header element. Called from parseHeaderElement.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a header element representing the argument </para>
				/// </returns>
				/// <java-name>
				/// createHeaderElement
				/// </java-name>
				[Dot42.DexImport("createHeaderElement", "(Ljava/lang/String;Ljava/lang/String;[Lorg/apache/http/NameValuePair;)Lorg/apache" +
    "/http/HeaderElement;", AccessFlags = 4)]
				protected internal virtual global::Org.Apache.Http.IHeaderElement CreateHeaderElement(string name, string value, global::Org.Apache.Http.INameValuePair[] @params) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeaderElement);
				}

				/// <java-name>
				/// parseParameters
				/// </java-name>
				[Dot42.DexImport("parseParameters", "(Ljava/lang/String;Lorg/apache/http/message/HeaderValueParser;)[Lorg/apache/http/" +
    "NameValuePair;", AccessFlags = 25)]
				public static global::Org.Apache.Http.INameValuePair[] ParseParameters(string buffer, global::Org.Apache.Http.Message.IHeaderValueParser cursor) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.INameValuePair[]);
				}

				/// <java-name>
				/// parseParameters
				/// </java-name>
				[Dot42.DexImport("parseParameters", "(Lorg/apache/http/util/CharArrayBuffer;Lorg/apache/http/message/ParserCursor;)[Lo" +
    "rg/apache/http/NameValuePair;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.INameValuePair[] ParseParameters(global::Org.Apache.Http.Util.CharArrayBuffer buffer, global::Org.Apache.Http.Message.ParserCursor cursor) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.INameValuePair[]);
				}

				/// <java-name>
				/// parseNameValuePair
				/// </java-name>
				[Dot42.DexImport("parseNameValuePair", "(Ljava/lang/String;Lorg/apache/http/message/HeaderValueParser;)Lorg/apache/http/N" +
    "ameValuePair;", AccessFlags = 25)]
				public static global::Org.Apache.Http.INameValuePair ParseNameValuePair(string buffer, global::Org.Apache.Http.Message.IHeaderValueParser cursor) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.INameValuePair);
				}

				/// <java-name>
				/// parseNameValuePair
				/// </java-name>
				[Dot42.DexImport("parseNameValuePair", "(Lorg/apache/http/util/CharArrayBuffer;Lorg/apache/http/message/ParserCursor;)Lor" +
    "g/apache/http/NameValuePair;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.INameValuePair ParseNameValuePair(global::Org.Apache.Http.Util.CharArrayBuffer buffer, global::Org.Apache.Http.Message.ParserCursor cursor) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.INameValuePair);
				}

				/// <java-name>
				/// parseNameValuePair
				/// </java-name>
				[Dot42.DexImport("parseNameValuePair", "(Lorg/apache/http/util/CharArrayBuffer;Lorg/apache/http/message/ParserCursor;[C)L" +
    "org/apache/http/NameValuePair;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.INameValuePair ParseNameValuePair(global::Org.Apache.Http.Util.CharArrayBuffer buffer, global::Org.Apache.Http.Message.ParserCursor cursor, char[] delimiters) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.INameValuePair);
				}

				/// <summary>
				/// <para>Creates a name-value pair. Called from parseNameValuePair.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a name-value pair representing the arguments </para>
				/// </returns>
				/// <java-name>
				/// createNameValuePair
				/// </java-name>
				[Dot42.DexImport("createNameValuePair", "(Ljava/lang/String;Ljava/lang/String;)Lorg/apache/http/NameValuePair;", AccessFlags = 4)]
				protected internal virtual global::Org.Apache.Http.INameValuePair CreateNameValuePair(string name, string value) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.INameValuePair);
				}

		}

		/// <summary>
		/// <para>Implementation of a HeaderIterator based on a List. For use by HeaderGroup.</para><para><para></para><title>Revision:</title><para>584542 </para></para>    
		/// </summary>
		/// <java-name>
		/// org/apache/http/message/BasicListHeaderIterator
		/// </java-name>
		[Dot42.DexImport("org/apache/http/message/BasicListHeaderIterator", AccessFlags = 33)]
		public partial class BasicListHeaderIterator : global::Org.Apache.Http.IHeaderIterator
 /* scope: __dot42__ */ 
		{
				/// <summary>
				/// <para>A list of headers to iterate over. Not all elements of this array are necessarily part of the iteration. </para>        
				/// </summary>
				/// <java-name>
				/// allHeaders
				/// </java-name>
				[Dot42.DexImport("allHeaders", "Ljava/util/List;", AccessFlags = 20)]
				protected internal readonly global::Java.Util.IList<object> AllHeaders;
				/// <summary>
				/// <para>The position of the next header in allHeaders. Negative if the iteration is over. </para>        
				/// </summary>
				/// <java-name>
				/// currentIndex
				/// </java-name>
				[Dot42.DexImport("currentIndex", "I", AccessFlags = 4)]
				protected internal int CurrentIndex;
				/// <summary>
				/// <para>The position of the last returned header. Negative if none has been returned so far. </para>        
				/// </summary>
				/// <java-name>
				/// lastIndex
				/// </java-name>
				[Dot42.DexImport("lastIndex", "I", AccessFlags = 4)]
				protected internal int LastIndex;
				/// <summary>
				/// <para>The header name to filter by. <code>null</code> to iterate over all headers in the array. </para>        
				/// </summary>
				/// <java-name>
				/// headerName
				/// </java-name>
				[Dot42.DexImport("headerName", "Ljava/lang/String;", AccessFlags = 4)]
				protected internal string HeaderName;
				/// <summary>
				/// <para>Creates a new header iterator.</para><para></para>        
				/// </summary>
				[Dot42.DexImport("<init>", "(Ljava/util/List;Ljava/lang/String;)V", AccessFlags = 1)]
				public BasicListHeaderIterator(global::Java.Util.IList<object> headers, string name) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Determines the index of the next header.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the index of the next header that matches the filter name, or negative if there are no more headers </para>
				/// </returns>
				/// <java-name>
				/// findNext
				/// </java-name>
				[Dot42.DexImport("findNext", "(I)I", AccessFlags = 4)]
				protected internal virtual int FindNext(int from) /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <summary>
				/// <para>Checks whether a header is part of the iteration.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para><code>true</code> if the header should be part of the iteration, <code>false</code> to skip </para>
				/// </returns>
				/// <java-name>
				/// filterHeader
				/// </java-name>
				[Dot42.DexImport("filterHeader", "(I)Z", AccessFlags = 4)]
				protected internal virtual bool FilterHeader(int index) /* MethodBuilder.Create */ 
				{
						return default(bool);
				}

				/// <summary>
				/// <para>Indicates whether there is another header in this iteration.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para><code>true</code> if there is another header, <code>false</code> otherwise </para>
				/// </returns>
				/// <java-name>
				/// hasNext
				/// </java-name>
				[Dot42.DexImport("hasNext", "()Z", AccessFlags = 1)]
				public virtual bool HasNext() /* MethodBuilder.Create */ 
				{
						return default(bool);
				}

				/// <summary>
				/// <para>Obtains the next header from this iteration.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the next header in this iteration</para>
				/// </returns>
				/// <java-name>
				/// nextHeader
				/// </java-name>
				[Dot42.DexImport("nextHeader", "()Lorg/apache/http/Header;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IHeader NextHeader() /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeader);
				}

				/// <summary>
				/// <para>Returns the next header. Same as nextHeader, but not type-safe.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the next header in this iteration</para>
				/// </returns>
				/// <java-name>
				/// next
				/// </java-name>
				[Dot42.DexImport("next", "()Ljava/lang/Object;", AccessFlags = 17)]
				public object Next() /* MethodBuilder.Create */ 
				{
						return default(object);
				}

				/// <summary>
				/// <para>Removes the header that was returned last. </para>        
				/// </summary>
				/// <java-name>
				/// remove
				/// </java-name>
				[Dot42.DexImport("remove", "()V", AccessFlags = 1)]
				public virtual void Remove() /* MethodBuilder.Create */ 
				{
				}

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

		}

		/// <summary>
		/// <para>This class represents a context of a parsing operation: <ul><li><para>the current position the parsing operation is expected to start at </para></li><li><para>the bounds limiting the scope of the parsing operation </para></li></ul></para><para><para> </para></para>    
		/// </summary>
		/// <java-name>
		/// org/apache/http/message/ParserCursor
		/// </java-name>
		[Dot42.DexImport("org/apache/http/message/ParserCursor", AccessFlags = 33)]
		public partial class ParserCursor
 /* scope: __dot42__ */ 
		{
				[Dot42.DexImport("<init>", "(II)V", AccessFlags = 1)]
				public ParserCursor(int lowerBound, int upperBound) /* MethodBuilder.Create */ 
				{
				}

				/// <java-name>
				/// getLowerBound
				/// </java-name>
				[Dot42.DexImport("getLowerBound", "()I", AccessFlags = 1)]
				public virtual int GetLowerBound() /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <java-name>
				/// getUpperBound
				/// </java-name>
				[Dot42.DexImport("getUpperBound", "()I", AccessFlags = 1)]
				public virtual int GetUpperBound() /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <java-name>
				/// getPos
				/// </java-name>
				[Dot42.DexImport("getPos", "()I", AccessFlags = 1)]
				public virtual int GetPos() /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <java-name>
				/// updatePos
				/// </java-name>
				[Dot42.DexImport("updatePos", "(I)V", AccessFlags = 1)]
				public virtual void UpdatePos(int pos) /* MethodBuilder.Create */ 
				{
				}

				/// <java-name>
				/// atEnd
				/// </java-name>
				[Dot42.DexImport("atEnd", "()Z", AccessFlags = 1)]
				public virtual bool AtEnd() /* MethodBuilder.Create */ 
				{
						return default(bool);
				}

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

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

				/// <java-name>
				/// getLowerBound
				/// </java-name>
				public int LowerBound
				{
				[Dot42.DexImport("getLowerBound", "()I", AccessFlags = 1)]
						get{ return GetLowerBound(); }
				}

				/// <java-name>
				/// getUpperBound
				/// </java-name>
				public int UpperBound
				{
				[Dot42.DexImport("getUpperBound", "()I", AccessFlags = 1)]
						get{ return GetUpperBound(); }
				}

				/// <java-name>
				/// getPos
				/// </java-name>
				public int Pos
				{
				[Dot42.DexImport("getPos", "()I", AccessFlags = 1)]
						get{ return GetPos(); }
				}

		}

		/// <summary>
		/// <para>Interface for parsing header values into elements. Instances of this interface are expected to be stateless and thread-safe.</para><para><para></para><title>Revision:</title><para>589325 </para><title>Date:</title><para>2007-10-28 03:37:56 -0700 (Sun, 28 Oct 2007) </para></para><para><para>4.0 </para></para>    
		/// </summary>
		/// <java-name>
		/// org/apache/http/message/HeaderValueParser
		/// </java-name>
		[Dot42.DexImport("org/apache/http/message/HeaderValueParser", AccessFlags = 1537)]
		public partial interface IHeaderValueParser
 /* scope: __dot42__ */ 
		{
				/// <summary>
				/// <para>Parses a header value into elements. Parse errors are indicated as <code>RuntimeException</code>. </para><para>Some HTTP headers (such as the set-cookie header) have values that can be decomposed into multiple elements. In order to be processed by this parser, such headers must be in the following form: </para><para><pre>
				///        header  = [ element ] *( "," [ element ] )
				///        element = name [ "=" [ value ] ] *( ";" [ param ] )
				///        param   = name [ "=" [ value ] ]
				/// 
				///        name    = token
				///        value   = ( token | quoted-string )
				/// 
				///        token         = 1*&lt;any char except "=", ",", ";", &lt;"&gt; and
				///                              white space&gt;
				///        quoted-string = &lt;"&amp;gt; *( text | quoted-char ) &amp;lt;"&gt;
				///        text          = any char except &lt;"&amp;gt;
				///        quoted-char   = "" char
				///        </pre> </para><para>Any amount of white space is allowed between any part of the header, element or param and is ignored. A missing value in any element or param will be stored as the empty String; if the "=" is also missing <b>null</b> will be stored instead. </para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>an array holding all elements of the header value</para>
				/// </returns>
				/// <java-name>
				/// parseElements
				/// </java-name>
				[Dot42.DexImport("parseElements", "(Lorg/apache/http/util/CharArrayBuffer;Lorg/apache/http/message/ParserCursor;)[Lo" +
    "rg/apache/http/HeaderElement;", AccessFlags = 1025)]
				global::Org.Apache.Http.IHeaderElement[] ParseElements(global::Org.Apache.Http.Util.CharArrayBuffer buffer, global::Org.Apache.Http.Message.ParserCursor cursor) /* MethodBuilder.Create */ ;

				/// <summary>
				/// <para>Parses a single header element. A header element consist of a semicolon-separate list of name=value definitions.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the parsed element</para>
				/// </returns>
				/// <java-name>
				/// parseHeaderElement
				/// </java-name>
				[Dot42.DexImport("parseHeaderElement", "(Lorg/apache/http/util/CharArrayBuffer;Lorg/apache/http/message/ParserCursor;)Lor" +
    "g/apache/http/HeaderElement;", AccessFlags = 1025)]
				global::Org.Apache.Http.IHeaderElement ParseHeaderElement(global::Org.Apache.Http.Util.CharArrayBuffer buffer, global::Org.Apache.Http.Message.ParserCursor cursor) /* MethodBuilder.Create */ ;

				/// <summary>
				/// <para>Parses a list of name-value pairs. These lists are used to specify parameters to a header element. Parse errors are indicated as <code>RuntimeException</code>. </para><para>This method comforms to the generic grammar and formatting rules outlined in the  and  of . </para><para>&lt;h&gt;2.2 Basic Rules&lt;/h&gt; </para><para>The following rules are used throughout this specification to describe basic parsing constructs. The US-ASCII coded character set is defined by ANSI X3.4-1986. </para><para><pre>
				///            OCTET          = &lt;any 8-bit sequence of data&gt;
				///            CHAR           = &lt;any US-ASCII character (octets 0 - 127)&gt;
				///            UPALPHA        = &lt;any US-ASCII uppercase letter "A".."Z"&gt;
				///            LOALPHA        = &lt;any US-ASCII lowercase letter "a".."z"&gt;
				///            ALPHA          = UPALPHA | LOALPHA
				///            DIGIT          = &lt;any US-ASCII digit "0".."9"&gt;
				///            CTL            = &lt;any US-ASCII control character
				///                             (octets 0 - 31) and DEL (127)&gt;
				///            CR             = &lt;US-ASCII CR, carriage return (13)&gt;
				///            LF             = &lt;US-ASCII LF, linefeed (10)&gt;
				///            SP             = &lt;US-ASCII SP, space (32)&gt;
				///            HT             = &lt;US-ASCII HT, horizontal-tab (9)&gt;
				///            &lt;"&gt;            = &lt;US-ASCII double-quote mark (34)&gt;
				///        </pre> </para><para>Many HTTP/1.1 header field values consist of words separated by LWS or special characters. These special characters MUST be in a quoted string to be used within a parameter value (as defined in section 3.6). </para><para><pre>
				///        token          = 1*&lt;any char="" except="" ctls="" or="" separators&gt;=""&gt;
				///        separators     = "(" | ")" | "&lt;" | "&gt;" | "@"
				///                       | "," | ";" | ":" | "\" | &lt;"&gt;
				///                       | "/" | "[" | "]" | "?" | "="
				///                       | "{" | "}" | SP | HT
				///        </pre> </para><para>A string of text is parsed as a single word if it is quoted using double-quote marks. </para><para><pre>
				///        quoted-string  = ( &lt;"&gt; *(qdtext | quoted-pair ) &lt;"&gt; )
				///        qdtext         = &lt;any TEXT except &lt;"&gt;&gt;
				///        </pre> </para><para>The backslash character ("\") MAY be used as a single-character quoting mechanism only within quoted-string and comment constructs. </para><para><pre>
				///        quoted-pair    = "\" CHAR
				///        </pre> &lt;h&gt;3.6 Transfer Codings&lt;/h&gt; </para><para>Parameters are in the form of attribute/value pairs. </para><para><pre>
				///        parameter               = attribute "=" value
				///        attribute               = token
				///        value                   = token | quoted-string
				///        </pre></para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>an array holding all items of the name-value list</para>
				/// </returns>
				/// <java-name>
				/// parseParameters
				/// </java-name>
				[Dot42.DexImport("parseParameters", "(Lorg/apache/http/util/CharArrayBuffer;Lorg/apache/http/message/ParserCursor;)[Lo" +
    "rg/apache/http/NameValuePair;", AccessFlags = 1025)]
				global::Org.Apache.Http.INameValuePair[] ParseParameters(global::Org.Apache.Http.Util.CharArrayBuffer buffer, global::Org.Apache.Http.Message.ParserCursor cursor) /* MethodBuilder.Create */ ;

				/// <summary>
				/// <para>Parses a name=value specification, where the = and value are optional.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the name-value pair, where the value is <code>null</code> if no value is specified </para>
				/// </returns>
				/// <java-name>
				/// parseNameValuePair
				/// </java-name>
				[Dot42.DexImport("parseNameValuePair", "(Lorg/apache/http/util/CharArrayBuffer;Lorg/apache/http/message/ParserCursor;)Lor" +
    "g/apache/http/NameValuePair;", AccessFlags = 1025)]
				global::Org.Apache.Http.INameValuePair ParseNameValuePair(global::Org.Apache.Http.Util.CharArrayBuffer buffer, global::Org.Apache.Http.Message.ParserCursor cursor) /* MethodBuilder.Create */ ;

		}

		/// <summary>
		/// <para>Basic implementation for formatting header value elements. Instances of this class are stateless and thread-safe. Derived classes are expected to maintain these properties.</para><para><para> </para><simplesectsep></simplesectsep><para>and others</para><para></para><title>Revision:</title><para>574185 </para></para><para><para>4.0 </para></para>    
		/// </summary>
		/// <java-name>
		/// org/apache/http/message/BasicHeaderValueFormatter
		/// </java-name>
		[Dot42.DexImport("org/apache/http/message/BasicHeaderValueFormatter", AccessFlags = 33)]
		public partial class BasicHeaderValueFormatter : global::Org.Apache.Http.Message.IHeaderValueFormatter
 /* scope: __dot42__ */ 
		{
				/// <summary>
				/// <para>A default instance of this class, for use as default or fallback. Note that BasicHeaderValueFormatter is not a singleton, there can be many instances of the class itself and of derived classes. The instance here provides non-customized, default behavior. </para>        
				/// </summary>
				/// <java-name>
				/// DEFAULT
				/// </java-name>
				[Dot42.DexImport("DEFAULT", "Lorg/apache/http/message/BasicHeaderValueFormatter;", AccessFlags = 25)]
				public static readonly global::Org.Apache.Http.Message.BasicHeaderValueFormatter DEFAULT;
				/// <summary>
				/// <para>Special characters that can be used as separators in HTTP parameters. These special characters MUST be in a quoted string to be used within a parameter value . </para>        
				/// </summary>
				/// <java-name>
				/// SEPARATORS
				/// </java-name>
				[Dot42.DexImport("SEPARATORS", "Ljava/lang/String;", AccessFlags = 25)]
				public const string SEPARATORS = " ;,:@()<>\\\"/[]?={}\t";
				/// <summary>
				/// <para>Unsafe special characters that must be escaped using the backslash character </para>        
				/// </summary>
				/// <java-name>
				/// UNSAFE_CHARS
				/// </java-name>
				[Dot42.DexImport("UNSAFE_CHARS", "Ljava/lang/String;", AccessFlags = 25)]
				public const string UNSAFE_CHARS = "\"\\";
				[Dot42.DexImport("<init>", "()V", AccessFlags = 1)]
				public BasicHeaderValueFormatter() /* MethodBuilder.Create */ 
				{
				}

				/// <java-name>
				/// formatElements
				/// </java-name>
				[Dot42.DexImport("formatElements", "([Lorg/apache/http/HeaderElement;ZLorg/apache/http/message/HeaderValueFormatter;)" +
    "Ljava/lang/String;", AccessFlags = 25)]
				public static string FormatElements(global::Org.Apache.Http.IHeaderElement[] headerElement, bool boolean, global::Org.Apache.Http.Message.IHeaderValueFormatter headerValueFormatter) /* MethodBuilder.Create */ 
				{
						return default(string);
				}

				/// <java-name>
				/// formatElements
				/// </java-name>
				[Dot42.DexImport("formatElements", "(Lorg/apache/http/util/CharArrayBuffer;[Lorg/apache/http/HeaderElement;Z)Lorg/apa" +
    "che/http/util/CharArrayBuffer;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.Util.CharArrayBuffer FormatElements(global::Org.Apache.Http.Util.CharArrayBuffer charArrayBuffer, global::Org.Apache.Http.IHeaderElement[] headerElement, bool boolean) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.Util.CharArrayBuffer);
				}

				/// <summary>
				/// <para>Estimates the length of formatted header elements.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a length estimate, in number of characters </para>
				/// </returns>
				/// <java-name>
				/// estimateElementsLen
				/// </java-name>
				[Dot42.DexImport("estimateElementsLen", "([Lorg/apache/http/HeaderElement;)I", AccessFlags = 4)]
				protected internal virtual int EstimateElementsLen(global::Org.Apache.Http.IHeaderElement[] elems) /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <java-name>
				/// formatHeaderElement
				/// </java-name>
				[Dot42.DexImport("formatHeaderElement", "(Lorg/apache/http/HeaderElement;ZLorg/apache/http/message/HeaderValueFormatter;)L" +
    "java/lang/String;", AccessFlags = 25)]
				public static string FormatHeaderElement(global::Org.Apache.Http.IHeaderElement headerElement, bool boolean, global::Org.Apache.Http.Message.IHeaderValueFormatter headerValueFormatter) /* MethodBuilder.Create */ 
				{
						return default(string);
				}

				/// <java-name>
				/// formatHeaderElement
				/// </java-name>
				[Dot42.DexImport("formatHeaderElement", "(Lorg/apache/http/util/CharArrayBuffer;Lorg/apache/http/HeaderElement;Z)Lorg/apac" +
    "he/http/util/CharArrayBuffer;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.Util.CharArrayBuffer FormatHeaderElement(global::Org.Apache.Http.Util.CharArrayBuffer charArrayBuffer, global::Org.Apache.Http.IHeaderElement headerElement, bool boolean) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.Util.CharArrayBuffer);
				}

				/// <summary>
				/// <para>Estimates the length of a formatted header element.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a length estimate, in number of characters </para>
				/// </returns>
				/// <java-name>
				/// estimateHeaderElementLen
				/// </java-name>
				[Dot42.DexImport("estimateHeaderElementLen", "(Lorg/apache/http/HeaderElement;)I", AccessFlags = 4)]
				protected internal virtual int EstimateHeaderElementLen(global::Org.Apache.Http.IHeaderElement elem) /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <java-name>
				/// formatParameters
				/// </java-name>
				[Dot42.DexImport("formatParameters", "([Lorg/apache/http/NameValuePair;ZLorg/apache/http/message/HeaderValueFormatter;)" +
    "Ljava/lang/String;", AccessFlags = 25)]
				public static string FormatParameters(global::Org.Apache.Http.INameValuePair[] nameValuePair, bool boolean, global::Org.Apache.Http.Message.IHeaderValueFormatter headerValueFormatter) /* MethodBuilder.Create */ 
				{
						return default(string);
				}

				/// <java-name>
				/// formatParameters
				/// </java-name>
				[Dot42.DexImport("formatParameters", "(Lorg/apache/http/util/CharArrayBuffer;[Lorg/apache/http/NameValuePair;Z)Lorg/apa" +
    "che/http/util/CharArrayBuffer;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.Util.CharArrayBuffer FormatParameters(global::Org.Apache.Http.Util.CharArrayBuffer charArrayBuffer, global::Org.Apache.Http.INameValuePair[] nameValuePair, bool boolean) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.Util.CharArrayBuffer);
				}

				/// <summary>
				/// <para>Estimates the length of formatted parameters.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a length estimate, in number of characters </para>
				/// </returns>
				/// <java-name>
				/// estimateParametersLen
				/// </java-name>
				[Dot42.DexImport("estimateParametersLen", "([Lorg/apache/http/NameValuePair;)I", AccessFlags = 4)]
				protected internal virtual int EstimateParametersLen(global::Org.Apache.Http.INameValuePair[] nvps) /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <java-name>
				/// formatNameValuePair
				/// </java-name>
				[Dot42.DexImport("formatNameValuePair", "(Lorg/apache/http/NameValuePair;ZLorg/apache/http/message/HeaderValueFormatter;)L" +
    "java/lang/String;", AccessFlags = 25)]
				public static string FormatNameValuePair(global::Org.Apache.Http.INameValuePair nameValuePair, bool boolean, global::Org.Apache.Http.Message.IHeaderValueFormatter headerValueFormatter) /* MethodBuilder.Create */ 
				{
						return default(string);
				}

				/// <java-name>
				/// formatNameValuePair
				/// </java-name>
				[Dot42.DexImport("formatNameValuePair", "(Lorg/apache/http/util/CharArrayBuffer;Lorg/apache/http/NameValuePair;Z)Lorg/apac" +
    "he/http/util/CharArrayBuffer;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.Util.CharArrayBuffer FormatNameValuePair(global::Org.Apache.Http.Util.CharArrayBuffer charArrayBuffer, global::Org.Apache.Http.INameValuePair nameValuePair, bool boolean) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.Util.CharArrayBuffer);
				}

				/// <summary>
				/// <para>Estimates the length of a formatted name-value pair.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a length estimate, in number of characters </para>
				/// </returns>
				/// <java-name>
				/// estimateNameValuePairLen
				/// </java-name>
				[Dot42.DexImport("estimateNameValuePairLen", "(Lorg/apache/http/NameValuePair;)I", AccessFlags = 4)]
				protected internal virtual int EstimateNameValuePairLen(global::Org.Apache.Http.INameValuePair nvp) /* MethodBuilder.Create */ 
				{
						return default(int);
				}

				/// <summary>
				/// <para>Actually formats the value of a name-value pair. This does not include a leading = character. Called from formatNameValuePair.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// doFormatValue
				/// </java-name>
				[Dot42.DexImport("doFormatValue", "(Lorg/apache/http/util/CharArrayBuffer;Ljava/lang/String;Z)V", AccessFlags = 4)]
				protected internal virtual void DoFormatValue(global::Org.Apache.Http.Util.CharArrayBuffer buffer, string value, bool quote) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Checks whether a character is a separator.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para><code>true</code> if the character is a separator, <code>false</code> otherwise </para>
				/// </returns>
				/// <java-name>
				/// isSeparator
				/// </java-name>
				[Dot42.DexImport("isSeparator", "(C)Z", AccessFlags = 4)]
				protected internal virtual bool IsSeparator(char ch) /* MethodBuilder.Create */ 
				{
						return default(bool);
				}

				/// <summary>
				/// <para>Checks whether a character is unsafe.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para><code>true</code> if the character is unsafe, <code>false</code> otherwise </para>
				/// </returns>
				/// <java-name>
				/// isUnsafe
				/// </java-name>
				[Dot42.DexImport("isUnsafe", "(C)Z", AccessFlags = 4)]
				protected internal virtual bool IsUnsafe(char ch) /* MethodBuilder.Create */ 
				{
						return default(bool);
				}

		}

		/// <summary>
		/// <para>A class for combining a set of headers. This class allows for multiple headers with the same name and keeps track of the order in which headers were added.</para><para><para>Michael Becke</para><para>4.0 </para></para>    
		/// </summary>
		/// <java-name>
		/// org/apache/http/message/HeaderGroup
		/// </java-name>
		[Dot42.DexImport("org/apache/http/message/HeaderGroup", AccessFlags = 33)]
		public partial class HeaderGroup : global::Java.Lang.ICloneable
 /* scope: __dot42__ */ 
		{
				/// <summary>
				/// <para>Constructor for HeaderGroup. </para>        
				/// </summary>
				[Dot42.DexImport("<init>", "()V", AccessFlags = 1)]
				public HeaderGroup() /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Removes any contained headers. </para>        
				/// </summary>
				/// <java-name>
				/// clear
				/// </java-name>
				[Dot42.DexImport("clear", "()V", AccessFlags = 1)]
				public virtual void Clear() /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Adds the given header to the group. The order in which this header was added is preserved.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// addHeader
				/// </java-name>
				[Dot42.DexImport("addHeader", "(Lorg/apache/http/Header;)V", AccessFlags = 1)]
				public virtual void AddHeader(global::Org.Apache.Http.IHeader header) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Removes the given header.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// removeHeader
				/// </java-name>
				[Dot42.DexImport("removeHeader", "(Lorg/apache/http/Header;)V", AccessFlags = 1)]
				public virtual void RemoveHeader(global::Org.Apache.Http.IHeader header) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Replaces the first occurence of the header with the same name. If no header with the same name is found the given header is added to the end of the list.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// updateHeader
				/// </java-name>
				[Dot42.DexImport("updateHeader", "(Lorg/apache/http/Header;)V", AccessFlags = 1)]
				public virtual void UpdateHeader(global::Org.Apache.Http.IHeader header) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Sets all of the headers contained within this group overriding any existing headers. The headers are added in the order in which they appear in the array.</para><para></para>        
				/// </summary>
				/// <java-name>
				/// setHeaders
				/// </java-name>
				[Dot42.DexImport("setHeaders", "([Lorg/apache/http/Header;)V", AccessFlags = 1)]
				public virtual void SetHeaders(global::Org.Apache.Http.IHeader[] headers) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Gets a header representing all of the header values with the given name. If more that one header with the given name exists the values will be combined with a "," as per RFC 2616.</para><para>Header name comparison is case insensitive.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>a header with a condensed value or <code>null</code> if no headers by the given name are present </para>
				/// </returns>
				/// <java-name>
				/// getCondensedHeader
				/// </java-name>
				[Dot42.DexImport("getCondensedHeader", "(Ljava/lang/String;)Lorg/apache/http/Header;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IHeader GetCondensedHeader(string name) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeader);
				}

				/// <summary>
				/// <para>Gets all of the headers with the given name. The returned array maintains the relative order in which the headers were added.</para><para>Header name comparison is case insensitive.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>an array of length &gt;= 0 </para>
				/// </returns>
				/// <java-name>
				/// getHeaders
				/// </java-name>
				[Dot42.DexImport("getHeaders", "(Ljava/lang/String;)[Lorg/apache/http/Header;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IHeader[] GetHeaders(string name) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeader[]);
				}

				/// <summary>
				/// <para>Gets the first header with the given name.</para><para>Header name comparison is case insensitive.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the first header or <code>null</code> </para>
				/// </returns>
				/// <java-name>
				/// getFirstHeader
				/// </java-name>
				[Dot42.DexImport("getFirstHeader", "(Ljava/lang/String;)Lorg/apache/http/Header;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IHeader GetFirstHeader(string name) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeader);
				}

				/// <summary>
				/// <para>Gets the last header with the given name.</para><para>Header name comparison is case insensitive.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the last header or <code>null</code> </para>
				/// </returns>
				/// <java-name>
				/// getLastHeader
				/// </java-name>
				[Dot42.DexImport("getLastHeader", "(Ljava/lang/String;)Lorg/apache/http/Header;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IHeader GetLastHeader(string name) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeader);
				}

				/// <summary>
				/// <para>Gets all of the headers contained within this group.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>an array of length &gt;= 0 </para>
				/// </returns>
				/// <java-name>
				/// getAllHeaders
				/// </java-name>
				[Dot42.DexImport("getAllHeaders", "()[Lorg/apache/http/Header;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IHeader[] GetAllHeaders() /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeader[]);
				}

				/// <summary>
				/// <para>Tests if headers with the given name are contained within this group.</para><para>Header name comparison is case insensitive.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para><code>true</code> if at least one header with the name is contained, <code>false</code> otherwise </para>
				/// </returns>
				/// <java-name>
				/// containsHeader
				/// </java-name>
				[Dot42.DexImport("containsHeader", "(Ljava/lang/String;)Z", AccessFlags = 1)]
				public virtual bool ContainsHeader(string name) /* MethodBuilder.Create */ 
				{
						return default(bool);
				}

				/// <summary>
				/// <para>Returns an iterator over this group of headers.</para><para><para>4.0 </para></para>        
				/// </summary>
				/// <returns>
				/// <para>iterator over this group of headers.</para>
				/// </returns>
				/// <java-name>
				/// iterator
				/// </java-name>
				[Dot42.DexImport("iterator", "()Lorg/apache/http/HeaderIterator;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IHeaderIterator Iterator() /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeaderIterator);
				}

				/// <summary>
				/// <para>Returns an iterator over the headers with a given name in this group.</para><para><para>4.0 </para></para>        
				/// </summary>
				/// <returns>
				/// <para>iterator over some headers in this group.</para>
				/// </returns>
				/// <java-name>
				/// iterator
				/// </java-name>
				[Dot42.DexImport("iterator", "(Ljava/lang/String;)Lorg/apache/http/HeaderIterator;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IHeaderIterator Iterator(string name) /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHeaderIterator);
				}

				/// <summary>
				/// <para>Returns a copy of this object</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>copy of this object </para>
				/// </returns>
				/// <java-name>
				/// copy
				/// </java-name>
				[Dot42.DexImport("copy", "()Lorg/apache/http/message/HeaderGroup;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.Message.HeaderGroup Copy() /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.Message.HeaderGroup);
				}

				/// <java-name>
				/// clone
				/// </java-name>
				[Dot42.DexImport("clone", "()Ljava/lang/Object;", AccessFlags = 1)]
				public virtual object Clone() /* MethodBuilder.Create */ 
				{
						return default(object);
				}

				/// <summary>
				/// <para>Gets all of the headers contained within this group.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>an array of length &gt;= 0 </para>
				/// </returns>
				/// <java-name>
				/// getAllHeaders
				/// </java-name>
				public global::Org.Apache.Http.IHeader[] AllHeaders
				{
				[Dot42.DexImport("getAllHeaders", "()[Lorg/apache/http/Header;", AccessFlags = 1)]
						get{ return GetAllHeaders(); }
				}

		}

		/// <summary>
		/// <para>Basic implementation of an HTTP response that can be modified. This implementation makes sure that there always is a status line.</para><para><para></para><para></para><title>Revision:</title><para>573864 </para></para><para><para>4.0 </para></para>    
		/// </summary>
		/// <java-name>
		/// org/apache/http/message/BasicHttpResponse
		/// </java-name>
		[Dot42.DexImport("org/apache/http/message/BasicHttpResponse", AccessFlags = 33)]
		public partial class BasicHttpResponse : global::Org.Apache.Http.Message.AbstractHttpMessage, global::Org.Apache.Http.IHttpResponse
 /* scope: __dot42__ */ 
		{
				/// <summary>
				/// <para>Creates a new response. This is the constructor to which all others map.</para><para></para>        
				/// </summary>
				[Dot42.DexImport("<init>", "(Lorg/apache/http/StatusLine;Lorg/apache/http/ReasonPhraseCatalog;Ljava/util/Loca" +
    "le;)V", AccessFlags = 1)]
				public BasicHttpResponse(global::Org.Apache.Http.IStatusLine statusline, global::Org.Apache.Http.IReasonPhraseCatalog catalog, global::Java.Util.Locale locale) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Creates a response from a status line. The response will not have a reason phrase catalog and use the system default locale.</para><para></para>        
				/// </summary>
				[Dot42.DexImport("<init>", "(Lorg/apache/http/StatusLine;)V", AccessFlags = 1)]
				public BasicHttpResponse(global::Org.Apache.Http.IStatusLine statusline) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Creates a new response. This is the constructor to which all others map.</para><para></para>        
				/// </summary>
				[Dot42.DexImport("<init>", "(Lorg/apache/http/ProtocolVersion;ILjava/lang/String;)V", AccessFlags = 1)]
				public BasicHttpResponse(global::Org.Apache.Http.ProtocolVersion statusline, int catalog, string locale) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Returns the protocol version this message is compatible with. </para>        
				/// </summary>
				/// <java-name>
				/// getProtocolVersion
				/// </java-name>
				[Dot42.DexImport("getProtocolVersion", "()Lorg/apache/http/ProtocolVersion;", AccessFlags = 1)]
				public override global::Org.Apache.Http.ProtocolVersion GetProtocolVersion() /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.ProtocolVersion);
				}

				/// <summary>
				/// <para>Obtains the status line of this response. The status line can be set using one of the setStatusLine methods, or it can be initialized in a constructor.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the status line, or <code>null</code> if not yet set </para>
				/// </returns>
				/// <java-name>
				/// getStatusLine
				/// </java-name>
				[Dot42.DexImport("getStatusLine", "()Lorg/apache/http/StatusLine;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IStatusLine GetStatusLine() /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IStatusLine);
				}

				/// <summary>
				/// <para>Obtains the message entity of this response, if any. The entity is provided by calling setEntity.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the response entity, or <code>null</code> if there is none </para>
				/// </returns>
				/// <java-name>
				/// getEntity
				/// </java-name>
				[Dot42.DexImport("getEntity", "()Lorg/apache/http/HttpEntity;", AccessFlags = 1)]
				public virtual global::Org.Apache.Http.IHttpEntity GetEntity() /* MethodBuilder.Create */ 
				{
						return default(global::Org.Apache.Http.IHttpEntity);
				}

				/// <summary>
				/// <para>Obtains the locale of this response. The locale is used to determine the reason phrase for the status code. It can be changed using setLocale.</para><para></para>        
				/// </summary>
				/// <returns>
				/// <para>the locale of this response, never <code>null</code> </para>
				/// </returns>
				/// <java-name>
				/// getLocale
				/// </java-name>
				[Dot42.DexImport("getLocale", "()Ljava/util/Locale;", AccessFlags = 1)]
				public virtual global::Java.Util.Locale GetLocale() /* MethodBuilder.Create */ 
				{
						return default(global::Java.Util.Locale);
				}

				/// <java-name>
				/// setStatusLine
				/// </java-name>
				[Dot42.DexImport("setStatusLine", "(Lorg/apache/http/StatusLine;)V", AccessFlags = 1)]
				public virtual void SetStatusLine(global::Org.Apache.Http.IStatusLine statusline) /* MethodBuilder.Create */ 
				{
				}

				/// <java-name>
				/// setStatusLine
				/// </java-name>
				[Dot42.DexImport("setStatusLine", "(Lorg/apache/http/ProtocolVersion;I)V", AccessFlags = 1)]
				public virtual void SetStatusLine(global::Org.Apache.Http.ProtocolVersion ver, int code) /* MethodBuilder.Create */ 
				{
				}

				/// <java-name>
				/// setStatusLine
				/// </java-name>
				[Dot42.DexImport("setStatusLine", "(Lorg/apache/http/ProtocolVersion;ILjava/lang/String;)V", AccessFlags = 1)]
				public virtual void SetStatusLine(global::Org.Apache.Http.ProtocolVersion ver, int code, string reason) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Updates the status line of this response with a new status code. The status line can only be updated if it is available. It must have been set either explicitly or in a constructor. <br></br> The reason phrase will be updated according to the new status code, based on the current locale. It can be set explicitly using setReasonPhrase.</para><para><para>HttpStatus </para><simplesectsep></simplesectsep><para>setStatusLine(StatusLine) </para><simplesectsep></simplesectsep><para>setStatusLine(ProtocolVersion,int) </para></para>        
				/// </summary>
				/// <java-name>
				/// setStatusCode
				/// </java-name>
				[Dot42.DexImport("setStatusCode", "(I)V", AccessFlags = 1)]
				public virtual void SetStatusCode(int code) /* MethodBuilder.Create */ 
				{
				}

				/// <summary>
				/// <para>Updates the status line of this response with a new reason phrase. The status line can only be updated if it is available. It must have been set either explicitly or in a constructor.</para><para><para>setStatusLine(StatusLine) </para><simplesectsep></simplesectsep><para>setStatusLine(ProtocolVersion,int) </para></para>        
				/// </summary>
				/// <java-name>
				/// setReasonPhrase
				/// </java-name>
				[Dot42.DexImport("setReasonPhrase", "(Ljava/lang/String;)V", AccessFlags = 1)]
				public virtual void SetReasonPhrase(string reason) /* MethodBuilder.Create */ 
				{
				}

				/// <java-name>
				/// setEntity
				/// </java-name>
				[Dot42.DexImport("setEntity", "(Lorg/apache/http