com.Tivadar.Best.HTTP.xml

<?xml version="1.0"?>
<doc>
    <assembly>
        <name>com.Tivadar.Best.HTTP</name>
    </assembly>
    <members>
        <member name="T:Best.HTTP.Shared.Compression.Crc.CRC32">
            <summary>
              Computes a CRC-32. The CRC-32 algorithm is parameterized - you
              can set the polynomial and enable or disable bit
              reversal. This can be used for GZIP, BZip2, or ZIP.
            </summary>
            <remarks>
              This type is used internally by DotNetZip; it is generally not used
              directly by applications wishing to create, read, or manipulate zip
              archive files.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Crc.CRC32.TotalBytesRead">
            <summary>
              Indicates the total number of bytes applied to the CRC.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Crc.CRC32.Crc32Result">
            <summary>
            Indicates the current CRC for all blocks slurped in.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Crc.CRC32.GetCrc32(System.IO.Stream)">
            <summary>
            Returns the CRC32 for the specified stream.
            </summary>
            <param name="input">The stream over which to calculate the CRC32</param>
            <returns>the CRC32 calculation</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Crc.CRC32.GetCrc32AndCopy(System.IO.Stream,System.IO.Stream)">
            <summary>
            Returns the CRC32 for the specified stream, and writes the input into the
            output stream.
            </summary>
            <param name="input">The stream over which to calculate the CRC32</param>
            <param name="output">The stream into which to deflate the input</param>
            <returns>the CRC32 calculation</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Crc.CRC32.ComputeCrc32(System.Int32,System.Byte)">
            <summary>
              Get the CRC32 for the given (word,byte) combo.  This is a
              computation defined by PKzip for PKZIP 2.0 (weak) encryption.
            </summary>
            <param name="W">The word to start with.</param>
            <param name="B">The byte to combine it with.</param>
            <returns>The CRC-ized result.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Crc.CRC32.SlurpBlock(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Update the value for the running CRC32 using the given block of bytes.
            This is useful when using the CRC32() class in a Stream.
            </summary>
            <param name="block">block of bytes to slurp</param>
            <param name="offset">starting point in the block</param>
            <param name="count">how many bytes within the block to slurp</param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Crc.CRC32.UpdateCRC(System.Byte)">
            <summary>
              Process one byte in the CRC.
            </summary>
            <param name = "b">the byte to include into the CRC .  </param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Crc.CRC32.UpdateCRC(System.Byte,System.Int32)">
            <summary>
              Process a run of N identical bytes into the CRC.
            </summary>
            <remarks>
              <para>
                This method serves as an optimization for updating the CRC when a
                run of identical bytes is found. Rather than passing in a buffer of
                length n, containing all identical bytes b, this method accepts the
                byte value and the length of the (virtual) buffer - the length of
                the run.
              </para>
            </remarks>
            <param name = "b">the byte to include into the CRC.  </param>
            <param name = "n">the number of times that byte should be repeated. </param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Crc.CRC32.Combine(System.Int32,System.Int32)">
            <summary>
              Combines the given CRC32 value with the current running total.
            </summary>
            <remarks>
              This is useful when using a divide-and-conquer approach to
              calculating a CRC.  Multiple threads can each calculate a
              CRC32 on a segment of the data, and then combine the
              individual CRC32 values at the end.
            </remarks>
            <param name="crc">the crc value to be combined with this one</param>
            <param name="length">the length of data the CRC value was calculated on</param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Crc.CRC32.#ctor">
            <summary>
              Create an instance of the CRC32 class using the default settings: no
              bit reversal, and a polynomial of 0xEDB88320.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Crc.CRC32.#ctor(System.Boolean)">
            <summary>
              Create an instance of the CRC32 class, specifying whether to reverse
              data bits or not.
            </summary>
            <param name='reverseBits'>
              specify true if the instance should reverse data bits.
            </param>
            <remarks>
              <para>
                In the CRC-32 used by BZip2, the bits are reversed. Therefore if you
                want a CRC32 with compatibility with BZip2, you should pass true
                here. In the CRC-32 used by GZIP and PKZIP, the bits are not
                reversed; Therefore if you want a CRC32 with compatibility with
                those, you should pass false.
              </para>
            </remarks>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Crc.CRC32.#ctor(System.Int32,System.Boolean)">
             <summary>
               Create an instance of the CRC32 class, specifying the polynomial and
               whether to reverse data bits or not.
             </summary>
             <param name='polynomial'>
               The polynomial to use for the CRC, expressed in the reversed (LSB)
               format: the highest ordered bit in the polynomial value is the
               coefficient of the 0th power; the second-highest order bit is the
               coefficient of the 1 power, and so on. Expressed this way, the
               polynomial for the CRC-32C used in IEEE 802.3, is 0xEDB88320.
             </param>
             <param name='reverseBits'>
               specify true if the instance should reverse data bits.
             </param>
            
             <remarks>
               <para>
                 In the CRC-32 used by BZip2, the bits are reversed. Therefore if you
                 want a CRC32 with compatibility with BZip2, you should pass true
                 here for the <c>reverseBits</c> parameter. In the CRC-32 used by
                 GZIP and PKZIP, the bits are not reversed; Therefore if you want a
                 CRC32 with compatibility with those, you should pass false for the
                 <c>reverseBits</c> parameter.
               </para>
             </remarks>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Crc.CRC32.Reset">
            <summary>
              Reset the CRC-32 class - clear the CRC "remainder register."
            </summary>
            <remarks>
              <para>
                Use this when employing a single instance of this class to compute
                multiple, distinct CRCs on multiple, distinct data blocks.
              </para>
            </remarks>
        </member>
        <member name="T:Best.HTTP.Shared.Compression.Zlib.DeflateStream">
             <summary>
             A class for compressing and decompressing streams using the Deflate algorithm.
             </summary>
            
             <remarks>
            
             <para>
               The DeflateStream is a <see
               href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a <see
               cref="T:System.IO.Stream"/>.  It adds DEFLATE compression or decompression to any
               stream.
             </para>
            
             <para>
               Using this stream, applications can compress or decompress data via stream
               <c>Read</c> and <c>Write</c> operations.  Either compresssion or decompression
               can occur through either reading or writing. The compression format used is
               DEFLATE, which is documented in <see
               href="http://www.ietf.org/rfc/rfc1951.txt">IETF RFC 1951</see>, "DEFLATE
               Compressed Data Format Specification version 1.3.".
             </para>
            
             </remarks>
            
             <seealso cref="T:Best.HTTP.Shared.Compression.Zlib.GZipStream" />
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.DeflateStream.#ctor(System.IO.Stream,Best.HTTP.Shared.Compression.Zlib.CompressionMode)">
             <summary>
               Create a DeflateStream using the specified CompressionMode.
             </summary>
            
             <remarks>
               When mode is <c>CompressionMode.Compress</c>, the DeflateStream will use
               the default compression level. The "captive" stream will be closed when
               the DeflateStream is closed.
             </remarks>
            
             <example>
             This example uses a DeflateStream to compress data from a file, and writes
             the compressed data to another file.
             <code>
             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
             {
                 using (var raw = System.IO.File.Create(fileToCompress + ".deflated"))
                 {
                     using (Stream compressor = new DeflateStream(raw, CompressionMode.Compress))
                     {
                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];
                         int n;
                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
                         {
                             compressor.Write(buffer, 0, n);
                         }
                     }
                 }
             }
             </code>
            
             <code lang="VB">
             Using input As Stream = File.OpenRead(fileToCompress)
                 Using raw As FileStream = File.Create(fileToCompress &amp; ".deflated")
                     Using compressor As Stream = New DeflateStream(raw, CompressionMode.Compress)
                         Dim buffer As Byte() = New Byte(4096) {}
                         Dim n As Integer = -1
                         Do While (n &lt;&gt; 0)
                             If (n &gt; 0) Then
                                 compressor.Write(buffer, 0, n)
                             End If
                             n = input.Read(buffer, 0, buffer.Length)
                         Loop
                     End Using
                 End Using
             End Using
             </code>
             </example>
             <param name="stream">The stream which will be read or written.</param>
             <param name="mode">Indicates whether the DeflateStream will compress or decompress.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.DeflateStream.#ctor(System.IO.Stream,Best.HTTP.Shared.Compression.Zlib.CompressionMode,Best.HTTP.Shared.Compression.Zlib.CompressionLevel)">
             <summary>
             Create a DeflateStream using the specified CompressionMode and the specified CompressionLevel.
             </summary>
            
             <remarks>
            
             <para>
               When mode is <c>CompressionMode.Decompress</c>, the level parameter is
               ignored.  The "captive" stream will be closed when the DeflateStream is
               closed.
             </para>
            
             </remarks>
            
             <example>
            
               This example uses a DeflateStream to compress data from a file, and writes
               the compressed data to another file.
            
             <code>
             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
             {
                 using (var raw = System.IO.File.Create(fileToCompress + ".deflated"))
                 {
                     using (Stream compressor = new DeflateStream(raw,
                                                                  CompressionMode.Compress,
                                                                  CompressionLevel.BestCompression))
                     {
                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];
                         int n= -1;
                         while (n != 0)
                         {
                             if (n &gt; 0)
                                 compressor.Write(buffer, 0, n);
                             n= input.Read(buffer, 0, buffer.Length);
                         }
                     }
                 }
             }
             </code>
            
             <code lang="VB">
             Using input As Stream = File.OpenRead(fileToCompress)
                 Using raw As FileStream = File.Create(fileToCompress &amp; ".deflated")
                     Using compressor As Stream = New DeflateStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
                         Dim buffer As Byte() = New Byte(4096) {}
                         Dim n As Integer = -1
                         Do While (n &lt;&gt; 0)
                             If (n &gt; 0) Then
                                 compressor.Write(buffer, 0, n)
                             End If
                             n = input.Read(buffer, 0, buffer.Length)
                         Loop
                     End Using
                 End Using
             End Using
             </code>
             </example>
             <param name="stream">The stream to be read or written while deflating or inflating.</param>
             <param name="mode">Indicates whether the <c>DeflateStream</c> will compress or decompress.</param>
             <param name="level">A tuning knob to trade speed for effectiveness.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.DeflateStream.#ctor(System.IO.Stream,Best.HTTP.Shared.Compression.Zlib.CompressionMode,System.Boolean)">
             <summary>
               Create a <c>DeflateStream</c> using the specified
               <c>CompressionMode</c>, and explicitly specify whether the
               stream should be left open after Deflation or Inflation.
             </summary>
            
             <remarks>
            
             <para>
               This constructor allows the application to request that the captive stream
               remain open after the deflation or inflation occurs.  By default, after
               <c>Close()</c> is called on the stream, the captive stream is also
               closed. In some cases this is not desired, for example if the stream is a
               memory stream that will be re-read after compression.  Specify true for
               the <paramref name="leaveOpen"/> parameter to leave the stream open.
             </para>
            
             <para>
               The <c>DeflateStream</c> will use the default compression level.
             </para>
            
             <para>
               See the other overloads of this constructor for example code.
             </para>
             </remarks>
            
             <param name="stream">
               The stream which will be read or written. This is called the
               "captive" stream in other places in this documentation.
             </param>
            
             <param name="mode">
               Indicates whether the <c>DeflateStream</c> will compress or decompress.
             </param>
            
             <param name="leaveOpen">true if the application would like the stream to
             remain open after inflation/deflation.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.DeflateStream.#ctor(System.IO.Stream,Best.HTTP.Shared.Compression.Zlib.CompressionMode,Best.HTTP.Shared.Compression.Zlib.CompressionLevel,System.Boolean)">
             <summary>
               Create a <c>DeflateStream</c> using the specified <c>CompressionMode</c>
               and the specified <c>CompressionLevel</c>, and explicitly specify whether
               the stream should be left open after Deflation or Inflation.
             </summary>
            
             <remarks>
            
             <para>
               When mode is <c>CompressionMode.Decompress</c>, the level parameter is ignored.
             </para>
            
             <para>
               This constructor allows the application to request that the captive stream
               remain open after the deflation or inflation occurs.  By default, after
               <c>Close()</c> is called on the stream, the captive stream is also
               closed. In some cases this is not desired, for example if the stream is a
               <see cref="T:System.IO.MemoryStream"/> that will be re-read after
               compression.  Specify true for the <paramref name="leaveOpen"/> parameter
               to leave the stream open.
             </para>
            
             </remarks>
            
             <example>
            
               This example shows how to use a <c>DeflateStream</c> to compress data from
               a file, and store the compressed data into another file.
            
             <code>
             using (var output = System.IO.File.Create(fileToCompress + ".deflated"))
             {
                 using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
                 {
                     using (Stream compressor = new DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))
                     {
                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];
                         int n= -1;
                         while (n != 0)
                         {
                             if (n &gt; 0)
                                 compressor.Write(buffer, 0, n);
                             n= input.Read(buffer, 0, buffer.Length);
                         }
                     }
                 }
                 // can write additional data to the output stream here
             }
             </code>
            
             <code lang="VB">
             Using output As FileStream = File.Create(fileToCompress &amp; ".deflated")
                 Using input As Stream = File.OpenRead(fileToCompress)
                     Using compressor As Stream = New DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)
                         Dim buffer As Byte() = New Byte(4096) {}
                         Dim n As Integer = -1
                         Do While (n &lt;&gt; 0)
                             If (n &gt; 0) Then
                                 compressor.Write(buffer, 0, n)
                             End If
                             n = input.Read(buffer, 0, buffer.Length)
                         Loop
                     End Using
                 End Using
                 ' can write additional data to the output stream here.
             End Using
             </code>
             </example>
             <param name="stream">The stream which will be read or written.</param>
             <param name="mode">Indicates whether the DeflateStream will compress or decompress.</param>
             <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>
             <param name="level">A tuning knob to trade speed for effectiveness.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.DeflateStream.#ctor(System.IO.Stream,Best.HTTP.Shared.Compression.Zlib.CompressionMode,Best.HTTP.Shared.Compression.Zlib.CompressionLevel,System.Boolean,System.Int32)">
             <summary>
               Create a <c>DeflateStream</c> using the specified <c>CompressionMode</c>
               and the specified <c>CompressionLevel</c>, and explicitly specify whether
               the stream should be left open after Deflation or Inflation.
             </summary>
            
             <remarks>
            
             <para>
               When mode is <c>CompressionMode.Decompress</c>, the level parameter is ignored.
             </para>
            
             <para>
               This constructor allows the application to request that the captive stream
               remain open after the deflation or inflation occurs.  By default, after
               <c>Close()</c> is called on the stream, the captive stream is also
               closed. In some cases this is not desired, for example if the stream is a
               <see cref="T:System.IO.MemoryStream"/> that will be re-read after
               compression.  Specify true for the <paramref name="leaveOpen"/> parameter
               to leave the stream open.
             </para>
            
             </remarks>
            
             <example>
            
               This example shows how to use a <c>DeflateStream</c> to compress data from
               a file, and store the compressed data into another file.
            
             <code>
             using (var output = System.IO.File.Create(fileToCompress + ".deflated"))
             {
                 using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
                 {
                     using (Stream compressor = new DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, true))
                     {
                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];
                         int n= -1;
                         while (n != 0)
                         {
                             if (n &gt; 0)
                                 compressor.Write(buffer, 0, n);
                             n= input.Read(buffer, 0, buffer.Length);
                         }
                     }
                 }
                 // can write additional data to the output stream here
             }
             </code>
            
             <code lang="VB">
             Using output As FileStream = File.Create(fileToCompress &amp; ".deflated")
                 Using input As Stream = File.OpenRead(fileToCompress)
                     Using compressor As Stream = New DeflateStream(output, CompressionMode.Compress, CompressionLevel.BestCompression, True)
                         Dim buffer As Byte() = New Byte(4096) {}
                         Dim n As Integer = -1
                         Do While (n &lt;&gt; 0)
                             If (n &gt; 0) Then
                                 compressor.Write(buffer, 0, n)
                             End If
                             n = input.Read(buffer, 0, buffer.Length)
                         Loop
                     End Using
                 End Using
                 ' can write additional data to the output stream here.
             End Using
             </code>
             </example>
             <param name="stream">The stream which will be read or written.</param>
             <param name="mode">Indicates whether the DeflateStream will compress or decompress.</param>
             <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>
             <param name="level">A tuning knob to trade speed for effectiveness.</param>
             <param name="windowBits">Desired window bits.</param>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.DeflateStream.FlushMode">
            <summary>
            This property sets the flush behavior on the stream.
            </summary>
            <remarks> See the ZLIB documentation for the meaning of the flush behavior.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.DeflateStream.BufferSize">
             <summary>
               The size of the working buffer for the compression codec.
             </summary>
            
             <remarks>
             <para>
               The working buffer is used for all stream operations.  The default size is
               1024 bytes.  The minimum size is 128 bytes. You may get better performance
               with a larger buffer.  Then again, you might not.  You would have to test
               it.
             </para>
            
             <para>
               Set this before the first call to <c>Read()</c> or <c>Write()</c> on the
               stream. If you try to set it afterwards, it will throw.
             </para>
             </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.DeflateStream.Strategy">
             <summary>
               The ZLIB strategy to be used during compression.
             </summary>
            
             <remarks>
               By tweaking this parameter, you may be able to optimize the compression for
               data with particular characteristics.
             </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.DeflateStream.TotalIn">
            <summary> Returns the total number of bytes input so far.</summary>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.DeflateStream.TotalOut">
            <summary> Returns the total number of bytes output so far.</summary>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.DeflateStream.Dispose(System.Boolean)">
            <summary>
              Dispose the stream.
            </summary>
            <remarks>
              <para>
                This may or may not result in a <c>Close()</c> call on the captive
                stream.  See the constructors that have a <c>leaveOpen</c> parameter
                for more information.
              </para>
              <para>
                Application code won't call this code directly.  This method may be
                invoked in two distinct scenarios.  If disposing == true, the method
                has been called directly or indirectly by a user's code, for example
                via the public Dispose() method. In this case, both managed and
                unmanaged resources can be referenced and disposed.  If disposing ==
                false, the method has been called by the runtime from inside the
                object finalizer and this method should not reference other objects;
                in that case only unmanaged resources must be referenced or
                disposed.
              </para>
            </remarks>
            <param name="disposing">
              true if the Dispose method was invoked by user code.
            </param>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.DeflateStream.CanRead">
            <summary>
            Indicates whether the stream can be read.
            </summary>
            <remarks>
            The return value depends on whether the captive stream supports reading.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.DeflateStream.CanSeek">
            <summary>
            Indicates whether the stream supports Seek operations.
            </summary>
            <remarks>
            Always returns false.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.DeflateStream.CanWrite">
            <summary>
            Indicates whether the stream can be written.
            </summary>
            <remarks>
            The return value depends on whether the captive stream supports writing.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.DeflateStream.Flush">
            <summary>
            Flush the stream.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.DeflateStream.Length">
            <summary>
            Reading this property always throws a <see cref="T:System.NotImplementedException"/>.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.DeflateStream.Position">
             <summary>
             The position of the stream pointer.
             </summary>
            
             <remarks>
               Setting this property always throws a <see
               cref="T:System.NotImplementedException"/>. Reading will return the total bytes
               written out, if used in writing, or the total bytes read in, if used in
               reading.  The count may refer to compressed bytes or uncompressed bytes,
               depending on how you've used the stream.
             </remarks>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.DeflateStream.Read(System.Byte[],System.Int32,System.Int32)">
             <summary>
             Read data from the stream.
             </summary>
             <remarks>
            
             <para>
               If you wish to use the <c>DeflateStream</c> to compress data while
               reading, you can create a <c>DeflateStream</c> with
               <c>CompressionMode.Compress</c>, providing an uncompressed data stream.
               Then call Read() on that <c>DeflateStream</c>, and the data read will be
               compressed as you read.  If you wish to use the <c>DeflateStream</c> to
               decompress data while reading, you can create a <c>DeflateStream</c> with
               <c>CompressionMode.Decompress</c>, providing a readable compressed data
               stream.  Then call Read() on that <c>DeflateStream</c>, and the data read
               will be decompressed as you read.
             </para>
            
             <para>
               A <c>DeflateStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not both.
             </para>
            
             </remarks>
             <param name="buffer">The buffer into which the read data should be placed.</param>
             <param name="offset">the offset within that data array to put the first byte read.</param>
             <param name="count">the number of bytes to read.</param>
             <returns>the number of bytes actually read</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.DeflateStream.Seek(System.Int64,System.IO.SeekOrigin)">
            <summary>
            Calling this method always throws a <see cref="T:System.NotImplementedException"/>.
            </summary>
            <param name="offset">this is irrelevant, since it will always throw!</param>
            <param name="origin">this is irrelevant, since it will always throw!</param>
            <returns>irrelevant!</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.DeflateStream.SetLength(System.Int64)">
            <summary>
            Will call the base stream's SetLength method.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.DeflateStream.Write(System.Byte[],System.Int32,System.Int32)">
             <summary>
               Write data to the stream.
             </summary>
             <remarks>
            
             <para>
               If you wish to use the <c>DeflateStream</c> to compress data while
               writing, you can create a <c>DeflateStream</c> with
               <c>CompressionMode.Compress</c>, and a writable output stream.  Then call
               <c>Write()</c> on that <c>DeflateStream</c>, providing uncompressed data
               as input.  The data sent to the output stream will be the compressed form
               of the data written.  If you wish to use the <c>DeflateStream</c> to
               decompress data while writing, you can create a <c>DeflateStream</c> with
               <c>CompressionMode.Decompress</c>, and a writable output stream.  Then
               call <c>Write()</c> on that stream, providing previously compressed
               data. The data sent to the output stream will be the decompressed form of
               the data written.
             </para>
            
             <para>
               A <c>DeflateStream</c> can be used for <c>Read()</c> or <c>Write()</c>,
               but not both.
             </para>
            
             </remarks>
            
             <param name="buffer">The buffer holding data to write to the stream.</param>
             <param name="offset">the offset within that data array to find the first byte to write.</param>
             <param name="count">the number of bytes to write.</param>
        </member>
        <member name="T:Best.HTTP.Shared.Compression.Zlib.GZipStream">
             <summary>
               A class for compressing and decompressing GZIP streams.
             </summary>
             <remarks>
            
             <para>
               The <c>GZipStream</c> is a <see
               href="http://en.wikipedia.org/wiki/Decorator_pattern">Decorator</see> on a
               <see cref="T:System.IO.Stream"/>. It adds GZIP compression or decompression to any
               stream.
             </para>
            
             <para>
               Like the <c>System.IO.Compression.GZipStream</c> in the .NET Base Class Library, the
               <c>Ionic.Zlib.GZipStream</c> can compress while writing, or decompress while
               reading, but not vice versa.  The compression method used is GZIP, which is
               documented in <see href="http://www.ietf.org/rfc/rfc1952.txt">IETF RFC
               1952</see>, "GZIP file format specification version 4.3".</para>
            
             <para>
               A <c>GZipStream</c> can be used to decompress data (through <c>Read()</c>) or
               to compress data (through <c>Write()</c>), but not both.
             </para>
            
             <para>
               If you wish to use the <c>GZipStream</c> to compress data, you must wrap it
               around a write-able stream. As you call <c>Write()</c> on the <c>GZipStream</c>, the
               data will be compressed into the GZIP format.  If you want to decompress data,
               you must wrap the <c>GZipStream</c> around a readable stream that contains an
               IETF RFC 1952-compliant stream.  The data will be decompressed as you call
               <c>Read()</c> on the <c>GZipStream</c>.
             </para>
            
             <para>
               Though the GZIP format allows data from multiple files to be concatenated
               together, this stream handles only a single segment of GZIP format, typically
               representing a single file.
             </para>
            
             </remarks>
            
             <seealso cref="T:Best.HTTP.Shared.Compression.Zlib.DeflateStream" />
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.Comment">
             <summary>
               The comment on the GZIP stream.
             </summary>
            
             <remarks>
             <para>
               The GZIP format allows for each file to optionally have an associated
               comment stored with the file.  The comment is encoded with the ISO-8859-1
               code page.  To include a comment in a GZIP stream you create, set this
               property before calling <c>Write()</c> for the first time on the
               <c>GZipStream</c>.
             </para>
            
             <para>
               When using <c>GZipStream</c> to decompress, you can retrieve this property
               after the first call to <c>Read()</c>.  If no comment has been set in the
               GZIP bytestream, the Comment property will return <c>null</c>
               (<c>Nothing</c> in VB).
             </para>
             </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.FileName">
             <summary>
               The FileName for the GZIP stream.
             </summary>
            
             <remarks>
            
             <para>
               The GZIP format optionally allows each file to have an associated
               filename.  When compressing data (through <c>Write()</c>), set this
               FileName before calling <c>Write()</c> the first time on the <c>GZipStream</c>.
               The actual filename is encoded into the GZIP bytestream with the
               ISO-8859-1 code page, according to RFC 1952. It is the application's
               responsibility to insure that the FileName can be encoded and decoded
               correctly with this code page.
             </para>
            
             <para>
               When decompressing (through <c>Read()</c>), you can retrieve this value
               any time after the first <c>Read()</c>.  In the case where there was no filename
               encoded into the GZIP bytestream, the property will return <c>null</c> (<c>Nothing</c>
               in VB).
             </para>
             </remarks>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.GZipStream.LastModified">
             <summary>
               The last modified time for the GZIP stream.
             </summary>
            
             <remarks>
               GZIP allows the storage of a last modified time with each GZIP entity.
               When compressing data, you can set this before the first call to
               <c>Write()</c>.  When decompressing, you can retrieve this value any time
               after the first call to <c>Read()</c>.
             </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.Crc32">
            <summary>
            The CRC on the GZIP stream.
            </summary>
            <remarks>
            This is used for internal error checking. You probably don't need to look at this property.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.GZipStream.#ctor(System.IO.Stream,Best.HTTP.Shared.Compression.Zlib.CompressionMode)">
             <summary>
               Create a <c>GZipStream</c> using the specified <c>CompressionMode</c>.
             </summary>
             <remarks>
            
             <para>
               When mode is <c>CompressionMode.Compress</c>, the <c>GZipStream</c> will use the
               default compression level.
             </para>
            
             <para>
               As noted in the class documentation, the <c>CompressionMode</c> (Compress
               or Decompress) also establishes the "direction" of the stream.  A
               <c>GZipStream</c> with <c>CompressionMode.Compress</c> works only through
               <c>Write()</c>.  A <c>GZipStream</c> with
               <c>CompressionMode.Decompress</c> works only through <c>Read()</c>.
             </para>
            
             </remarks>
            
             <example>
               This example shows how to use a GZipStream to compress data.
             <code>
             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
             {
                 using (var raw = System.IO.File.Create(outputFile))
                 {
                     using (Stream compressor = new GZipStream(raw, CompressionMode.Compress))
                     {
                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];
                         int n;
                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
                         {
                             compressor.Write(buffer, 0, n);
                         }
                     }
                 }
             }
             </code>
             <code lang="VB">
             Dim outputFile As String = (fileToCompress &amp; ".compressed")
             Using input As Stream = File.OpenRead(fileToCompress)
                 Using raw As FileStream = File.Create(outputFile)
                 Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress)
                     Dim buffer As Byte() = New Byte(4096) {}
                     Dim n As Integer = -1
                     Do While (n &lt;&gt; 0)
                         If (n &gt; 0) Then
                             compressor.Write(buffer, 0, n)
                         End If
                         n = input.Read(buffer, 0, buffer.Length)
                     Loop
                 End Using
                 End Using
             End Using
             </code>
             </example>
            
             <example>
             This example shows how to use a GZipStream to uncompress a file.
             <code>
             private void GunZipFile(string filename)
             {
                 if (!filename.EndsWith(".gz))
                     throw new ArgumentException("filename");
                 var DecompressedFile = filename.Substring(0,filename.Length-3);
                 byte[] working = new byte[WORKING_BUFFER_SIZE];
                 int n= 1;
                 using (System.IO.Stream input = System.IO.File.OpenRead(filename))
                 {
                     using (Stream decompressor= new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, true))
                     {
                         using (var output = System.IO.File.Create(DecompressedFile))
                         {
                             while (n !=0)
                             {
                                 n= decompressor.Read(working, 0, working.Length);
                                 if (n > 0)
                                 {
                                     output.Write(working, 0, n);
                                 }
                             }
                         }
                     }
                 }
             }
             </code>
            
             <code lang="VB">
             Private Sub GunZipFile(ByVal filename as String)
                 If Not (filename.EndsWith(".gz)) Then
                     Throw New ArgumentException("filename")
                 End If
                 Dim DecompressedFile as String = filename.Substring(0,filename.Length-3)
                 Dim working(WORKING_BUFFER_SIZE) as Byte
                 Dim n As Integer = 1
                 Using input As Stream = File.OpenRead(filename)
                     Using decompressor As Stream = new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, True)
                         Using output As Stream = File.Create(UncompressedFile)
                             Do
                                 n= decompressor.Read(working, 0, working.Length)
                                 If n > 0 Then
                                     output.Write(working, 0, n)
                                 End IF
                             Loop While (n  > 0)
                         End Using
                     End Using
                 End Using
             End Sub
             </code>
             </example>
            
             <param name="stream">The stream which will be read or written.</param>
             <param name="mode">Indicates whether the GZipStream will compress or decompress.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.GZipStream.#ctor(System.IO.Stream,Best.HTTP.Shared.Compression.Zlib.CompressionMode,Best.HTTP.Shared.Compression.Zlib.CompressionLevel)">
             <summary>
               Create a <c>GZipStream</c> using the specified <c>CompressionMode</c> and
               the specified <c>CompressionLevel</c>.
             </summary>
             <remarks>
            
             <para>
               The <c>CompressionMode</c> (Compress or Decompress) also establishes the
               "direction" of the stream.  A <c>GZipStream</c> with
               <c>CompressionMode.Compress</c> works only through <c>Write()</c>.  A
               <c>GZipStream</c> with <c>CompressionMode.Decompress</c> works only
               through <c>Read()</c>.
             </para>
            
             </remarks>
            
             <example>
            
             This example shows how to use a <c>GZipStream</c> to compress a file into a .gz file.
            
             <code>
             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
             {
                 using (var raw = System.IO.File.Create(fileToCompress + ".gz"))
                 {
                     using (Stream compressor = new GZipStream(raw,
                                                               CompressionMode.Compress,
                                                               CompressionLevel.BestCompression))
                     {
                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];
                         int n;
                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
                         {
                             compressor.Write(buffer, 0, n);
                         }
                     }
                 }
             }
             </code>
            
             <code lang="VB">
             Using input As Stream = File.OpenRead(fileToCompress)
                 Using raw As FileStream = File.Create(fileToCompress &amp; ".gz")
                     Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression)
                         Dim buffer As Byte() = New Byte(4096) {}
                         Dim n As Integer = -1
                         Do While (n &lt;&gt; 0)
                             If (n &gt; 0) Then
                                 compressor.Write(buffer, 0, n)
                             End If
                             n = input.Read(buffer, 0, buffer.Length)
                         Loop
                     End Using
                 End Using
             End Using
             </code>
             </example>
             <param name="stream">The stream to be read or written while deflating or inflating.</param>
             <param name="mode">Indicates whether the <c>GZipStream</c> will compress or decompress.</param>
             <param name="level">A tuning knob to trade speed for effectiveness.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.GZipStream.#ctor(System.IO.Stream,Best.HTTP.Shared.Compression.Zlib.CompressionMode,System.Boolean)">
             <summary>
               Create a <c>GZipStream</c> using the specified <c>CompressionMode</c>, and
               explicitly specify whether the stream should be left open after Deflation
               or Inflation.
             </summary>
            
             <remarks>
             <para>
               This constructor allows the application to request that the captive stream
               remain open after the deflation or inflation occurs.  By default, after
               <c>Close()</c> is called on the stream, the captive stream is also
               closed. In some cases this is not desired, for example if the stream is a
               memory stream that will be re-read after compressed data has been written
               to it.  Specify true for the <paramref name="leaveOpen"/> parameter to leave
               the stream open.
             </para>
            
             <para>
               The <see cref="T:Best.HTTP.Shared.Compression.Zlib.CompressionMode"/> (Compress or Decompress) also
               establishes the "direction" of the stream.  A <c>GZipStream</c> with
               <c>CompressionMode.Compress</c> works only through <c>Write()</c>.  A <c>GZipStream</c>
               with <c>CompressionMode.Decompress</c> works only through <c>Read()</c>.
             </para>
            
             <para>
               The <c>GZipStream</c> will use the default compression level. If you want
               to specify the compression level, see <see cref="M:Best.HTTP.Shared.Compression.Zlib.GZipStream.#ctor(System.IO.Stream,Best.HTTP.Shared.Compression.Zlib.CompressionMode,Best.HTTP.Shared.Compression.Zlib.CompressionLevel,System.Boolean)"/>.
             </para>
            
             <para>
               See the other overloads of this constructor for example code.
             </para>
            
             </remarks>
            
             <param name="stream">
               The stream which will be read or written. This is called the "captive"
               stream in other places in this documentation.
             </param>
            
             <param name="mode">Indicates whether the GZipStream will compress or decompress.
             </param>
            
             <param name="leaveOpen">
               true if the application would like the base stream to remain open after
               inflation/deflation.
             </param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.GZipStream.#ctor(System.IO.Stream,Best.HTTP.Shared.Compression.Zlib.CompressionMode,Best.HTTP.Shared.Compression.Zlib.CompressionLevel,System.Boolean)">
             <summary>
               Create a <c>GZipStream</c> using the specified <c>CompressionMode</c> and the
               specified <c>CompressionLevel</c>, and explicitly specify whether the
               stream should be left open after Deflation or Inflation.
             </summary>
            
             <remarks>
            
             <para>
               This constructor allows the application to request that the captive stream
               remain open after the deflation or inflation occurs.  By default, after
               <c>Close()</c> is called on the stream, the captive stream is also
               closed. In some cases this is not desired, for example if the stream is a
               memory stream that will be re-read after compressed data has been written
               to it.  Specify true for the <paramref name="leaveOpen"/> parameter to
               leave the stream open.
             </para>
            
             <para>
               As noted in the class documentation, the <c>CompressionMode</c> (Compress
               or Decompress) also establishes the "direction" of the stream.  A
               <c>GZipStream</c> with <c>CompressionMode.Compress</c> works only through
               <c>Write()</c>.  A <c>GZipStream</c> with <c>CompressionMode.Decompress</c> works only
               through <c>Read()</c>.
             </para>
            
             </remarks>
            
             <example>
               This example shows how to use a <c>GZipStream</c> to compress data.
             <code>
             using (System.IO.Stream input = System.IO.File.OpenRead(fileToCompress))
             {
                 using (var raw = System.IO.File.Create(outputFile))
                 {
                     using (Stream compressor = new GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, true))
                     {
                         byte[] buffer = new byte[WORKING_BUFFER_SIZE];
                         int n;
                         while ((n= input.Read(buffer, 0, buffer.Length)) != 0)
                         {
                             compressor.Write(buffer, 0, n);
                         }
                     }
                 }
             }
             </code>
             <code lang="VB">
             Dim outputFile As String = (fileToCompress &amp; ".compressed")
             Using input As Stream = File.OpenRead(fileToCompress)
                 Using raw As FileStream = File.Create(outputFile)
                 Using compressor As Stream = New GZipStream(raw, CompressionMode.Compress, CompressionLevel.BestCompression, True)
                     Dim buffer As Byte() = New Byte(4096) {}
                     Dim n As Integer = -1
                     Do While (n &lt;&gt; 0)
                         If (n &gt; 0) Then
                             compressor.Write(buffer, 0, n)
                         End If
                         n = input.Read(buffer, 0, buffer.Length)
                     Loop
                 End Using
                 End Using
             End Using
             </code>
             </example>
             <param name="stream">The stream which will be read or written.</param>
             <param name="mode">Indicates whether the GZipStream will compress or decompress.</param>
             <param name="leaveOpen">true if the application would like the stream to remain open after inflation/deflation.</param>
             <param name="level">A tuning knob to trade speed for effectiveness.</param>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.FlushMode">
            <summary>
            This property sets the flush behavior on the stream.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.BufferSize">
             <summary>
               The size of the working buffer for the compression codec.
             </summary>
            
             <remarks>
             <para>
               The working buffer is used for all stream operations.  The default size is
               1024 bytes.  The minimum size is 128 bytes. You may get better performance
               with a larger buffer.  Then again, you might not.  You would have to test
               it.
             </para>
            
             <para>
               Set this before the first call to <c>Read()</c> or <c>Write()</c> on the
               stream. If you try to set it afterwards, it will throw.
             </para>
             </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.TotalIn">
            <summary> Returns the total number of bytes input so far.</summary>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.TotalOut">
            <summary> Returns the total number of bytes output so far.</summary>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.GZipStream.Dispose(System.Boolean)">
            <summary>
              Dispose the stream.
            </summary>
            <remarks>
              <para>
                This may or may not result in a <c>Close()</c> call on the captive
                stream.  See the constructors that have a <c>leaveOpen</c> parameter
                for more information.
              </para>
              <para>
                This method may be invoked in two distinct scenarios.  If disposing
                == true, the method has been called directly or indirectly by a
                user's code, for example via the public Dispose() method. In this
                case, both managed and unmanaged resources can be referenced and
                disposed.  If disposing == false, the method has been called by the
                runtime from inside the object finalizer and this method should not
                reference other objects; in that case only unmanaged resources must
                be referenced or disposed.
              </para>
            </remarks>
            <param name="disposing">
              indicates whether the Dispose method was invoked by user code.
            </param>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.CanRead">
            <summary>
            Indicates whether the stream can be read.
            </summary>
            <remarks>
            The return value depends on whether the captive stream supports reading.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.CanSeek">
            <summary>
            Indicates whether the stream supports Seek operations.
            </summary>
            <remarks>
            Always returns false.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.CanWrite">
            <summary>
            Indicates whether the stream can be written.
            </summary>
            <remarks>
            The return value depends on whether the captive stream supports writing.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.GZipStream.Flush">
            <summary>
            Flush the stream.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.Length">
            <summary>
            Reading this property always throws a <see cref="T:System.NotImplementedException"/>.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.GZipStream.Position">
             <summary>
               The position of the stream pointer.
             </summary>
            
             <remarks>
               Setting this property always throws a <see
               cref="T:System.NotImplementedException"/>. Reading will return the total bytes
               written out, if used in writing, or the total bytes read in, if used in
               reading.  The count may refer to compressed bytes or uncompressed bytes,
               depending on how you've used the stream.
             </remarks>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.GZipStream.Read(System.Byte[],System.Int32,System.Int32)">
             <summary>
               Read and decompress data from the source stream.
             </summary>
            
             <remarks>
               With a <c>GZipStream</c>, decompression is done through reading.
             </remarks>
            
             <example>
             <code>
             byte[] working = new byte[WORKING_BUFFER_SIZE];
             using (System.IO.Stream input = System.IO.File.OpenRead(_CompressedFile))
             {
                 using (Stream decompressor= new Ionic.Zlib.GZipStream(input, CompressionMode.Decompress, true))
                 {
                     using (var output = System.IO.File.Create(_DecompressedFile))
                     {
                         int n;
                         while ((n= decompressor.Read(working, 0, working.Length)) !=0)
                         {
                             output.Write(working, 0, n);
                         }
                     }
                 }
             }
             </code>
             </example>
             <param name="buffer">The buffer into which the decompressed data should be placed.</param>
             <param name="offset">the offset within that data array to put the first byte read.</param>
             <param name="count">the number of bytes to read.</param>
             <returns>the number of bytes actually read</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.GZipStream.Seek(System.Int64,System.IO.SeekOrigin)">
            <summary>
              Calling this method always throws a <see cref="T:System.NotImplementedException"/>.
            </summary>
            <param name="offset">irrelevant; it will always throw!</param>
            <param name="origin">irrelevant; it will always throw!</param>
            <returns>irrelevant!</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.GZipStream.SetLength(System.Int64)">
            <summary>
              Calling this method always throws a <see cref="T:System.NotImplementedException"/>.
            </summary>
            <param name="value">irrelevant; this method will always throw!</param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.GZipStream.Write(System.Byte[],System.Int32,System.Int32)">
             <summary>
               Write data to the stream.
             </summary>
            
             <remarks>
             <para>
               If you wish to use the <c>GZipStream</c> to compress data while writing,
               you can create a <c>GZipStream</c> with <c>CompressionMode.Compress</c>, and a
               writable output stream.  Then call <c>Write()</c> on that <c>GZipStream</c>,
               providing uncompressed data as input.  The data sent to the output stream
               will be the compressed form of the data written.
             </para>
            
             <para>
               A <c>GZipStream</c> can be used for <c>Read()</c> or <c>Write()</c>, but not
               both. Writing implies compression.  Reading implies decompression.
             </para>
            
             </remarks>
             <param name="buffer">The buffer holding data to write to the stream.</param>
             <param name="offset">the offset within that data array to find the first byte to write.</param>
             <param name="count">the number of bytes to write.</param>
        </member>
        <member name="T:Best.HTTP.Shared.Compression.Zlib.FlushType">
            <summary>
            Describes how to flush the current deflate operation.
            </summary>
            <remarks>
            The different FlushType values are useful when using a Deflate in a streaming application.
            </remarks>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.FlushType.None">
            <summary>No flush at all.</summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.FlushType.Partial">
            <summary>Closes the current block, but doesn't flush it to
            the output. Used internally only in hypothetical
            scenarios.  This was supposed to be removed by Zlib, but it is
            still in use in some edge cases.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.FlushType.Sync">
            <summary>
            Use this during compression to specify that all pending output should be
            flushed to the output buffer and the output should be aligned on a byte
            boundary.  You might use this in a streaming communication scenario, so that
            the decompressor can get all input data available so far.  When using this
            with a ZlibCodec, <c>AvailableBytesIn</c> will be zero after the call if
            enough output space has been provided before the call.  Flushing will
            degrade compression and so it should be used only when necessary.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.FlushType.Full">
            <summary>
            Use this during compression to specify that all output should be flushed, as
            with <c>FlushType.Sync</c>, but also, the compression state should be reset
            so that decompression can restart from this point if previous compressed
            data has been damaged or if random access is desired.  Using
            <c>FlushType.Full</c> too often can significantly degrade the compression.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.FlushType.Finish">
            <summary>Signals the end of the compression/decompression stream.</summary>
        </member>
        <member name="T:Best.HTTP.Shared.Compression.Zlib.CompressionLevel">
            <summary>
            The compression level to be used when using a DeflateStream or ZlibStream with CompressionMode.Compress.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.None">
            <summary>
            None means that the data will be simply stored, with no change at all.
            If you are producing ZIPs for use on Mac OSX, be aware that archives produced with CompressionLevel.None
            cannot be opened with the default zip reader. Use a different CompressionLevel.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.Level0">
            <summary>
            Same as None.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.BestSpeed">
            <summary>
            The fastest but least effective compression.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.Level1">
            <summary>
            A synonym for BestSpeed.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.Level2">
            <summary>
            A little slower, but better, than level 1.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.Level3">
            <summary>
            A little slower, but better, than level 2.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.Level4">
            <summary>
            A little slower, but better, than level 3.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.Level5">
            <summary>
            A little slower than level 4, but with better compression.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.Default">
            <summary>
            The default compression level, with a good balance of speed and compression efficiency.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.Level6">
            <summary>
            A synonym for Default.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.Level7">
            <summary>
            Pretty good compression!
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.Level8">
            <summary>
             Better compression than Level7!
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.BestCompression">
            <summary>
            The "best" compression, where best means greatest reduction in size of the input data stream.
            This is also the slowest compression.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionLevel.Level9">
            <summary>
            A synonym for BestCompression.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Compression.Zlib.CompressionStrategy">
            <summary>
            Describes options for how the compression algorithm is executed.  Different strategies
            work better on different sorts of data.  The strategy parameter can affect the compression
            ratio and the speed of compression but not the correctness of the compresssion.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionStrategy.Default">
            <summary>
            The default strategy is probably the best for normal data.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionStrategy.Filtered">
            <summary>
            The <c>Filtered</c> strategy is intended to be used most effectively with data produced by a
            filter or predictor.  By this definition, filtered data consists mostly of small
            values with a somewhat random distribution.  In this case, the compression algorithm
            is tuned to compress them better.  The effect of <c>Filtered</c> is to force more Huffman
            coding and less string matching; it is a half-step between <c>Default</c> and <c>HuffmanOnly</c>.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionStrategy.HuffmanOnly">
            <summary>
            Using <c>HuffmanOnly</c> will force the compressor to do Huffman encoding only, with no
            string matching.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Compression.Zlib.CompressionMode">
            <summary>
            An enum to specify the direction of transcoding - whether to compress or decompress.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionMode.Compress">
            <summary>
            Used to specify that the stream should compress the data.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.CompressionMode.Decompress">
            <summary>
            Used to specify that the stream should decompress the data.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Compression.Zlib.ZlibException">
            <summary>
            A general purpose exception class for exceptions in the Zlib library.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibException.#ctor">
            <summary>
            The ZlibException class captures exception information generated
            by the Zlib library.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibException.#ctor(System.String)">
            <summary>
            This ctor collects a message attached to the exception.
            </summary>
            <param name="s">the message for the exception.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.SharedUtils.URShift(System.Int32,System.Int32)">
            <summary>
            Performs an unsigned bitwise right shift with the specified number
            </summary>
            <param name="number">Number to operate on</param>
            <param name="bits">Ammount of bits to shift</param>
            <returns>The resulting number from the shift operation</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.SharedUtils.ReadInput(System.IO.TextReader,System.Byte[],System.Int32,System.Int32)">
             <summary>
               Reads a number of characters from the current source TextReader and writes
               the data to the target array at the specified index.
             </summary>
            
             <param name="sourceTextReader">The source TextReader to read from</param>
             <param name="target">Contains the array of characteres read from the source TextReader.</param>
             <param name="start">The starting index of the target array.</param>
             <param name="count">The maximum number of characters to read from the source TextReader.</param>
            
             <returns>
               The number of characters read. The number will be less than or equal to
               count depending on the data available in the source TextReader. Returns -1
               if the end of the stream is reached.
             </returns>
        </member>
        <member name="T:Best.HTTP.Shared.Compression.Zlib.Adler">
             <summary>
             Computes an Adler-32 checksum.
             </summary>
             <remarks>
             The Adler checksum is similar to a CRC checksum, but faster to compute, though less
             reliable.  It is used in producing RFC1950 compressed streams.  The Adler checksum
             is a required part of the "ZLIB" standard.  Applications will almost never need to
             use this class directly.
             </remarks>
            
             <exclude/>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.Adler.Adler32(System.UInt32,System.Byte[],System.Int32,System.Int32)">
            <summary>
              Calculates the Adler32 checksum.
            </summary>
            <remarks>
              <para>
                This is used within ZLIB.  You probably don't need to use this directly.
              </para>
            </remarks>
            <example>
               To compute an Adler32 checksum on a byte array:
             <code>
               var adler = Adler.Adler32(0, null, 0, 0);
               adler = Adler.Adler32(adler, buffer, index, length);
             </code>
            </example>
        </member>
        <member name="T:Best.HTTP.Shared.Compression.Zlib.ZlibCodec">
             <summary>
             Encoder and Decoder for ZLIB and DEFLATE (IETF RFC1950 and RFC1951).
             </summary>
            
             <remarks>
             This class compresses and decompresses data according to the Deflate algorithm
             and optionally, the ZLIB format, as documented in <see
             href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950 - ZLIB</see> and <see
             href="http://www.ietf.org/rfc/rfc1951.txt">RFC 1951 - DEFLATE</see>.
             </remarks>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.InputBuffer">
            <summary>
            The buffer from which data is taken.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.NextIn">
            <summary>
            An index into the InputBuffer array, indicating where to start reading. 
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.AvailableBytesIn">
            <summary>
            The number of bytes available in the InputBuffer, starting at NextIn. 
            </summary>
            <remarks>
            Generally you should set this to InputBuffer.Length before the first Inflate() or Deflate() call. 
            The class will update this number as calls to Inflate/Deflate are made.
            </remarks>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.TotalBytesIn">
            <summary>
            Total number of bytes read so far, through all calls to Inflate()/Deflate().
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.OutputBuffer">
            <summary>
            Buffer to store output data.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.NextOut">
            <summary>
            An index into the OutputBuffer array, indicating where to start writing. 
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.AvailableBytesOut">
            <summary>
            The number of bytes available in the OutputBuffer, starting at NextOut. 
            </summary>
            <remarks>
            Generally you should set this to OutputBuffer.Length before the first Inflate() or Deflate() call. 
            The class will update this number as calls to Inflate/Deflate are made.
            </remarks>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.TotalBytesOut">
            <summary>
            Total number of bytes written to the output so far, through all calls to Inflate()/Deflate().
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.Message">
            <summary>
            used for diagnostics, when something goes wrong!
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.CompressLevel">
            <summary>
            The compression level to use in this codec.  Useful only in compression mode.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.WindowBits">
            <summary>
            The number of Window Bits to use.  
            </summary>
            <remarks>
            This gauges the size of the sliding window, and hence the 
            compression effectiveness as well as memory consumption. It's best to just leave this 
            setting alone if you don't know what it is.  The maximum value is 15 bits, which implies
            a 32k window.  
            </remarks>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.Strategy">
            <summary>
            The compression strategy to use.
            </summary>
            <remarks>
            This is only effective in compression.  The theory offered by ZLIB is that different
            strategies could potentially produce significant differences in compression behavior
            for different data sets.  Unfortunately I don't have any good recommendations for how
            to set it differently.  When I tested changing the strategy I got minimally different
            compression performance. It's best to leave this property alone if you don't have a
            good feel for it.  Or, you may want to produce a test harness that runs through the
            different strategy options and evaluates them on different file types. If you do that,
            let me know your results.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.Adler32">
            <summary>
            The Adler32 checksum on the data transferred through the codec so far. You probably don't need to look at this.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.#ctor">
            <summary>
            Create a ZlibCodec.
            </summary>
            <remarks>
            If you use this default constructor, you will later have to explicitly call 
            InitializeInflate() or InitializeDeflate() before using the ZlibCodec to compress 
            or decompress. 
            </remarks>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.#ctor(Best.HTTP.Shared.Compression.Zlib.CompressionMode)">
            <summary>
            Create a ZlibCodec that either compresses or decompresses.
            </summary>
            <param name="mode">
            Indicates whether the codec should compress (deflate) or decompress (inflate).
            </param>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.InitializeInflate">
            <summary>
            Initialize the inflation state. 
            </summary>
            <remarks>
            It is not necessary to call this before using the ZlibCodec to inflate data; 
            It is implicitly called when you call the constructor.
            </remarks>
            <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.InitializeInflate(System.Boolean)">
             <summary>
             Initialize the inflation state with an explicit flag to
             govern the handling of RFC1950 header bytes.
             </summary>
            
             <remarks>
             By default, the ZLIB header defined in <see
             href="http://www.ietf.org/rfc/rfc1950.txt">RFC 1950</see> is expected.  If
             you want to read a zlib stream you should specify true for
             expectRfc1950Header.  If you have a deflate stream, you will want to specify
             false. It is only necessary to invoke this initializer explicitly if you
             want to specify false.
             </remarks>
            
             <param name="expectRfc1950Header">whether to expect an RFC1950 header byte
             pair when reading the stream of data to be inflated.</param>
            
             <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.InitializeInflate(System.Int32)">
            <summary>
            Initialize the ZlibCodec for inflation, with the specified number of window bits. 
            </summary>
            <param name="windowBits">The number of window bits to use. If you need to ask what that is, 
            then you shouldn't be calling this initializer.</param>
            <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.InitializeInflate(System.Int32,System.Boolean)">
             <summary>
             Initialize the inflation state with an explicit flag to govern the handling of
             RFC1950 header bytes. 
             </summary>
            
             <remarks>
             If you want to read a zlib stream you should specify true for
             expectRfc1950Header. In this case, the library will expect to find a ZLIB
             header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
             1950</see>, in the compressed stream.  If you will be reading a DEFLATE or
             GZIP stream, which does not have such a header, you will want to specify
             false.
             </remarks>
            
             <param name="expectRfc1950Header">whether to expect an RFC1950 header byte pair when reading 
             the stream of data to be inflated.</param>
             <param name="windowBits">The number of window bits to use. If you need to ask what that is, 
             then you shouldn't be calling this initializer.</param>
             <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.Inflate(Best.HTTP.Shared.Compression.Zlib.FlushType)">
             <summary>
             Inflate the data in the InputBuffer, placing the result in the OutputBuffer.
             </summary>
             <remarks>
             You must have set InputBuffer and OutputBuffer, NextIn and NextOut, and AvailableBytesIn and 
             AvailableBytesOut  before calling this method.
             </remarks>
             <example>
             <code>
             private void InflateBuffer()
             {
                 int bufferSize = 1024;
                 byte[] buffer = new byte[bufferSize];
                 ZlibCodec decompressor = new ZlibCodec();
             
                 Console.WriteLine("\n============================================");
                 Console.WriteLine("Size of Buffer to Inflate: {0} bytes.", CompressedBytes.Length);
                 MemoryStream ms = new MemoryStream(DecompressedBytes);
             
                 int rc = decompressor.InitializeInflate();
             
                 decompressor.InputBuffer = CompressedBytes;
                 decompressor.NextIn = 0;
                 decompressor.AvailableBytesIn = CompressedBytes.Length;
             
                 decompressor.OutputBuffer = buffer;
             
                 // pass 1: inflate 
                 do
                 {
                     decompressor.NextOut = 0;
                     decompressor.AvailableBytesOut = buffer.Length;
                     rc = decompressor.Inflate(FlushType.None);
             
                     if (rc != ZlibConstants.Z_OK &amp;&amp; rc != ZlibConstants.Z_STREAM_END)
                         throw new Exception("inflating: " + decompressor.Message);
             
                     ms.Write(decompressor.OutputBuffer, 0, buffer.Length - decompressor.AvailableBytesOut);
                 }
                 while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);
             
                 // pass 2: finish and flush
                 do
                 {
                     decompressor.NextOut = 0;
                     decompressor.AvailableBytesOut = buffer.Length;
                     rc = decompressor.Inflate(FlushType.Finish);
             
                     if (rc != ZlibConstants.Z_STREAM_END &amp;&amp; rc != ZlibConstants.Z_OK)
                         throw new Exception("inflating: " + decompressor.Message);
             
                     if (buffer.Length - decompressor.AvailableBytesOut &gt; 0)
                         ms.Write(buffer, 0, buffer.Length - decompressor.AvailableBytesOut);
                 }
                 while (decompressor.AvailableBytesIn &gt; 0 || decompressor.AvailableBytesOut == 0);
             
                 decompressor.EndInflate();
             }
            
             </code>
             </example>
             <param name="flush">The flush to use when inflating.</param>
             <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.EndInflate">
            <summary>
            Ends an inflation session. 
            </summary>
            <remarks>
            Call this after successively calling Inflate().  This will cause all buffers to be flushed. 
            After calling this you cannot call Inflate() without a intervening call to one of the
            InitializeInflate() overloads.
            </remarks>
            <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.SyncInflate">
            <summary>
            I don't know what this does!
            </summary>
            <returns>Z_OK if everything goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.InitializeDeflate">
            <summary>
            Initialize the ZlibCodec for deflation operation.
            </summary>
            <remarks>
            The codec will use the MAX window bits and the default level of compression.
            </remarks>
            <example>
            <code>
             int bufferSize = 40000;
             byte[] CompressedBytes = new byte[bufferSize];
             byte[] DecompressedBytes = new byte[bufferSize];
             
             ZlibCodec compressor = new ZlibCodec();
             
             compressor.InitializeDeflate(CompressionLevel.Default);
             
             compressor.InputBuffer = System.Text.ASCIIEncoding.ASCII.GetBytes(TextToCompress);
             compressor.NextIn = 0;
             compressor.AvailableBytesIn = compressor.InputBuffer.Length;
             
             compressor.OutputBuffer = CompressedBytes;
             compressor.NextOut = 0;
             compressor.AvailableBytesOut = CompressedBytes.Length;
             
             while (compressor.TotalBytesIn != TextToCompress.Length &amp;&amp; compressor.TotalBytesOut &lt; bufferSize)
             {
               compressor.Deflate(FlushType.None);
             }
             
             while (true)
             {
               int rc= compressor.Deflate(FlushType.Finish);
               if (rc == ZlibConstants.Z_STREAM_END) break;
             }
             
             compressor.EndDeflate();
              
            </code>
            </example>
            <returns>Z_OK if all goes well. You generally don't need to check the return code.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.InitializeDeflate(Best.HTTP.Shared.Compression.Zlib.CompressionLevel)">
            <summary>
            Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel.
            </summary>
            <remarks>
            The codec will use the maximum window bits (15) and the specified
            CompressionLevel.  It will emit a ZLIB stream as it compresses.
            </remarks>
            <param name="level">The compression level for the codec.</param>
            <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.InitializeDeflate(Best.HTTP.Shared.Compression.Zlib.CompressionLevel,System.Boolean)">
            <summary>
            Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel, 
            and the explicit flag governing whether to emit an RFC1950 header byte pair.
            </summary>
            <remarks>
            The codec will use the maximum window bits (15) and the specified CompressionLevel.
            If you want to generate a zlib stream, you should specify true for
            wantRfc1950Header. In this case, the library will emit a ZLIB
            header, as defined in <see href="http://www.ietf.org/rfc/rfc1950.txt">RFC
            1950</see>, in the compressed stream.  
            </remarks>
            <param name="level">The compression level for the codec.</param>
            <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>
            <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.InitializeDeflate(Best.HTTP.Shared.Compression.Zlib.CompressionLevel,System.Int32)">
            <summary>
            Initialize the ZlibCodec for deflation operation, using the specified CompressionLevel, 
            and the specified number of window bits. 
            </summary>
            <remarks>
            The codec will use the specified number of window bits and the specified CompressionLevel.
            </remarks>
            <param name="level">The compression level for the codec.</param>
            <param name="bits">the number of window bits to use.  If you don't know what this means, don't use this method.</param>
            <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.InitializeDeflate(Best.HTTP.Shared.Compression.Zlib.CompressionLevel,System.Int32,System.Boolean)">
             <summary>
             Initialize the ZlibCodec for deflation operation, using the specified
             CompressionLevel, the specified number of window bits, and the explicit flag
             governing whether to emit an RFC1950 header byte pair.
             </summary>
            
             <param name="level">The compression level for the codec.</param>
             <param name="wantRfc1950Header">whether to emit an initial RFC1950 byte pair in the compressed stream.</param>
             <param name="bits">the number of window bits to use.  If you don't know what this means, don't use this method.</param>
             <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.Deflate(Best.HTTP.Shared.Compression.Zlib.FlushType)">
            <summary>
            Deflate one batch of data.
            </summary>
            <remarks>
            You must have set InputBuffer and OutputBuffer before calling this method.
            </remarks>
            <example>
            <code>
            private void DeflateBuffer(CompressionLevel level)
            {
                int bufferSize = 1024;
                byte[] buffer = new byte[bufferSize];
                ZlibCodec compressor = new ZlibCodec();
            
                Console.WriteLine("\n============================================");
                Console.WriteLine("Size of Buffer to Deflate: {0} bytes.", UncompressedBytes.Length);
                MemoryStream ms = new MemoryStream();
            
                int rc = compressor.InitializeDeflate(level);
            
                compressor.InputBuffer = UncompressedBytes;
                compressor.NextIn = 0;
                compressor.AvailableBytesIn = UncompressedBytes.Length;
            
                compressor.OutputBuffer = buffer;
            
                // pass 1: deflate 
                do
                {
                    compressor.NextOut = 0;
                    compressor.AvailableBytesOut = buffer.Length;
                    rc = compressor.Deflate(FlushType.None);
            
                    if (rc != ZlibConstants.Z_OK &amp;&amp; rc != ZlibConstants.Z_STREAM_END)
                        throw new Exception("deflating: " + compressor.Message);
            
                    ms.Write(compressor.OutputBuffer, 0, buffer.Length - compressor.AvailableBytesOut);
                }
                while (compressor.AvailableBytesIn &gt; 0 || compressor.AvailableBytesOut == 0);
            
                // pass 2: finish and flush
                do
                {
                    compressor.NextOut = 0;
                    compressor.AvailableBytesOut = buffer.Length;
                    rc = compressor.Deflate(FlushType.Finish);
            
                    if (rc != ZlibConstants.Z_STREAM_END &amp;&amp; rc != ZlibConstants.Z_OK)
                        throw new Exception("deflating: " + compressor.Message);
            
                    if (buffer.Length - compressor.AvailableBytesOut &gt; 0)
                        ms.Write(buffer, 0, buffer.Length - compressor.AvailableBytesOut);
                }
                while (compressor.AvailableBytesIn &gt; 0 || compressor.AvailableBytesOut == 0);
            
                compressor.EndDeflate();
            
                ms.Seek(0, SeekOrigin.Begin);
                CompressedBytes = new byte[compressor.TotalBytesOut];
                ms.Read(CompressedBytes, 0, CompressedBytes.Length);
            }
            </code>
            </example>
            <param name="flush">whether to flush all data as you deflate. Generally you will want to 
            use Z_NO_FLUSH here, in a series of calls to Deflate(), and then call EndDeflate() to 
            flush everything. 
            </param>
            <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.EndDeflate">
            <summary>
            End a deflation session.
            </summary>
            <remarks>
            Call this after making a series of one or more calls to Deflate(). All buffers are flushed.
            </remarks>
            <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.ResetDeflate">
            <summary>
            Reset a codec for another deflation session.
            </summary>
            <remarks>
            Call this to reset the deflation state.  For example if a thread is deflating
            non-consecutive blocks, you can call Reset() after the Deflate(Sync) of the first
            block and before the next Deflate(None) of the second block.
            </remarks>
            <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.SetDeflateParams(Best.HTTP.Shared.Compression.Zlib.CompressionLevel,Best.HTTP.Shared.Compression.Zlib.CompressionStrategy)">
            <summary>
            Set the CompressionStrategy and CompressionLevel for a deflation session.
            </summary>
            <param name="level">the level of compression to use.</param>
            <param name="strategy">the strategy to use for compression.</param>
            <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZlibCodec.SetDictionary(System.Byte[])">
            <summary>
            Set the dictionary to be used for either Inflation or Deflation.
            </summary>
            <param name="dictionary">The dictionary bytes to use.</param>
            <returns>Z_OK if all goes well.</returns>
        </member>
        <member name="T:Best.HTTP.Shared.Compression.Zlib.ZlibConstants">
            <summary>
            A bunch of constants used in the Zlib interface.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibConstants.WindowBitsMax">
            <summary>
            The maximum number of window bits for the Deflate algorithm.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibConstants.WindowBitsDefault">
            <summary>
            The default number of window bits for the Deflate algorithm.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibConstants.Z_OK">
            <summary>
            indicates everything is A-OK
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibConstants.Z_STREAM_END">
            <summary>
            Indicates that the last operation reached the end of the stream.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibConstants.Z_NEED_DICT">
            <summary>
            The operation ended in need of a dictionary. 
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibConstants.Z_STREAM_ERROR">
            <summary>
            There was an error with the stream - not enough data, not open and readable, etc.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibConstants.Z_DATA_ERROR">
            <summary>
            There was an error with the data - not enough data, bad data, etc.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibConstants.Z_BUF_ERROR">
            <summary>
            There was an error with the working buffer.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibConstants.WorkingBufferSizeDefault">
            <summary>
            The size of the working buffer used in the ZlibCodec class. Defaults to 8192 bytes.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Compression.Zlib.ZlibConstants.WorkingBufferSizeMin">
            <summary>
            The minimum size of the working buffer used in the ZlibCodec class.  Currently it is 128 bytes.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Compression.Zlib.ZTree.DistanceCode(System.Int32)">
            <summary>
            Map from a distance to a distance code.
            </summary>
            <remarks> 
            No side effects. _dist_code[256] and _dist_code[257] are never used.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Shared.Databases.Database`4.FromFirstMetadataIndex(System.Collections.Generic.IEnumerable{System.Int32})">
            <summary>
            Loads the first content from the metadata indexes.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Databases.Database`4.FromMetadataIndex(System.Int32)">
            <summary>
            Loads the content from the metadata index.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Databases.Database`4.FromMetadatas(System.Collections.Generic.IEnumerable{`1})">
            <summary>
            Loads all content from the metadatas.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Databases.Database`4.FromMetadataIndexes(System.Collections.Generic.IEnumerable{System.Int32})">
            <summary>
            Loads all content from the metadata indexes.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Databases.DiskManager`1.CacheSize">
            <summary>
            Sum size of the cached contents
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Databases.Indexing.NoAllocList`1">
            <summary>
            Implements most common list functions. With best case (no or only one item) it doesn't do any allocation.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Databases.Indexing.Node`2.Depth">
            <summary>
            Depth of the node.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Databases.Indexing.Node`2.BalanceFactor">
            <summary>
            Difference between LeftDepth and RightDepth.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Databases.Indexing.Node`2.LeftDepth">
            <summary>
            Left node's Depth, or -1 if it's null.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Databases.Indexing.Node`2.RightDepth">
            <summary>
            Right node's Depth, or -1 if it's null.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Databases.Indexing.AVLTree`2.RemoveNode(Best.HTTP.Shared.Databases.Indexing.Node{`0,`1})">
            <summary>
            Removes node and reparent any child it has.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Databases.IndexingService`2.Index(`1)">
            <summary>
            Index newly added metadata
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Databases.IndexingService`2.Remove(`1)">
            <summary>
            Remove metadata from all indexes.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Databases.IndexingService`2.Clear">
            <summary>
            Clear all indexes
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Databases.IndexingService`2.GetOptimizedIndexes">
            <summary>
            Get indexes in an optimized order. This is usually one of the indexes' WalkHorizontal() call.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Databases.MetadataService`2.CreateFrom(System.IO.Stream)">
            <summary>
            Called when metadata loaded from file
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Databases.MetadataService`2.CreateDefault(`1,System.Int32,System.Int32,System.Action{`1,`0})">
            <summary>
            Called by a concrete MetadataService implementation to create a new metadata
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Extensions.Extensions.AsciiToString(System.Byte[])">
            <summary>
            On WP8 platform there are no ASCII encoding.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Extensions.Extensions.GetASCIIBytes(System.String)">
            <summary>
            On WP8 platform there are no ASCII encoding.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Extensions.Extensions.IsHostIsAnIPAddress(System.Uri)">
            <summary>
            Returns true if the Uri's host is a valid IPv4 or IPv6 address.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Extensions.Extensions.IsIpV4AddressValid(System.String)">
            <summary>
            Validates an IPv4 address.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Extensions.Extensions.IsIpV6AddressValid(System.String)">
            <summary>
            Validates an IPv6 address.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Extensions.Extensions.ReadBuffer(System.IO.Stream,System.Byte[])">
            <summary>
            Will fill the entire buffer from the stream. Will throw an exception when the underlying stream is closed.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Extensions.HeaderParser">
            <summary>
            Will parse a comma-separeted header value
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Extensions.HeaderValue">
            <summary>
            Used in string parsers. Its Value is optional.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Extensions.HeartbeatManager">
            <summary>
            A manager class that can handle subscribing and unsubscribeing in the same update.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Extensions.KeyValuePairList">
            <summary>
            Base class for specialized parsers
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Extensions.TimerData.CreateNew">
            <summary>
            Create a new TimerData but the Created field will be set to the current time.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.HTTPManager">
            <summary>
            Global entry point to access and manage main services of the plugin.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.HTTPManager.#cctor">
            <summary>
            Static constructor. Setup default values.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.HTTPManager.OnSetupFinished">
            <summary>
            Delegate for the setup finished event.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPManager.PerHostSettings">
            <summary>
            Instance of the per-host settings manager.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPManager.CurrentFrameDateTime">
            <summary>
            Cached DateTime value for cases where high resolution isn't needed.
            </summary>
            <remarks>Warning!! It must be used only on the main update thread!</remarks>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPManager.RootSaveFolderProvider">
            <summary>
            By default the plugin will save all cache and cookie data under the path returned by Application.persistentDataPath.
            You can assign a function to this delegate to return a custom root path to define a new path.
            <remarks>This delegate will be called on a non Unity thread!</remarks>
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPManager.Proxy">
            <summary>
            The global, default proxy for all HTTPRequests. The HTTPRequest's Proxy still can be changed per-request. Default value is null.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPManager.Heartbeats">
            <summary>
            Heartbeat manager to use less threads in the plugin. The heartbeat updates are called from the OnUpdate function.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPManager.Logger">
            <summary>
            A basic Best.HTTP.Logger.ILogger implementation to be able to log intelligently additional informations about the plugin's internal mechanism.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.HTTPManager.IOService">
            <summary>
            An IIOService implementation to handle filesystem operations.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.HTTPManager.UserAgent">
            <summary>
            User-agent string that will be sent with each requests.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPManager.IsQuitting">
            <summary>
            It's true if the application is quitting and the plugin is shutting down itself.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPManager.LocalCache">
            <summary>
            The local content cache, maintained by the plugin. When set to a non-null value, Maintain called immediately on the cache.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.HTTPManager.Setup">
            <summary>
            Initializes the HTTPManager with default settings. This method should be called on Unity's main thread before using the HTTP plugin. By default it gets called by <see cref="T:Best.HTTP.Shared.HTTPUpdateDelegator"/>.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.HTTPManager.GetRootSaveFolder">
            <summary>
            Will return where the various caches should be saved.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.HTTPManager.OnUpdate">
            <summary>
            Updates the HTTPManager. This method should be called regularly from a Unity event (e.g., Update, LateUpdate).
            It processes various events and callbacks and manages internal tasks.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.HTTPManager.OnQuit">
            <summary>
            Shuts down the HTTPManager and performs cleanup operations. This method should be called when the application is quitting.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.HTTPManager.AbortAll">
            <summary>
            Aborts all ongoing HTTP requests and performs an immediate shutdown of the HTTPManager.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.ThreadingMode">
            <summary>
            Threading mode the plugin will use to call HTTPManager.OnUpdate().
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.ThreadingMode.UnityUpdate">
            <summary>
            HTTPManager.OnUpdate() is called from the HTTPUpdateDelegator's Update functions (Unity's main thread).
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.ThreadingMode.Threaded">
            <summary>
            The plugin starts a dedicated thread to call HTTPManager.OnUpdate() periodically.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.ThreadingMode.None">
            <summary>
            HTTPManager.OnUpdate() will not be called automatically.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.HTTPUpdateDelegator">
            <summary>
            Will route some U3D calls to the HTTPManager.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPUpdateDelegator.Instance">
            <summary>
            The singleton instance of the HTTPUpdateDelegator
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPUpdateDelegator.IsCreated">
            <summary>
            True, if the Instance property should hold a valid value.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPUpdateDelegator.IsThreadRunning">
            <summary>
            It's true if the dispatch thread running.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPUpdateDelegator.CurrentThreadingMode">
            <summary>
            The current threading mode the plugin is in.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.HTTPUpdateDelegator.ThreadFrequencyInMS">
            <summary>
            How much time the plugin should wait between two update call. Its default value 100 ms.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.HTTPUpdateDelegator.OnBeforeApplicationQuit">
            <summary>
            Called in the OnApplicationQuit function. If this function returns False, the plugin will not start to
            shut down itself.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.HTTPUpdateDelegator.OnApplicationForegroundStateChanged">
            <summary>
            Called when the Unity application's foreground state changed.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.HTTPUpdateDelegator.CheckInstance">
            <summary>
            Will create the HTTPUpdateDelegator instance and set it up.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.HTTPUpdateDelegator.IsMainThread">
            <summary>
            Return true if the call happens on the Unity main thread. Setup must be called before to save the thread id!
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.HTTPUpdateDelegator.SetThreadingMode(Best.HTTP.Shared.ThreadingMode)">
            <summary>
            Set directly the threading mode to use.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.HTTPUpdateDelegator.SwapThreadingMode">
            <summary>
            Swaps threading mode between Unity's Update function or a distinct thread.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.HTTPUpdateDelegator.PingUpdateThread">
            <summary>
            Pings the update thread to call HTTPManager.OnUpdate immediately.
            </summary>
            <remarks>Works only when the current threading mode is Threaded!</remarks>
        </member>
        <member name="T:Best.HTTP.Shared.Logger.FileOutput">
            <summary>
            Provides an implementation of <see cref="T:Best.HTTP.Shared.Logger.ILogOutput"/> that writes log messages to a file.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Logger.FileOutput.AcceptColor">
            <summary>
            Gets a value indicating whether this log output accepts color codes. Always returns <c>false</c>.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.FileOutput.#ctor(System.String)">
            <summary>
            Initializes a new instance of the FileOutput class with the specified file name.
            </summary>
            <param name="fileName">The name of the file to write log messages to.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.FileOutput.Write(Best.HTTP.Shared.Logger.Loglevels,System.String)">
            <summary>
            Writes a log message to the file.
            </summary>
            <param name="level">The log level of the message.</param>
            <param name="logEntry">The log message to write.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.FileOutput.Flush">
            <summary>
            Flushes any buffered log messages to the file.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.FileOutput.Dispose">
            <summary>
            Releases any resources used by the FileOutput instance.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Logger.Loglevels">
            <summary>
            Available logging levels.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Logger.Loglevels.All">
            <summary>
            All message will be logged.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Logger.Loglevels.Information">
            <summary>
            Only Informations and above will be logged.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Logger.Loglevels.Warning">
            <summary>
            Only Warnings and above will be logged.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Logger.Loglevels.Error">
            <summary>
            Only Errors and above will be logged.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Logger.Loglevels.Exception">
            <summary>
            Only Exceptions will be logged.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.Logger.Loglevels.None">
            <summary>
            No logging will occur.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Logger.ILogOutput">
            <summary>
            Represents an output target for log messages.
            </summary>
            <remarks>
            <para>
            This interface defines methods for writing log messages to an output target.
            Implementations of this interface are used to configure where log messages
            should be written.
            </para>
            <para>
            Two of its out-of-the-box implementations are
            <list type="bullet">
                <item><description><see cref="T:Best.HTTP.Shared.Logger.UnityOutput">UnityOutput</see></description></item>
                <item><description><see cref="T:Best.HTTP.Shared.Logger.FileOutput">FileOutput</see></description></item>
            </list>
            </para>
            </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Logger.ILogOutput.AcceptColor">
            <summary>
            Gets a value indicating whether the log output supports colored text.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.ILogOutput.Write(Best.HTTP.Shared.Logger.Loglevels,System.String)">
            <summary>
            Writes a log entry to the output.
            </summary>
            <param name="level">The logging level of the entry.</param>
            <param name="logEntry">The log message to write.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.ILogOutput.Flush">
            <summary>
            Flushes any buffered log entries to the output.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Logger.IFilter">
            <summary>
            Represents a filter for further sort out what log entries to include in the final log output.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.IFilter.Include(System.String)">
            <summary>
            Return <c>true</c> if the division must be included in the output.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Logger.ILogger">
            <summary>
            Represents a logger for recording log messages.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Logger.ILogger.Level">
            <summary>
            Gets or sets the minimum severity level for logging.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Logger.ILogger.Output">
            <summary>
            Gets or sets the output target for log messages.
            </summary>
            <value>
            The <see cref="T:Best.HTTP.Shared.Logger.ILogOutput"/> instance used to write log messages.
            </value>
        </member>
        <member name="P:Best.HTTP.Shared.Logger.ILogger.Filter">
            <summary>
            Gets or sets an output filter to decide what messages are included or not.
            </summary>
            <value>The <see cref="T:Best.HTTP.Shared.Logger.IFilter"/> instance used for filtering.</value>
        </member>
        <member name="P:Best.HTTP.Shared.Logger.ILogger.IsEmpty">
            <summary>
            Property indicating whether the logger's internal queue is empty or not.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Logger.ILogger.IsDiagnostic">
            <summary>
            Gets a value indicating whether diagnostic logging is enabled.
            </summary>
            <remarks>
            Diagnostic logging is enabled when <see cref="P:Best.HTTP.Shared.Logger.ILogger.Level"/> is set to <see cref="F:Best.HTTP.Shared.Logger.Loglevels.All"/>.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.ILogger.Verbose(System.String,System.String,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Logs a message with <see cref="F:Best.HTTP.Shared.Logger.Loglevels.All"/> level.
            </summary>
            <param name="division">The division or category of the log message.</param>
            <param name="msg">The verbose log message.</param>
            <param name="context">The optional <see cref="T:Best.HTTP.Shared.Logger.LoggingContext"/> for additional context.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.ILogger.Information(System.String,System.String,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Logs a message with <see cref="F:Best.HTTP.Shared.Logger.Loglevels.Information"/> level.
            </summary>
            <param name="division">The division or category of the log message.</param>
            <param name="msg">The verbose log message.</param>
            <param name="context">The optional <see cref="T:Best.HTTP.Shared.Logger.LoggingContext"/> for additional context.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.ILogger.Warning(System.String,System.String,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Logs a message with <see cref="F:Best.HTTP.Shared.Logger.Loglevels.Warning"/> level.
            </summary>
            <param name="division">The division or category of the log message.</param>
            <param name="msg">The verbose log message.</param>
            <param name="context">The optional <see cref="T:Best.HTTP.Shared.Logger.LoggingContext"/> for additional context.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.ILogger.Error(System.String,System.String,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Logs a message with <see cref="F:Best.HTTP.Shared.Logger.Loglevels.Error"/> level.
            </summary>
            <param name="division">The division or category of the log message.</param>
            <param name="msg">The verbose log message.</param>
            <param name="context">The optional <see cref="T:Best.HTTP.Shared.Logger.LoggingContext"/> for additional context.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.ILogger.Exception(System.String,System.String,System.Exception,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Logs a message with <see cref="F:Best.HTTP.Shared.Logger.Loglevels.Exception"/> level.
            </summary>
            <param name="division">The division or category of the log message.</param>
            <param name="msg">The verbose log message.</param>
            <param name="context">The optional <see cref="T:Best.HTTP.Shared.Logger.LoggingContext"/> for additional context.</param>
        </member>
        <member name="T:Best.HTTP.Shared.Logger.LoggingContext">
            <summary>
            Represents a logging context for categorizing and organizing log messages.
            </summary>
            <remarks>
            The LoggingContext class is used to provide additional context information
            to log messages, allowing for better categorization and organization of log output. It can be
            associated with specific objects or situations to enrich log entries with context-specific data.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.Logger.LoggingContext.Hash">
            <summary>
            Gets the unique hash value of this logging context.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.LoggingContext.#ctor(System.Object)">
            <summary>
            Initializes a new instance of the LoggingContext class associated with the specified object.
            </summary>
            <param name="boundto">The object to associate the context with.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.LoggingContext.Add(System.String,System.Int64)">
            <summary>
            Adds a <c>long</c> value to the logging context.
            </summary>
            <param name="key">The key to associate with the value.</param>
            <param name="value">The <c>long</c> value to add.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.LoggingContext.Add(System.String,System.Boolean)">
            <summary>
            Adds a <c>bool</c> value to the logging context.
            </summary>
            <param name="key">The key to associate with the value.</param>
            <param name="value">The <c>bool</c> value to add.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.LoggingContext.Add(System.String,System.String)">
            <summary>
            Adds a <c>string</c> value to the logging context.
            </summary>
            <param name="key">The key to associate with the value.</param>
            <param name="value">The <c>string</c> value to add.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.LoggingContext.Add(System.String,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Adds a <c>LoggingContext</c> value to the logging context.
            </summary>
            <param name="key">The key to associate with the value.</param>
            <param name="value">The <c>LoggingContext</c> value to add.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.LoggingContext.GetStringField(System.String)">
            <summary>
            Gets the <c>string</c> field with the specified name from the logging context.
            </summary>
            <param name="fieldName">The name of the <c>string</c> field to retrieve.</param>
            <returns>The value of the <c>string</c> field or <c>null</c> if not found.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.LoggingContext.Remove(System.String)">
            <summary>
            Removes a field from the logging context by its key.
            </summary>
            <param name="key">The key of the field to remove.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.LoggingContext.ToJson(System.Text.StringBuilder)">
            <summary>
            Converts the logging context and its associated fields to a JSON string representation.
            </summary>
            <param name="sb">A <see cref="T:System.Text.StringBuilder"/> instance to which the JSON string is appended.</param>
            <remarks>
            This method serializes the logging context and its associated fields into a JSON format
            for structured logging purposes. The resulting JSON string represents the context and its fields, making it
            suitable for inclusion in log entries for better analysis and debugging.
            </remarks>
        </member>
        <member name="T:Best.HTTP.Shared.Logger.SingleDivisionFilter">
            <summary>
            <see cref="T:Best.HTTP.Shared.Logger.IFilter"/> implementation to include only one division in the log output.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Logger.MultiDivisionFilter">
            <summary>
            <see cref="T:Best.HTTP.Shared.Logger.IFilter"/> implementation to allow filtering for multiple divisions.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Logger.UnityOutput">
            <summary>
            Provides an implementation of <see cref="T:Best.HTTP.Shared.Logger.ILogOutput"/> that writes log messages to the Unity Debug Console.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.Logger.UnityOutput.AcceptColor">
            <summary>
            Gets a value indicating whether this log output accepts color codes.
            </summary>
            <remarks>
            This property returns <c>true</c> when running in the Unity Editor and <c>false</c> otherwise.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.UnityOutput.Write(Best.HTTP.Shared.Logger.Loglevels,System.String)">
            <summary>
            Writes a log message to the Unity Debug Console based on the specified log level.
            </summary>
            <param name="level">The log level of the message.</param>
            <param name="logEntry">The log message to write.</param>
        </member>
        <member name="M:Best.HTTP.Shared.Logger.UnityOutput.Best#HTTP#Shared#Logger#ILogOutput#Flush">
            <summary>
            This implementation does nothing.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.FileSystem.FileStreamModes">
            <summary>
            These are the different modes that the plugin want's to use a filestream.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.FileSystem.FileStreamModes.Create">
            <summary>
            Create a new file.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.FileSystem.FileStreamModes.OpenRead">
            <summary>
            Open an existing file for reading.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.FileSystem.FileStreamModes.OpenReadWrite">
            <summary>
            Open or create a file for read and write.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.FileSystem.FileStreamModes.Append">
            <summary>
            Open an existing file for writing to the end.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.FileSystem.IIOService">
            <summary>
            Interface for file-system abstraction.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.FileSystem.IIOService.DirectoryCreate(System.String)">
            <summary>
            Create a directory for the given path.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.FileSystem.IIOService.DirectoryExists(System.String)">
            <summary>
            Return true if the directory exists for the given path.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.FileSystem.IIOService.DirectoryDelete(System.String)">
            <summary>
            Delete the directory.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.FileSystem.IIOService.GetFiles(System.String)">
            <summary>
            Return with the file names for the given path.
            </summary>
            <param name="path"></param>
            <returns></returns>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.FileSystem.IIOService.FileDelete(System.String)">
            <summary>
            Delete the file for the given path.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.FileSystem.IIOService.FileExists(System.String)">
            <summary>
            Return true if the file exists on the given path.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.FileSystem.IIOService.CreateFileStream(System.String,Best.HTTP.Shared.PlatformSupport.FileSystem.FileStreamModes)">
            <summary>
            Create a stream that can read and/or write a file on the given path.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.IL2CPP.Option">
            <summary>
            The code generation options available for IL to C++ conversion.
            Enable or disabled these with caution.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.IL2CPP.Option.NullChecks">
             <summary>
             Enable or disable code generation for null checks.
            
             Global null check support is enabled by default when il2cpp.exe
             is launched from the Unity editor.
            
             Disabling this will prevent NullReferenceException exceptions from
             being thrown in generated code. In *most* cases, code that dereferences
             a null pointer will crash then. Sometimes the point where the crash
             happens is later than the location where the null reference check would
             have been emitted though.
             </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.IL2CPP.Option.ArrayBoundsChecks">
             <summary>
             Enable or disable code generation for array bounds checks.
            
             Global array bounds check support is enabled by default when il2cpp.exe
             is launched from the Unity editor.
            
             Disabling this will prevent IndexOutOfRangeException exceptions from
             being thrown in generated code. This will allow reading and writing to
             memory outside of the bounds of an array without any runtime checks.
             Disable this check with extreme caution.
             </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.IL2CPP.Option.DivideByZeroChecks">
             <summary>
             Enable or disable code generation for divide by zero checks.
            
             Global divide by zero check support is disabled by default when il2cpp.exe
             is launched from the Unity editor.
            
             Enabling this will cause DivideByZeroException exceptions to be
             thrown in generated code. Most code doesn't need to handle this
             exception, so it is probably safe to leave it disabled.
             </summary>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.IL2CPP.Il2CppSetOptionAttribute">
             <summary>
             Use this attribute on a class, method, or property to inform the IL2CPP code conversion utility to override the
             global setting for one of a few different runtime checks.
            
             Example:
            
                 [Il2CppSetOption(Option.NullChecks, false)]
                 public static string MethodWithNullChecksDisabled()
                 {
                     var tmp = new Object();
                     return tmp.ToString();
                 }
             </summary>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.IL2CPP.PreserveAttribute">
            <summary>
            https://docs.unity3d.com/Manual/ManagedCodeStripping.html
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.Memory.UserModeLock">
            <summary>
            Light-weight user-mode lock for code blocks that has rare contentions and doesn't take a long time to finish.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool">
            <summary>
            The BufferPool is a foundational element of the Best HTTP package, aiming to reduce dynamic memory allocation overheads by reusing byte arrays. The concept is elegantly simple: rather than allocating and deallocating memory for every requirement, byte arrays can be "borrowed" and "returned" within this pool. Once returned, these arrays are retained for subsequent use, minimizing repetitive memory operations.
            <para>While the BufferPool is housed within the Best HTTP package, its benefits are not limited to just HTTP operations. All protocols and packages integrated with or built upon the Best HTTP package utilize and benefit from the BufferPool. This ensures that memory is used efficiently and performance remains optimal across all integrated components.</para>
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.NoData">
            <summary>
            Represents an empty byte array that can be returned for zero-length requests.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.IsEnabled">
            <summary>
            Gets or sets a value indicating whether the buffer pooling mechanism is enabled or disabled.
            Disabling will also clear all stored entries.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.RemoveOlderThan">
            <summary>
            Specifies the duration after which buffer entries, once released back to the pool, are deemed old and will be
            considered for removal in the next maintenance cycle.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.RunMaintenanceEvery">
            <summary>
            Specifies how frequently the maintenance cycle should run to manage old buffers.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.MinBufferSize">
            <summary>
            Specifies the minimum buffer size that will be allocated. If a request is made for a size smaller than this and canBeLarger is <c>true</c>, 
            this size will be used.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.MaxBufferSize">
            <summary>
            Specifies the maximum size of a buffer that the system will consider storing back into the pool.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.MaxPoolSize">
            <summary>
            Specifies the maximum total size of all stored buffers. When the buffer reach this threshold, new releases will be declined.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.RemoveEmptyLists">
            <summary>
            Indicates whether to remove buffer stores that don't hold any buffers from the free list.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.IsDoubleReleaseCheckEnabled">
            <summary>
            If set to <c>true</c>, and a byte array is released back to the pool more than once, an error will be logged.
            </summary>
            <remarks>Error checking is expensive and has a very large overhead! Turn it on with caution!</remarks>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.Get(System.Int64,System.Boolean,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Fetches a byte array from the pool.
            </summary>
            <remarks>Depending on the `canBeLarger` parameter, the returned buffer may be larger than the requested size!</remarks>
            <param name="size">Requested size of the buffer.</param>
            <param name="canBeLarger">If <c>true</c>, the returned buffer can be larger than the requested size.</param>
            <param name="context">Optional context for logging purposes.</param>
            <returns>A byte array from the pool or a newly allocated one if suitable size is not available.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.ReleaseBulk(System.Collections.Concurrent.ConcurrentQueue{Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment})">
            <summary>
            Releases a list of buffer segments back to the pool in a bulk operation.
            </summary>
            <param name="segments">List of buffer segments to release.</param>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.ReleaseBulk(System.Collections.Generic.List{Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment})">
            <summary>
            Releases a list of buffer segments back to the pool in a bulk operation.
            </summary>
            <param name="segments">List of buffer segments to release.</param>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.Release(System.Byte[])">
            <summary>
            Releases a byte array back to the pool.
            </summary>
            <param name="buffer">Buffer to be released back to the pool.</param>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.Resize(System.Byte[]@,System.Int32,System.Boolean,System.Boolean,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Resizes a byte array by returning the old one to the pool and fetching (or creating) a new one of the specified size.
            </summary>
            <param name="buffer">Buffer to resize.</param>
            <param name="newSize">New size for the buffer.</param>
            <param name="canBeLarger">If <c>true</c>, the new buffer can be larger than the specified size.</param>
            <param name="clear">If <c>true</c>, the new buffer will be cleared (set to all zeros).</param>
            <param name="context">Optional context for logging purposes.</param>
            <returns>A resized buffer.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.Clear">
            <summary>
            Clears all stored entries in the buffer pool instantly, releasing memory.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool.Maintain">
            <summary>
            Internal method called by the plugin to remove old, non-used buffers.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment">
            <summary>
            Represents a segment (a continuous section) of a byte array, providing functionalities to 
            work with a portion of the data without copying.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment.Empty">
            <summary>
            Represents an empty buffer segment.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment.Data">
            <summary>
            The underlying data of the buffer segment.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment.Offset">
            <summary>
            The starting offset of the segment within the data.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment.Count">
            <summary>
            The number of bytes in the segment that contain valid data.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment.#ctor(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Initializes a new instance of the BufferSegment struct.
            </summary>
            <param name="data">The data for the buffer segment.</param>
            <param name="offset">The starting offset of the segment.</param>
            <param name="count">The number of bytes in the segment.</param>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment.AsAutoRelease">
            <summary>
            Converts the buffer segment to an AutoReleaseBuffer to use it in a local using statement.
            </summary>
            <returns>A new AutoReleaseBuffer instance containing the data of the buffer segment.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment.Slice(System.Int32)">
            <summary>
            Creates a new segment starting from the specified offset.
            </summary>
            <remarks>The new segment will reference the same underlying byte[] as the original, without creating a copy of the data.</remarks>
            <param name="newOffset">The starting offset of the new segment.</param>
            <returns>A new buffer segment that references the same underlying data.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment.Slice(System.Int32,System.Int32)">
            <summary>
            Creates a new segment with the specified offset and count.
            </summary>
            <remarks>The new segment will reference the same underlying byte[] as the original, without creating a copy of the data.</remarks>
            <param name="offset">The starting offset of the new segment.</param>
            <param name="count">The number of bytes in the new segment.</param>
            <returns>A new buffer segment that references the same underlying data.</returns>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment.CopyTo(System.Byte[])">
            <summary>
            Copyies the buffer's content to the received array.
            </summary>
            <param name="to">The array the data will be copied into.</param>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.Memory.BufferStore">
            <summary>
            Private data struct that contains the size - byte arrays mapping. 
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferStore.Size">
            <summary>
            Size/length of the arrays stored in the buffers.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferStore.buffers">
            <summary>
            
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Memory.BufferStore.#ctor(System.Int64,System.Byte[])">
            <summary>
            Create a new store with its first byte[] to store.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.Memory.BufferDesc">
            <summary>
            Helper struct for <see cref="T:Best.HTTP.Shared.PlatformSupport.Memory.BufferPool"/>.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferDesc.buffer">
            <summary>
            The actual reference to the stored byte array.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferDesc.released">
            <summary>
            When the buffer is put back to the pool. Based on this value the pool will calculate the age of the buffer.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IPeekableContentProvider">
            <summary>
            The IPeekableContentProvider interface defines an abstraction for providing content to an <see cref="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer"/> with the ability to peek at the content without consuming it.
            It is an essential part of content streaming over a TCP connection.
            </summary>
            <remarks>
            <para>
            Key Functions of IPeekableContentProvider:
            </para>
            <list type="bullet">
            <item>
            <term>Content Provision</term><description>It provides content to an associated <see cref="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer"/> without immediately consuming the content. This allows the consumer to examine the data before processing.
            </description></item>
            <item>
            <term>Two-Way Binding</term><description>Supports establishing a two-way binding between the <see cref="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IPeekableContentProvider"/> and an <see cref="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer"/>, enabling bidirectional communication between the provider and consumer.
            </description></item>
            <item>
            <term>Unbinding</term><description>Provides methods for unbinding a content consumer, terminating the association between the provider and consumer.
            </description></item>
            </list>
            </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IPeekableContentProvider.Peekable">
            <summary>
            Gets the <see cref="T:Best.HTTP.Shared.Streams.PeekableContentProviderStream"/> associated with this content provider, which allows peeking at the content without consuming it.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IPeekableContentProvider.Consumer">
            <summary>
            Gets the <see cref="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer"/> implementor that will be notified through <see cref="M:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer.OnContent"/> calls when new data is available in the TCPStreamer.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IPeekableContentProvider.SetTwoWayBinding(Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer)">
            <summary>
            Sets up a two-way binding between this content provider and an <see cref="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer"/>. This enables bidirectional communication between the provider and consumer.
            </summary>
            <param name="consumer">The <see cref="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer"/> to bind to.</param>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IPeekableContentProvider.Unbind">
            <summary>
            Unbinds the content provider from its associated content consumer. This terminates the association between the provider and consumer.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IPeekableContentProvider.UnbindIf(Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer)">
            <summary>
            Unbinds the content provider from a specific content consumer if it is currently bound to that consumer.
            </summary>
            <param name="consumer">The <see cref="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer"/> to unbind from.</param>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer">
            <summary>
            The IContentConsumer interface represents a consumer of content provided by an <see cref="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IPeekableContentProvider"/>. It defines methods for handling received content and connection-related events.
            </summary>
            <remarks>
            <para>
            Key Functions of IContentConsumer:
            </para>
            <list type="bullet">
            <item>
            <term>Content Handling</term><description>Defines methods for handling incoming content, allowing consumers to process data as it becomes available.
            </description></item>
            <item>
            <term>Connection Management</term><description>Provides event methods to notify consumers of connection closure and error conditions, facilitating graceful handling of connection-related issues.
            </description></item>
            </list>
            </remarks>
        </member>
        <member name="P:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer.ContentProvider">
            <summary>
            Gets the <see cref="T:Best.HTTP.Shared.Streams.PeekableContentProviderStream"/> associated with this content consumer, which allows access to incoming content.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer.SetBinding(Best.HTTP.Shared.Streams.PeekableContentProviderStream)">
            <summary>
            This method should not be called directly. It is used internally to set the binding between the content consumer and its associated content provider.
            </summary>
            <param name="contentProvider">The <see cref="T:Best.HTTP.Shared.Streams.PeekableContentProviderStream"/> to bind to.</param>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer.UnsetBinding">
            <summary>
            This method should not be called directly. It is used internally to unset the binding between the content consumer and its associated content provider.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer.OnContent">
            <summary>
            Called when new content is available from the associated content provider.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer.OnConnectionClosed">
            <summary>
            Called when the connection is closed by the remote peer. It notifies the content consumer about the connection closure.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer.OnError(System.Exception)">
            <summary>
            Called when an error occurs during content processing or connection handling. It provides the exception that caused the error.
            </summary>
            <param name="ex">The <see cref="T:System.Exception"/> that represents the error condition.</param>
        </member>
        <member name="T:Best.HTTP.Shared.PlatformSupport.Text.StringBuilderPool">
            <summary>
            Implements pooling logic for <see cref="T:System.Text.StringBuilder"/> instances.
            </summary>
        </member>
        <member name="P:Best.HTTP.Shared.PlatformSupport.Text.StringBuilderPool.IsEnabled">
            <summary>
            Setting this property to false the pooling mechanism can be disabled.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Text.StringBuilderPool.RemoveOlderThan">
            <summary>
            Buffer entries that released back to the pool and older than this value are moved when next maintenance is triggered.
            </summary>
        </member>
        <member name="F:Best.HTTP.Shared.PlatformSupport.Text.StringBuilderPool.RunMaintenanceEvery">
            <summary>
            How often pool maintenance must run.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Streams.BufferPoolMemoryStream">
            <summary>
            This is a modified MemoryStream class to use VariableSizedBufferPool
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Streams.PeekableContentProviderStream">
            <summary>
            A PeekableStream implementation that also implements the <see cref="T:Best.HTTP.Shared.PlatformSupport.Network.Tcp.IPeekableContentProvider"/> interface too.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Streams.PeekableContentProviderStream.Unbind">
            <summary>
            This will set Consumer to null.
            </summary>
        </member>
        <member name="M:Best.HTTP.Shared.Streams.PeekableContentProviderStream.UnbindIf(Best.HTTP.Shared.PlatformSupport.Network.Tcp.IContentConsumer)">
            <summary>
            Set Consumer to null if the current one is the one passed in the parameter. 
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Streams.StreamList">
            <summary>
            Wrapper of multiple streams. Writes and reads are both supported. Read goes trough all the streams.
            </summary>
        </member>
        <member name="T:Best.HTTP.Shared.Streams.WriteOnlyBufferedStream">
            <summary>
            A custom buffer stream implementation that will not close the underlying stream.
            </summary>
        </member>
        <member name="T:Best.HTTP.JSON.Json">
             <summary>
             Based on the download from http://techblog.procurios.nl/k/news/view/14605/14863/how-do-i-write-my-own-parser-%28for-json%29.html
             This class encodes and decodes JSON strings.
             Spec. details, see http://www.json.org/
            
             JSON uses Arrays and Objects. These correspond here to the datatypes List and Dictionary.
             All numbers are parsed to doubles.
             </summary>
        </member>
        <member name="M:Best.HTTP.JSON.Json.Decode(System.String)">
            <summary>
            Parses the string json into a value
            </summary>
            <param name="json">A JSON string.</param>
            <returns>A List, a Dictionary, a double, a string, null, true, or false</returns>
        </member>
        <member name="M:Best.HTTP.JSON.Json.Decode(System.String,System.Boolean@)">
            <summary>
            Parses the string json into a value; and fills 'success' with the successfullness of the parse.
            </summary>
            <param name="json">A JSON string.</param>
            <param name="success">Successful parse?</param>
            <returns>A List, a Dictionary, a double, a string, null, true, or false</returns>
        </member>
        <member name="M:Best.HTTP.JSON.Json.Encode(System.Object)">
            <summary>
            Converts a Dictionary / List object into a JSON string
            </summary>
            <param name="json">A Dictionary / List</param>
            <returns>A JSON encoded string, or null if object 'json' is not serializable</returns>
        </member>
        <member name="M:Best.HTTP.JSON.LitJson.JsonData.ContainsKey(System.String)">
            <summary>
            Determines whether the json contains an element that has the specified key.
            </summary>
            <param name="key">The key to locate in the json.</param>
            <returns>true if the json contains an element that has the specified key; otherwise, false.</returns>
        </member>
        <member name="T:Best.HTTP.Caching.HTTPCacheBuilder">
            <summary>
            A builder struct for constructing an instance of the HTTPCache class with optional configuration options and callbacks.
            </summary>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCacheBuilder.WithOptions(Best.HTTP.Caching.HTTPCacheOptions)">
            <summary>
            Sets the configuration options for the HTTP cache.
            </summary>
            <param name="options">The <see cref="T:Best.HTTP.Caching.HTTPCacheOptions"/> containing cache configuration settings.</param>
            <returns>The current <see cref="T:Best.HTTP.Caching.HTTPCacheBuilder"/> instance for method chaining.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCacheBuilder.WithOptions(Best.HTTP.Caching.HTTPCacheOptionsBuilder)">
            <summary>
            Sets the configuration options for the HTTP cache using an <see cref="T:Best.HTTP.Caching.HTTPCacheOptionsBuilder"/>.
            </summary>
            <param name="optionsBuilder">An <see cref="T:Best.HTTP.Caching.HTTPCacheOptionsBuilder"/> for building cache configuration settings.</param>
            <returns>The current <see cref="T:Best.HTTP.Caching.HTTPCacheBuilder"/> instance for method chaining.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCacheBuilder.WithBeforeBeginCacheCallback(Best.HTTP.Caching.OnBeforeBeginCacheDelegate)">
            <summary>
            Sets a callback delegate to be executed before caching of an entity begins.
            </summary>
            <param name="callback">The delegate to be executed before caching starts.</param>
            <returns>The current <see cref="T:Best.HTTP.Caching.HTTPCacheBuilder"/> instance for method chaining.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCacheBuilder.Build">
            <summary>
            Builds and returns an instance of the <see cref="T:Best.HTTP.Caching.HTTPCache"/> with the specified configuration options and callback delegate.
            </summary>
            <returns>An <see cref="T:Best.HTTP.Caching.HTTPCache"/> instance configured with the specified options and callback.</returns>
        </member>
        <member name="T:Best.HTTP.Caching.HTTPCacheOptionsBuilder">
            <summary>
            A builder struct for constructing an instance of <see cref="T:Best.HTTP.Caching.HTTPCacheOptions"/> with optional configuration settings.
            </summary>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCacheOptionsBuilder.WithMaxCacheSize(System.UInt64)">
            <summary>
            Sets the maximum cache size for the HTTP cache.
            </summary>
            <param name="maxCacheSize">The maximum size, in bytes, that the cache can reach.</param>
            <returns>The current <see cref="T:Best.HTTP.Caching.HTTPCacheOptionsBuilder"/> instance for method chaining.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCacheOptionsBuilder.WithDeleteOlderThen(System.TimeSpan)">
            <summary>
            Sets the maximum duration for which cached entries will be retained.
            By default all entities (even stalled ones) are kept cached until they are evicted to make room for new, fresh ones.
            </summary>
            <param name="olderThan">The maximum age for cached entries to be retained.</param>
            <returns>The current <see cref="T:Best.HTTP.Caching.HTTPCacheOptionsBuilder"/> instance for method chaining.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCacheOptionsBuilder.Build">
            <summary>
            Builds and returns an instance of <see cref="T:Best.HTTP.Caching.HTTPCacheOptions"/> with the specified configuration settings.
            </summary>
            <returns>An <see cref="T:Best.HTTP.Caching.HTTPCacheOptions"/> instance configured with the specified settings.</returns>
        </member>
        <member name="T:Best.HTTP.Caching.ErrorTypeForValidation">
            <summary>
            Types of errors that can occur during cache validation.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.ErrorTypeForValidation.None">
            <summary>
            Indicates that no error has occurred during validation.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.ErrorTypeForValidation.ServerError">
            <summary>
            Indicates a server error has occurred during validation.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.ErrorTypeForValidation.ConnectionError">
            <summary>
            Indicates a connection error has occurred during validation.
            </summary>
        </member>
        <member name="T:Best.HTTP.Caching.OnBeforeBeginCacheDelegate">
            <summary>
            Represents a delegate that can be used to perform actions before caching of an entity begins.
            </summary>
            <param name="method">The HTTP method used in the request.</param>
            <param name="uri">The URI of the HTTP request.</param>
            <param name="statusCode">The HTTP status code of the response.</param>
            <param name="headers">The HTTP response headers.</param>
            <param name="context">An optional logging context for debugging.</param>
        </member>
        <member name="T:Best.HTTP.Caching.OnCacheSizeChangedDelegate">
            <summary>
            Represents a delegate that can be used to handle cache size change events.
            </summary>
        </member>
        <member name="T:Best.HTTP.Caching.HTTPCache">
            <summary>
            Manages caching of HTTP responses and associated metadata.
            </summary>
            <remarks>
            <para>The `HTTPCache` class provides a powerful caching mechanism for HTTP responses in Unity applications. 
            It allows you to store and retrieve HTTP responses efficiently, reducing network requests and improving 
            the performance of your application. By utilizing HTTP caching, you can enhance user experience, reduce 
            bandwidth usage, and optimize loading times.
            </para>
            <para>
            Key features:
            <list type="bullet">
                <item><term>Optimal User Experience</term><description>Users experience faster load times and smoother interactions, enhancing user satisfaction.</description></item>
                <item><term>Efficient Caching</term><description>It enables efficient caching of HTTP responses, reducing the need to fetch data from the network repeatedly.</description></item>
                <item><term>Improved Performance</term><description>Caching helps improve the performance of your Unity application by reducing latency and decreasing loading times.</description></item>
                <item><term>Bandwidth Optimization</term><description>By storing and reusing cached responses, you can minimize bandwidth usage, making your application more data-friendly.</description></item>
                <item><term>Offline Access</term><description>Cached responses allow your application to function even when the device is offline or has limited connectivity.</description></item>
                <item><term>Reduced Server Load</term><description>Fewer network requests mean less load on your server infrastructure, leading to cost savings and improved server performance.</description></item>
                <item><term>Manual Cache Control</term><description>You can also manually control caching by adding, removing, or updating cached responses.</description></item>
            </list>
            </para>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Caching.HTTPCache.RootFolderName">
            <summary>
            Constants defining folder and file names used in the HTTP cache storage.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.HTTPCache.CacheHostName">
            <summary>
            This is the reversed domain the plugin uses for file paths when it have to load content from the local cache.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.HTTPCache.OnCacheSizeChanged">
            <summary>
            Event that is triggered when the size of the cache changes.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.HTTPCache.Options">
            <summary>
            Gets the options that define the behavior of the HTTP cache.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.HTTPCache.CacheSize">
            <summary>
            Gets the current size of the HTTP cache in bytes.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.HTTPCache.OnBeforeBeginCache">
            <summary>
            Called before the plugin calls <see cref="M:Best.HTTP.Caching.HTTPCache.BeginCache(Best.HTTP.HTTPMethods,System.Uri,System.Int32,System.Collections.Generic.Dictionary{System.String,System.Collections.Generic.List{System.String}},Best.HTTP.Shared.Logger.LoggingContext)"/> to decide whether the content will be cached or not.
            </summary>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.#ctor(Best.HTTP.Caching.HTTPCacheOptions)">
            <summary>
            Initializes a new instance of the HTTPCache class with the specified cache options.
            </summary>
            <param name="options">The HTTP cache options specifying cache size and deletion policy.</param>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.CalculateHash(Best.HTTP.HTTPMethods,System.Uri)">
            <summary>
            Calculates a unique hash identifier based on the HTTP method and URI.
            </summary>
            <param name="method">The HTTP method used in the request.</param>
            <param name="uri">The URI of the HTTP request.</param>
            <returns>A unique hash identifier for the combination of method and URI.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.GetHashDirectory(UnityEngine.Hash128)">
            <summary>
            Generates the directory path based on the given hash where cached content is stored.
            </summary>
            <param name="hash">A unique hash identifier for the cached content, returned by <see cref="M:Best.HTTP.Caching.HTTPCache.CalculateHash(Best.HTTP.HTTPMethods,System.Uri)"/>.</param>
            <returns>The directory path for the cached content associated with the given hash.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.GetHeaderPathFromHash(UnityEngine.Hash128)">
            <summary>
            Generates the file path for the header cache associated with the given hash.
            </summary>
            <param name="hash">A unique hash identifier for the cached content, returned by <see cref="M:Best.HTTP.Caching.HTTPCache.CalculateHash(Best.HTTP.HTTPMethods,System.Uri)"/>.</param>
            <returns>The file path for the header cache associated with the given hash.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.GetContentPathFromHash(UnityEngine.Hash128)">
            <summary>
            Generates the file path for the content cache associated with the given hash.
            </summary>
            <param name="hash">A unique hash identifier for the cached content, returned by <see cref="M:Best.HTTP.Caching.HTTPCache.CalculateHash(Best.HTTP.HTTPMethods,System.Uri)"/>.</param>
            <returns>The file path for the content cache associated with the given hash.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.AreCacheFilesExists(UnityEngine.Hash128)">
            <summary>
            Checks whether cache files (header and content) associated with the given hash exist.
            </summary>
            <param name="hash">A unique hash identifier for the cached content.</param>
            <returns><c>true</c> if both header and content cache files exist, otherwise <c>false</c>.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.SetupValidationHeaders(Best.HTTP.HTTPRequest)">
            <summary>
            Sets up validation headers on an HTTP request if a locally cached response exists.
            </summary>
            <param name="request">The <see cref="T:Best.HTTP.HTTPRequest"/> to which validation headers will be added.</param>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.IsThereEnoughSpaceAfterMaintain(System.UInt64,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            If necessary tries to make enough space in the cache by calling Maintain.
            </summary>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.BeginCache(Best.HTTP.HTTPMethods,System.Uri,System.Int32,System.Collections.Generic.Dictionary{System.String,System.Collections.Generic.List{System.String}},Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Initiates the caching process for an HTTP response, creating an <see cref="T:Best.HTTP.Caching.HTTPCacheContentWriter"/> if caching is enabled and all predconditions are met.
            </summary>
            <param name="method">The <see cref="T:Best.HTTP.HTTPRequest"/> method used to fetch the response.</param>
            <param name="uri">The URI for the response.</param>
            <param name="statusCode">The HTTP status code of the response.</param>
            <param name="headers">The HTTP headers of the response.</param>
            <param name="context">An optional logging context for debugging.</param>
            <returns>An <see cref="T:Best.HTTP.Caching.HTTPCacheContentWriter"/> instance for writing the response content to the cache, or null if caching is not enabled or not possible.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.EndCache(Best.HTTP.Caching.HTTPCacheContentWriter,System.Boolean,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Finalizes the caching process and takes appropriate actions based on the completion status.
            </summary>
            <param name="cacheResult">The <see cref="T:Best.HTTP.Caching.HTTPCacheContentWriter"/> instance representing the caching operation.</param>
            <param name="completedWithoutIssue">A boolean indicating whether the caching process completed without issues.</param>
            <param name="context">An optional logging context for debugging.</param>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.BeginReadContent(UnityEngine.Hash128,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Initiates the process of reading cached content associated with a given hash. Call BeginReadContent to acquire a Stream object that points to the cached resource.
            </summary>
            <param name="hash">A hash from <see cref="M:Best.HTTP.Caching.HTTPCache.CalculateHash(Best.HTTP.HTTPMethods,System.Uri)"/> identifying the resource.</param>
            <param name="context">An optional <see cref="T:Best.HTTP.Shared.Logger.LoggingContext"/></param>
            <returns>A stream for reading the cached content, or null if the content could not be read (the resource isn't cached or currently downloading).</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.EndReadContent(UnityEngine.Hash128,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Finalizes the process of reading cached content associated with a given hash.
            </summary>
            <param name="hash">The unique hash identifier for the cached content.</param>
            <param name="context">An optional logging context for debugging.</param>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.Delete(UnityEngine.Hash128,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Deletes a cached entry identified by the given hash, including its associated header and content files.
            </summary>
            <param name="hash">The unique hash identifier for the cached entry to be deleted.</param>
            <param name="context">An optional logging context for debugging.</param>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.RefreshHeaders(UnityEngine.Hash128,System.Collections.Generic.Dictionary{System.String,System.Collections.Generic.List{System.String}},Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Refreshes the headers of a cached HTTP response with new headers.
            </summary>
            <param name="hash">A unique hash identifier for the cached response from a <see cref="M:Best.HTTP.Caching.HTTPCache.CalculateHash(Best.HTTP.HTTPMethods,System.Uri)"/> call.</param>
            <param name="newHeaders">A dictionary of new headers to replace or merge with existing headers.</param>
            <param name="context">Used by the plugin to add an addition logging context for debugging. It can be <c>null</c>.</param>
            <returns><c>true</c> if the headers were successfully refreshed; otherwise, <c>false</c>.</returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.CanServeWithoutValidation(UnityEngine.Hash128,Best.HTTP.Caching.ErrorTypeForValidation,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Checks whether the caches resource identified by the hash is can be served from the local store with the given error conditions. 
            </summary>
            <remarks>This check reflects the very current state, even if it returns <c>true</c>, a request might just executing to get a write lock on it to refresh the content.</remarks>
            <param name="hash"><see cref="T:UnityEngine.Hash128"/> hash returned by <see cref="M:Best.HTTP.Caching.HTTPCache.CalculateHash(Best.HTTP.HTTPMethods,System.Uri)"/> identifying a resource.</param>
            <param name="errorType">Possible error condition that can occur during validation. Servers can provision that certain stalled resources can be served if revalidation fails.</param>
            <param name="context">Used by the plugin to add an addition logging context for debugging. It can be <c>null</c>.</param>
            <returns><c>true</c> if the cached response can be served without validating it with the origin server; otherwise, <c>false</c></returns>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.Redirect(Best.HTTP.HTTPRequest,UnityEngine.Hash128)">
            <summary>
            Redirects a request to a cached entity.
            </summary>
            <param name="request">The <see cref="T:Best.HTTP.HTTPRequest"/> that will be redirected.</param>
            <param name="hash">Hash obtained from <see cref="M:Best.HTTP.Caching.HTTPCache.CalculateHash(Best.HTTP.HTTPMethods,System.Uri)"/>.</param>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCache.Clear">
            <summary>
            Clears the HTTP cache by removing all cached entries and associated metadata.
            </summary>
        </member>
        <member name="T:Best.HTTP.Caching.HTTPCacheContentWriter">
            <summary>
            Represents a writer for caching HTTP response content.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.HTTPCacheContentWriter.Cache">
            <summary>
            Gets the parent HTTPCache instance associated with this content writer.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.HTTPCacheContentWriter.Hash">
            <summary>
            Hash identifying the resource. If <see cref="M:Best.HTTP.Caching.HTTPCacheContentWriter.Write(Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment)"/> fails, it becomes an invalid one.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.HTTPCacheContentWriter.ExpectedLength">
            <summary>
            Expected length of the content. Has a non-zero value only when the server is sending a "content-length" header.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.HTTPCacheContentWriter.ProcessedLength">
            <summary>
            Number of bytes written to the cache.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.HTTPCacheContentWriter.Context">
            <summary>
            Context of this cache writer used for logging.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.HTTPCacheContentWriter._contentStream">
            <summary>
            Underlying stream the download bytes are written into.
            </summary>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCacheContentWriter.Write(Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment)">
            <summary>
            Writes content to the underlying stream. 
            </summary>
            <param name="segment"><see cref="T:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment"/> holding a reference to the data and containing information about the offset and count of the valid range of data.</param>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCacheContentWriter.Close">
            <summary>
            Close the underlying stream and invalidate the hash.
            </summary>
        </member>
        <member name="T:Best.HTTP.Caching.LockTypes">
            <summary>
            Possible lock-states a cache-content can be in.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.LockTypes.Unlocked">
            <summary>
            No reads or writes are happening on the cached content.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.LockTypes.Write">
            <summary>
            There's one writer operating on the cached content. No other writes or reads allowed while this lock is held on the content.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.LockTypes.Read">
            <summary>
            There's at least one read operation happening on the cached content. No writes allowed while this lock is held on the content.
            </summary>
        </member>
        <member name="T:Best.HTTP.Caching.CacheMetadata">
            <summary>
            Metadata stored for every cached content. It contains only limited data about the content to help early cache decision making and cache management.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.CacheMetadata.Hash">
            <summary>
            Unique hash of the cached content, generated by <see cref="M:Best.HTTP.Caching.HTTPCache.CalculateHash(Best.HTTP.HTTPMethods,System.Uri)"/>.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.CacheMetadata.ContentLength">
            <summary>
            Size of the stored content in bytes.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.CacheMetadata.LastAccessTime">
            <summary>
            When the last time the content is accessed. Also initialized when the initial download completes.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.CacheMetadata.Lock">
            <summary>
            What kind of lock the content is currently in.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.CacheMetadata.ReadLockCount">
            <summary>
            Number of readers.
            </summary>
        </member>
        <member name="T:Best.HTTP.Caching.CacheFlags">
            <summary>
            Possible caching flags that a `Cache-Control` header can send.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.CacheFlags.None">
            <summary>
            No special treatment required.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.CacheFlags.MustRevalidate">
            <summary>
            Indicates whether the entity must be revalidated with the server or can be serverd directly from the cache without touching the server when the content is considered stale.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://www.rfc-editor.org/rfc/rfc9111.html#name-must-revalidate"/></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Caching.CacheFlags.NoCache">
            <summary>
            If it's true, the client always have to revalidate the cached content when it's stale.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://www.rfc-editor.org/rfc/rfc9111.html#name-no-cache-2"/></description></item>
            </list>
            </remarks>
        </member>
        <member name="T:Best.HTTP.Caching.CacheMetadataContent">
            <summary>
            Cached content associated with a <see cref="T:Best.HTTP.Caching.CacheMetadata"/>.
            </summary>
            <remarks>This is NOT the cached content received from the server! It's for storing caching values to decide on how the content can be used.</remarks>
        </member>
        <member name="F:Best.HTTP.Caching.CacheMetadataContent.ETag">
            <summary>
            ETag of the entity.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/ETag"/></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Caching.CacheMetadataContent.LastModified">
            <summary>
            LastModified date of the entity. Use ToString("r") to convert it to the format defined in RFC 1123.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.CacheMetadataContent.Expires">
            <summary>
            When the cache will expire.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://www.rfc-editor.org/rfc/rfc9111.html#name-expires"/></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Caching.CacheMetadataContent.Age">
            <summary>
            The age that came with the response
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://www.rfc-editor.org/rfc/rfc9111.html#name-age"/></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Caching.CacheMetadataContent.MaxAge">
            <summary>
            Maximum how long the entry should served from the cache without revalidation.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://www.rfc-editor.org/rfc/rfc9111.html#name-max-age-2"/></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Caching.CacheMetadataContent.Date">
            <summary>
            The Date that came with the response.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Date"/></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Caching.CacheMetadataContent.StaleWhileRevalidate">
            <summary>
            It's a grace period to serve staled content without revalidation.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://www.rfc-editor.org/rfc/rfc5861.html#section-3"/></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Caching.CacheMetadataContent.StaleIfError">
            <summary>
            Allows the client to serve stale content if the server responds with an 5xx error.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://www.rfc-editor.org/rfc/rfc5861.html#section-4"/></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Caching.CacheMetadataContent.Flags">
            <summary>
            bool values packed into one single flag.
            </summary>
        </member>
        <member name="F:Best.HTTP.Caching.CacheMetadataContent.RequestTime">
            <summary>
            The value of the clock at the time of the request that resulted in the stored response.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://www.rfc-editor.org/rfc/rfc9111.html#section-4.2.3-3.8"/></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Caching.CacheMetadataContent.ResponseTime">
            <summary>
            The value of the clock at the time the response was received.
            </summary>
        </member>
        <member name="T:Best.HTTP.Caching.HTTPCacheOptions">
            <summary>
            Represents the configuration options for the HTTP cache.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.HTTPCacheOptions.DeleteOlder">
            <summary>
            Gets or sets the maximum duration for which cached entries will be retained.
            </summary>
        </member>
        <member name="P:Best.HTTP.Caching.HTTPCacheOptions.MaxCacheSize">
            <summary>
            Gets or sets the maximum size, in bytes, that the cache can reach.
            </summary>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCacheOptions.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Best.HTTP.Caching.HTTPCacheOptions"/> class with default settings.
            </summary>
        </member>
        <member name="M:Best.HTTP.Caching.HTTPCacheOptions.#ctor(System.TimeSpan,System.UInt64)">
            <summary>
            Initializes a new instance of the <see cref="T:Best.HTTP.Caching.HTTPCacheOptions"/> class with custom settings.
            </summary>
            <param name="deleteOlder">The maximum age for cached entries to be retained.</param>
            <param name="maxCacheSize">The maximum size, in bytes, that the cache can reach.</param>
        </member>
        <member name="T:Best.HTTP.Cookies.Cookie">
            <summary>
            The Cookie implementation based on <see href="http://tools.ietf.org/html/rfc6265">RFC-6265</see>.
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.Name">
            <summary>
            The name of the cookie.
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.Value">
            <summary>
            The value of the cookie.
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.Date">
            <summary>
            The Date when the Cookie is registered.
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.LastAccess">
            <summary>
            When this Cookie last used in a request.
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.Expires">
            <summary>
            The Expires attribute indicates the maximum lifetime of the cookie, represented as the date and time at which the cookie expires.
            The user agent is not required to retain the cookie until the specified date has passed.
            In fact, user agents often evict cookies due to memory pressure or privacy concerns.
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.MaxAge">
            <summary>
            The Max-Age attribute indicates the maximum lifetime of the cookie, represented as the number of seconds until the cookie expires.
            The user agent is not required to retain the cookie for the specified duration.
            In fact, user agents often evict cookies due to memory pressure or privacy concerns.
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.IsSession">
            <summary>
            If a cookie has neither the Max-Age nor the Expires attribute, the user agent will retain the cookie until "the current session is over".
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.Domain">
            <summary>
            The Domain attribute specifies those hosts to which the cookie will be sent.
            For example, if the value of the Domain attribute is "example.com", the user agent will include the cookie
            in the Cookie header when making HTTP requests to example.com, www.example.com, and www.corp.example.com.
            If the server omits the Domain attribute, the user agent will return the cookie only to the origin server.
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.Path">
            <summary>
            The scope of each cookie is limited to a set of paths, controlled by the Path attribute.
            If the server omits the Path attribute, the user agent will use the "directory" of the request-uri's path component as the default value.
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.IsSecure">
            <summary>
            The Secure attribute limits the scope of the cookie to "secure" channels (where "secure" is defined by the user agent).
            When a cookie has the Secure attribute, the user agent will include the cookie in an HTTP request only if the request is
            transmitted over a secure channel (typically HTTP over Transport Layer Security (TLS)).
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.IsHttpOnly">
            <summary>
            The HttpOnly attribute limits the scope of the cookie to HTTP requests.
            In particular, the attribute instructs the user agent to omit the cookie when providing access to
            cookies via "non-HTTP" APIs (such as a web browser API that exposes cookies to scripts).
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.Cookie.SameSite">
            <summary>
            SameSite prevents the browser from sending this cookie along with cross-site requests.
            The main goal is mitigate the risk of cross-origin information leakage.
            It also provides some protection against cross-site request forgery attacks.
            Possible values for the flag are lax or strict.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://web.dev/samesite-cookies-explained/">SameSite cookies explained</see></description></item>
            </list>
            </remarks>
        </member>
        <member name="M:Best.HTTP.Cookies.Cookie.GuessSize">
            <summary>
            Guess the storage size of the cookie.
            </summary>
            <returns></returns>
        </member>
        <member name="T:Best.HTTP.Cookies.CookieJar">
            <summary>
            The Cookie Jar implementation based on <see href="http://tools.ietf.org/html/rfc6265">RFC 6265</see>.
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.CookieJar.MaximumSize">
            <summary>
            Maximum size of the Cookie Jar in bytes. It's default value is 10485760 (10 MB).
            </summary>
        </member>
        <member name="P:Best.HTTP.Cookies.CookieJar.IsSavingSupported">
            <summary>
            Returns true if File apis are supported.
            </summary>
        </member>
        <member name="F:Best.HTTP.Cookies.CookieJar.AccessThreshold">
            <summary>
            The plugin will delete cookies that are accessed this threshold ago. Its default value is 7 days.
            </summary>
        </member>
        <member name="F:Best.HTTP.Cookies.CookieJar.IsSessionOverride">
            <summary>
            If this property is set to <c>true</c>, then new cookies treated as session cookies and these cookies are not saved to disk. Its default value is <c>false</c>.
            </summary>
        </member>
        <member name="F:Best.HTTP.Cookies.CookieJar.IsEnabled">
            <summary>
            Enabled or disables storing and handling of cookies. If set to false, <see cref="T:Best.HTTP.HTTPRequest">HTTPRequests</see> aren't searched for cookies and no cookies will be set for <see cref="T:Best.HTTP.HTTPResponse"/>s.
            </summary>
        </member>
        <member name="F:Best.HTTP.Cookies.CookieJar.Cookies">
            <summary>
            List of the Cookies
            </summary>
        </member>
        <member name="F:Best.HTTP.Cookies.CookieJar.rwLock">
            <summary>
            Synchronization object for thread safety.
            </summary>
        </member>
        <member name="M:Best.HTTP.Cookies.CookieJar.SetFromRequest(Best.HTTP.HTTPResponse)">
            <summary>
            Will set or update all cookies from the response object.
            </summary>
        </member>
        <member name="M:Best.HTTP.Cookies.CookieJar.Maintain(System.Boolean)">
            <summary>
            Deletes all expired or 'old' cookies, and will keep the sum size of cookies under the given size.
            </summary>
        </member>
        <member name="M:Best.HTTP.Cookies.CookieJar.Persist">
            <summary>
            Saves the Cookie Jar to a file.
            </summary>
            <remarks>Not implemented under Unity WebPlayer</remarks>
        </member>
        <member name="M:Best.HTTP.Cookies.CookieJar.Load">
            <summary>
            Load previously persisted cookie library from the file.
            </summary>
        </member>
        <member name="M:Best.HTTP.Cookies.CookieJar.Get(System.Uri)">
            <summary>
            Returns all Cookies that corresponds to the given Uri.
            </summary>
        </member>
        <member name="M:Best.HTTP.Cookies.CookieJar.Set(System.Uri,Best.HTTP.Cookies.Cookie)">
            <summary>
            Will add a new, or overwrite an old cookie if already exists.
            </summary>
        </member>
        <member name="M:Best.HTTP.Cookies.CookieJar.Set(Best.HTTP.Cookies.Cookie)">
            <summary>
            Will add a new, or overwrite an old cookie if already exists.
            </summary>
        </member>
        <member name="M:Best.HTTP.Cookies.CookieJar.Clear">
            <summary>
            Deletes all cookies from the Jar.
            </summary>
        </member>
        <member name="M:Best.HTTP.Cookies.CookieJar.Clear(System.TimeSpan)">
            <summary>
            Removes cookies that older than the given parameter.
            </summary>
        </member>
        <member name="M:Best.HTTP.Cookies.CookieJar.Clear(System.String)">
            <summary>
            Removes cookies that matches to the given domain.
            </summary>
        </member>
        <member name="M:Best.HTTP.Cookies.CookieJar.Find(Best.HTTP.Cookies.Cookie,System.Int32@)">
            <summary>
            Find and return a Cookie and his index in the list.
            </summary>
        </member>
        <member name="T:Best.HTTP.Hosts.Connections.ConnectionBase">
            <summary>
            Abstract base class for concrete connection implementation (HTTP/1, HTTP/2, WebGL, File).
            </summary>
        </member>
        <member name="P:Best.HTTP.Hosts.Connections.ConnectionBase.HostKey">
            <summary>
            The address of the server that this connection is bound to.
            </summary>
        </member>
        <member name="P:Best.HTTP.Hosts.Connections.ConnectionBase.State">
            <summary>
            The state of this connection.
            </summary>
        </member>
        <member name="P:Best.HTTP.Hosts.Connections.ConnectionBase.CurrentRequest">
            <summary>
            If the State is HTTPConnectionStates.Processing, then it holds a HTTPRequest instance. Otherwise it's null.
            </summary>
        </member>
        <member name="P:Best.HTTP.Hosts.Connections.ConnectionBase.KeepAliveTime">
            <summary>
            How much the connection kept alive after its last request processing.
            </summary>
        </member>
        <member name="P:Best.HTTP.Hosts.Connections.ConnectionBase.AssignedRequests">
            <summary>
            Number of assigned requests to process.
            </summary>
        </member>
        <member name="P:Best.HTTP.Hosts.Connections.ConnectionBase.MaxAssignedRequests">
            <summary>
            Maximum number of assignable requests.
            </summary>
        </member>
        <member name="P:Best.HTTP.Hosts.Connections.ConnectionBase.StartTime">
            <summary>
            When we start to process the current request. It's set after the connection is established.
            </summary>
        </member>
        <member name="M:Best.HTTP.Hosts.Connections.ConnectionBase.Shutdown(Best.HTTP.Shared.ShutdownTypes)">
            <summary>
            Called when the plugin shuts down immediately.
            </summary>
        </member>
        <member name="T:Best.HTTP.Hosts.Connections.KeepAliveHeader">
            <summary>
            https://tools.ietf.org/html/draft-thomson-hybi-http-timeout-03
            Test servers: http://tools.ietf.org/ http://nginx.org/
            </summary>
        </member>
        <member name="P:Best.HTTP.Hosts.Connections.KeepAliveHeader.TimeOut">
            <summary>
            A host sets the value of the "timeout" parameter to the time that the host will allow an idle connection to remain open before it is closed. A connection is idle if no data is sent or received by a host.
            </summary>
        </member>
        <member name="P:Best.HTTP.Hosts.Connections.KeepAliveHeader.MaxRequests">
            <summary>
            The "max" parameter has been used to indicate the maximum number of requests that would be made on the connection.This parameter is deprecated.Any limit on requests can be enforced by sending "Connection: close" and closing the connection.
            </summary>
        </member>
        <member name="T:Best.HTTP.Hosts.Connections.ConnectionHelper">
            <summary>
            Static helper class to handle cases where the plugin has to do additional logic based on the received response. These are like connection management, handling redirections, loading from local cache, authentication challanges, etc.
            </summary>
        </member>
        <member name="M:Best.HTTP.Hosts.Connections.ConnectionHelper.HandleResponse(Best.HTTP.HTTPRequest,System.Boolean@,Best.HTTP.Hosts.Connections.HTTPConnectionStates@,Best.HTTP.Hosts.Connections.KeepAliveHeader@,Best.HTTP.Shared.Logger.LoggingContext)">
            <summary>
            Called when the whole response received
            </summary>
        </member>
        <member name="T:Best.HTTP.Hosts.Connections.HTTP1.PeekableHTTP1Response">
            <summary>
            An HTTP 1.1 response implementation that can utilize a peekable stream.
            Its main entry point is the ProcessPeekable method that should be called after every chunk of data downloaded.
            </summary>
        </member>
        <member name="T:Best.HTTP.Hosts.Connections.HTTPConnectionStates">
            <summary>
            Possible states of a Http Connection.
            The ideal lifecycle of a connection that has KeepAlive is the following: Initial => [Processing => WaitForRecycle => Free] => Closed.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Connections.HTTPConnectionStates.Initial">
            <summary>
            This Connection instance is just created.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Connections.HTTPConnectionStates.Processing">
            <summary>
            This Connection is processing a request
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Connections.HTTPConnectionStates.WaitForProtocolShutdown">
            <summary>
            Wait for the upgraded protocol to shut down.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Connections.HTTPConnectionStates.Recycle">
            <summary>
            The Connection is finished processing the request, it's waiting now to deliver it's result.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Connections.HTTPConnectionStates.Free">
            <summary>
            The request result's delivered, it's now up to processing again.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Connections.HTTPConnectionStates.Closed">
            <summary>
            If it's not a KeepAlive connection, or something happened, then we close this connection and remove from the pool.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Connections.HTTPConnectionStates.ClosedResendRequest">
            <summary>
            Same as the Closed state, but processing this request requires resending the last processed request too.
            </summary>
        </member>
        <member name="T:Best.HTTP.Hosts.Connections.IDownloadContentBufferAvailable">
            <summary>
            Defines an interface for notifying connections when space becomes available in a buffer for downloading data.
            Connections implementating of this interface are used to signal their internal logic that they can transfer data into the available buffer space.
            </summary>
        </member>
        <member name="M:Best.HTTP.Hosts.Connections.IDownloadContentBufferAvailable.BufferAvailable(Best.HTTP.Response.DownloadContentStream)">
            <summary>
            Notifies a connection that space has become available in the buffer for downloading data.
            When invoked, this method indicates to a connection that it can transfer additional data into the buffer for further processing.
            </summary>
            <param name="stream">The <see cref="T:Best.HTTP.Response.DownloadContentStream"/> instance associated with the buffer.</param>
        </member>
        <member name="T:Best.HTTP.Hosts.Connections.IThreadSignaler">
            <summary>
            Interface for signaling upload threads.
            </summary>
        </member>
        <member name="P:Best.HTTP.Hosts.Connections.IThreadSignaler.Context">
            <summary>
            A <see cref="T:Best.HTTP.Shared.Logger.LoggingContext"/> instance for debugging purposes.
            </summary>
            <remarks>
            To help <see cref="T:Best.HTTP.Request.Upload.UploadStreamBase"/> implementors log in the IThreadSignaler's context,
            the interface implementors must make their logging context accessible.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Hosts.Connections.IThreadSignaler.SignalThread">
            <summary>
            Signals the associated thread to resume or wake up.
            </summary>
        </member>
        <member name="M:Best.HTTP.Hosts.Connections.WebGL.WebGLXHRNativeInterface.XHR_SetTimeout(System.Int32,System.UInt32)">
            <summary>
            Is an unsigned long representing the number of milliseconds a request can take before automatically being terminated. A value of 0 (which is the default) means there is no timeout.
            </summary>
        </member>
        <member name="T:Best.HTTP.Hosts.Settings.AsteriskStringComparer">
            <summary>
            Moves any added asterisk(*) to the end of the list.
            </summary>
        </member>
        <member name="T:Best.HTTP.Hosts.Settings.HTTRequestSettings">
            <summary>
            Settings for HTTP requests.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HTTRequestSettings.ConnectTimeout">
            <summary>
            The timeout for establishing a connection.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HTTRequestSettings.RequestTimeout">
            <summary>
            The maximum time allowed for the request to complete.
            </summary>
        </member>
        <member name="T:Best.HTTP.Hosts.Settings.HTTP1ConnectionSettings">
            <summary>
            Settings for HTTP/1 connections.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HTTP1ConnectionSettings.TryToReuseConnections">
            <summary>
            Indicates whether the connection should be open after receiving the response.
            </summary>
            <remarks>
            If set to <c>true</c>, internal TCP connections will be reused whenever possible.
            If making rare requests to the server, it's recommended to change this to <c>false</c>.
            </remarks>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HTTP1ConnectionSettings.MaxConnectionIdleTime">
            <summary>
            The maximum time a connection can remain idle before being closed.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HTTP1ConnectionSettings.ForceUseThreadPool">
            <summary>
            Indicates whether the upload thread should use a <see href="https://learn.microsoft.com/en-us/dotnet/api/system.threading.threadpool">ThreadPool</see> thread instead of creating and using a <see href="https://learn.microsoft.com/en-us/dotnet/api/system.threading.thread">Thread</see>.
            </summary>
            <remarks>The plugin tries to use ThreadPool threads for known short-living uploads like requests without upload body. With <c>ForceUseThreadPool</c> all HTTP/1 requests, including long uploads or downloads can be forced to use ThreadPool threads.</remarks>
        </member>
        <member name="T:Best.HTTP.Hosts.Settings.HostVariantSettings">
            <summary>
            Settings for <see cref="T:Best.HTTP.HostSetting.HostVariant"/>s.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HostVariantSettings.MaxConnectionPerVariant">
            <summary>
            The maximum number of connections allowed per host variant.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HostVariantSettings.MaxAssignedRequestsFactor">
            <summary>
            Factor used when calculations are made whether to open a new connection to the server or not.
            </summary>
            <remarks>
            It has an effect on HTTP/2 connections only.
            <para>Higher values (gte <c>1.0f</c>) delay, lower values (lte <c>1.0f</c>) bring forward creation of new connections.</para>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HostVariantSettings.VariantFactory">
            <summary>
            Factory function to generate HostVariant or descendent instances.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HostVariantSettings.ConnectionFactory">
            <summary>
            Factory function to generate custom connection implementations.
            </summary>
        </member>
        <member name="T:Best.HTTP.Hosts.Settings.LowLevelConnectionSettings">
            <summary>
            Represents the low-level TCP buffer settings for connections.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.LowLevelConnectionSettings.TCPWriteBufferSize">
            <summary>
            Gets or sets the size of the TCP write buffer in bytes. 
            </summary>
            <remarks>
            <para>Default value is 1 MiB.</para>
            <para>This determines the maximum amount of data that that the <see cref="!:TCPStreamer"/> class can buffer up if it's already in a write operation.
            Increasing this value can potentially improve write performance, especially for large messages or data streams. 
            However, setting it too high might consume a significant amount of memory, especially if there are many active connections.
            </para>
            </remarks>
            <value>The size of the TCP write buffer in bytes.</value>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.LowLevelConnectionSettings.ReadBufferSize">
            <summary>
            Gets or sets the size of the read buffer in bytes. 
            </summary>
            <value>The size of the read buffer in bytes.</value>
            <remarks>
            <para>Default value is 1 MiB.</para>
            <para>This determines the maximum amount of data that low level streams and the <see cref="!:TCPStreamer"/> can buffer up for consuming by higher level layers.
            Adjusting this value can affect the read performance of the application. 
            Like the write buffer, setting this too high might be memory-intensive, especially with many connections. 
            It's advised to find a balance that suits the application's needs and resources.
            </para>
            </remarks>
        </member>
        <member name="T:Best.HTTP.Hosts.Settings.HostSettings">
            <summary>
            Contains settings that can be associated with a specific host or host variant.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HostSettings.LowLevelConnectionSettings">
            <summary>
            Gets or sets the low-level TCP buffer settings for connections associated with the host or host variant.
            </summary>
            <value>The low-level TCP buffer settings.</value>
            <remarks>
            These settings determine the buffer sizes for reading from and writing to TCP connections, 
            which can impact performance and memory usage.
            </remarks>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HostSettings.RequestSettings">
            <summary>
            Settings related to HTTP requests made to this host or host variant.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HostSettings.HTTP1ConnectionSettings">
            <summary>
            Settings related to HTTP/1.x connection behavior.
            </summary>
        </member>
        <member name="F:Best.HTTP.Hosts.Settings.HostSettings.HostVariantSettings">
            <summary>
            Settings related to <see cref="T:Best.HTTP.HostSetting.HostVariant"/> behavior.
            </summary>
        </member>
        <member name="T:Best.HTTP.Hosts.Settings.HostSettingsManager">
            Host Settings Hierarchy for the following hosts, settings are stored as leafs:
            
            *.com
            *.example.com
            example.com
            
            '*' matches one or more subdomains so *.example.com 
             - matches a.example.com and a.b.example.com
             - but doesn't match example.com!
            
                                         
                                          
                               [com]                 [localhost]                [org]                      [*]
                          +------+------+                 |                       |                         |
                          |             |              [setting]                 [*]                     [setting]
                    [example]          [*]                                        |
                    /       \           |                                      [setting]
                  [b]     [setting]  [setting]
                   |
                  [a]
                   |
                [setting]
            
            <summary>
            Manages host-specific settings for HTTP requests based on hostnames.
            The HostSettingsManager is a powerful tool for fine-tuning HTTP request and connection behaviors
            on a per-host basis. It enables you to define custom settings for specific hostnames 
            while maintaining default settings for all other hosts. This level of granularity allows you to
            optimize and customize HTTP requests for different endpoints within your application.
            </summary>
            <remarks>
            When host-specific settings are not found for a given host variant, the default <see cref="T:Best.HTTP.Hosts.Settings.HostSettings"/>
            associated with the "*" host will be returned.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Hosts.Settings.HostSettingsManager.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Best.HTTP.Hosts.Settings.HostSettingsManager"/> class with default settings for all hosts ("*").
            </summary>
        </member>
        <member name="M:Best.HTTP.Hosts.Settings.HostSettingsManager.AddDefault(System.Uri)">
            <summary>
            Adds default settings for the host part of the specified URI. This is equivalent to calling <see cref="M:Best.HTTP.Hosts.Settings.HostSettingsManager.Add(System.Uri,Best.HTTP.Hosts.Settings.HostSettings)"/> with the a new <see cref="T:Best.HTTP.Hosts.Settings.HostSettings"/>.
            </summary>
            <param name="uri">The URI for which default settings should be applied. Only the host part of the URI will be used.</param>
            <returns>A <see cref="T:Best.HTTP.Hosts.Settings.HostSettings"/> instance with default values.</returns>
        </member>
        <member name="M:Best.HTTP.Hosts.Settings.HostSettingsManager.AddDefault(System.String)">
            <summary>
            Adds default settings for the the specified host name. This is equivalent to calling <see cref="M:Best.HTTP.Hosts.Settings.HostSettingsManager.Add(System.String,Best.HTTP.Hosts.Settings.HostSettings)"/> with the a new <see cref="T:Best.HTTP.Hosts.Settings.HostSettings"/>.
            </summary>
            <param name="hostname">The hostname for which default settings should be applied.</param>
            <returns>A <see cref="T:Best.HTTP.Hosts.Settings.HostSettings"/> instance with default values.</returns>
        </member>
        <member name="M:Best.HTTP.Hosts.Settings.HostSettingsManager.Add(System.Uri,Best.HTTP.Hosts.Settings.HostSettings)">
            <summary>
            Adds host-specific settings for the host part of the specified URI.
            </summary>
            <param name="uri">The URI for which settings should be applied. Only the host part of the URI will be used.</param>
            <param name="settings">The <see cref="T:Best.HTTP.Hosts.Settings.HostSettings"/> to apply.</param>
        </member>
        <member name="M:Best.HTTP.Hosts.Settings.HostSettingsManager.Add(System.String,Best.HTTP.Hosts.Settings.HostSettings)">
            <summary>
            Adds host-specific settings for the specified hostname.
            </summary>
            <param name="hostname">The hostname for which settings should be applied.</param>
            <param name="settings">The <see cref="T:Best.HTTP.Hosts.Settings.HostSettings"/> to apply.</param>
            <exception cref="T:System.ArgumentNullException">Thrown when either the hostname or settings is null.</exception>
            <exception cref="T:System.FormatException">Thrown when the hostname contains more than one asterisk ('*').</exception>
        </member>
        <member name="M:Best.HTTP.Hosts.Settings.HostSettingsManager.Get(Best.HTTP.HostSetting.HostVariant,System.Boolean)">
            <summary>
            Gets <see cref="T:Best.HTTP.Hosts.Settings.HostSettings"/> for the host part of the specified <see cref="T:Best.HTTP.HostSetting.HostVariant"/>. Returns the default settings associated with "*" when not found.
            </summary>
            <param name="variant">The <see cref="T:Best.HTTP.HostSetting.HostVariant"/> for which settings should be retrieved. Only the host part of the variant will be used.</param>
            <returns>The host settings for the specified host variant or the default settings for "*" if not found.</returns>
        </member>
        <member name="M:Best.HTTP.Hosts.Settings.HostSettingsManager.Get(Best.HTTP.HostSetting.HostKey,System.Boolean)">
            <summary>
            Gets <see cref="T:Best.HTTP.Hosts.Settings.HostSettings"/> for the host part of the specified <see cref="T:Best.HTTP.HostSetting.HostKey"/>. Returns the default settings associated with "*" when not found.
            </summary>
            <param name="hostKey">The <see cref="T:Best.HTTP.HostSetting.HostKey"/> for which settings should be retrieved. Only the host part of the host key will be used.</param>
            <returns>The host settings for the specified host key or the default settings for "*" if not found.</returns>
        </member>
        <member name="M:Best.HTTP.Hosts.Settings.HostSettingsManager.Get(System.Uri,System.Boolean)">
            <summary>
            Gets <see cref="T:Best.HTTP.Hosts.Settings.HostSettings"/> for the host part of the specified <see cref="T:System.Uri"/>. Returns the default settings associated with "*" when not found.
            </summary>
            <param name="uri">The <see cref="T:System.Uri"/> for which settings should be retrieved. Only the host part of the URI will be used.</param>
            <returns>The host settings for the specified URI or the default settings for "*" if not found.</returns>
        </member>
        <member name="M:Best.HTTP.Hosts.Settings.HostSettingsManager.Get(System.String,System.Boolean)">
            <summary>
            Gets <see cref="T:Best.HTTP.Hosts.Settings.HostSettings"/> for the host part of the specified hostname. Returns the default settings associated with "*" when not found.
            </summary>
            <param name="hostname">The hostname for which settings should be retrieved. Only the host part of the hostname will be used.</param>
            <returns>The host settings for the specified hostname or the default settings for "*" if not found.</returns>
            <exception cref="T:System.ArgumentNullException">Thrown when the hostname is null.</exception>
        </member>
        <member name="M:Best.HTTP.Hosts.Settings.HostSettingsManager.Clear">
            <summary>
            Clears all host-specific settings and resetting the default ("*") with default values.
            </summary>
        </member>
        <member name="T:Best.HTTP.HostSetting.HostKey">
            <summary>
            The <see cref="T:Best.HTTP.HostSetting.HostKey"/> struct represents a unique key for identifying hosts based on their <see cref="T:System.Uri"/> and <see cref="T:Best.HTTP.Request.Settings.ProxySettings"/>.
            </summary>
            <remarks>
            <para>
            The <see cref="T:Best.HTTP.HostSetting.HostKey"/> struct is designed to uniquely identify a host based on its URI (Uniform Resource Identifier) and optional proxy settings.
            It provides a way to create, compare, and hash host keys, enabling efficient host variant management in the <see cref="T:Best.HTTP.HostSetting.HostManager"/>.
            </para>
            <para>
            Key features of the <see cref="T:Best.HTTP.HostSetting.HostKey"/> struct include:
            </para>
            <list type="bullet">
                <item>
                    <term>Uniqueness</term>
                    <description>
                    Each <see cref="T:Best.HTTP.HostSetting.HostKey"/> is guaranteed to be unique for a specific host, considering both the URI and proxy settings.
                    </description>
                </item>
                <item>
                    <term>Hashing</term>
                    <description>
                    The struct provides a method to calculate a hash code for a <see cref="T:Best.HTTP.HostSetting.HostKey"/>, making it suitable for use as a dictionary key.
                    </description>
                </item>
                <item>
                    <term>Creation</term>
                    <description>
                    You can create a <see cref="T:Best.HTTP.HostSetting.HostKey"/> instance from a <see cref="T:System.Uri"/> and optional <see cref="T:Best.HTTP.Request.Settings.ProxySettings"/>.
                    </description>
                </item>
            </list>
            <para>
            Usage of the <see cref="T:Best.HTTP.HostSetting.HostKey"/> struct is typically handled internally by the BestHTTP library to manage unique hosts and optimize resource usage.
            Developers can use it when dealing with host-specific operations or customization of the library's behavior.
            </para>
            </remarks>
        </member>
        <member name="F:Best.HTTP.HostSetting.HostKey.Uri">
            <summary>
            Gets the URI (Uniform Resource Identifier) associated with the host.
            </summary>
        </member>
        <member name="F:Best.HTTP.HostSetting.HostKey.Proxy">
            <summary>
            Gets the proxy settings associated with the host.
            </summary>
        </member>
        <member name="F:Best.HTTP.HostSetting.HostKey.Key">
            <summary>
            Gets the unique hash key for the host.
            </summary>
        </member>
        <member name="P:Best.HTTP.HostSetting.HostKey.Host">
            <summary>
            Gets the host name from the URI or "file" if the URI is a file URI.
            </summary>
        </member>
        <member name="M:Best.HTTP.HostSetting.HostKey.#ctor(System.Uri,Best.HTTP.Request.Settings.ProxySettings)">
            <summary>
            Initializes a new instance of the <see cref="T:Best.HTTP.HostSetting.HostKey"/> struct with the specified URI and proxy settings.
            </summary>
            <param name="uri">The URI of the host.</param>
            <param name="proxy">The proxy settings associated with the host, or <c>null</c> if no proxy is used.</param>
        </member>
        <member name="M:Best.HTTP.HostSetting.HostKey.From(Best.HTTP.HTTPRequest)">
            <summary>
            Creates a <see cref="T:Best.HTTP.HostSetting.HostKey"/> instance from an HTTP request.
            </summary>
            <param name="request">The HTTP request from which to extract the current URI and proxy settings.</param>
            <returns>A <see cref="T:Best.HTTP.HostSetting.HostKey"/> representing the host of the HTTP request.</returns>
        </member>
        <member name="M:Best.HTTP.HostSetting.HostKey.From(System.Uri,Best.HTTP.Request.Settings.ProxySettings)">
            <summary>
            Creates a <see cref="T:Best.HTTP.HostSetting.HostKey"/> instance from a URI and proxy settings.
            </summary>
            <param name="uri">The URI of the host.</param>
            <param name="proxy">The proxy settings associated with the host, or <c>null</c> if no proxy is used.</param>
            <returns>A <see cref="T:Best.HTTP.HostSetting.HostKey"/> representing the host with the given URI and proxy settings.</returns>
        </member>
        <member name="T:Best.HTTP.HostSetting.HostManager">
            <summary>
            The <see cref="T:Best.HTTP.HostSetting.HostManager"/> class provides centralized management for <see cref="T:Best.HTTP.HostSetting.HostVariant"/> objects associated with HTTP requests and connections.
            </summary>
            <remarks>
            <para>
            The <see cref="T:Best.HTTP.HostSetting.HostManager"/> class acts as a central registry for managing <see cref="T:Best.HTTP.HostSetting.HostVariant"/> objects, each associated with a unique <see cref="T:Best.HTTP.HostSetting.HostKey"/>.
            It facilitates the creation, retrieval, and management of <see cref="T:Best.HTTP.HostSetting.HostVariant"/> instances based on HTTP requests and connections.
            </para>
            <para>
            A <see cref="T:Best.HTTP.HostSetting.HostVariant"/> represents a specific host and port combination (e.g., "http://example.com:80" or "https://example.com:443") and
            manages the connections and request queues for that host. The class ensures that a single <see cref="T:Best.HTTP.HostSetting.HostVariant"/> instance is used for
            each unique host, helping optimize resource usage and connection pooling.
            </para>
            <para>
            Key features of the <see cref="T:Best.HTTP.HostSetting.HostManager"/> class include:
            </para>
            <list type="bullet">
                <item>
                    <term>Creation and Retrieval</term>
                    <description>
                    The class allows you to create and retrieve <see cref="T:Best.HTTP.HostSetting.HostVariant"/> instances based on HTTP requests, connections, or <see cref="T:Best.HTTP.HostSetting.HostKey"/>.
                    It ensures that a single <see cref="T:Best.HTTP.HostSetting.HostVariant"/> is used for each unique host.
                    </description>
                </item>
                <item>
                    <term>Queue Management</term>
                    <description>
                    The <see cref="T:Best.HTTP.HostSetting.HostManager"/> manages the queue of pending requests for each <see cref="T:Best.HTTP.HostSetting.HostVariant"/>, ensuring efficient request processing.
                    </description>
                </item>
                <item>
                    <term>Connection Management</term>
                    <description>
                    The class handles the management of connections associated with <see cref="T:Best.HTTP.HostSetting.HostVariant"/> objects, including recycling idle connections,
                    removing idle connections, and shutting down connections when needed.
                    </description>
                </item>
            </list>
            <para>
            Usage of the <see cref="T:Best.HTTP.HostSetting.HostManager"/> class is typically transparent to developers and is handled internally by the Best HTTP library. However,
            it provides a convenient and efficient way to manage connections and requests when needed.
            </para>
            </remarks>
        </member>
        <member name="F:Best.HTTP.HostSetting.HostManager.hosts">
            <summary>
            Dictionary to store <see cref="T:Best.HTTP.HostSetting.HostKey"/>-<see cref="T:Best.HTTP.HostSetting.HostVariant"/> mappings.
            </summary>
        </member>
        <member name="M:Best.HTTP.HostSetting.HostManager.GetHostVariant(Best.HTTP.HTTPRequest)">
            <summary>
            Gets the <see cref="T:Best.HTTP.HostSetting.HostVariant"/> associated with an HTTP request.
            </summary>
            <param name="request">The HTTP request.</param>
            <returns>The <see cref="T:Best.HTTP.HostSetting.HostVariant"/> for the request's host.</returns>
        </member>
        <member name="M:Best.HTTP.HostSetting.HostManager.GetHostVariant(Best.HTTP.Hosts.Connections.ConnectionBase)">
            <summary>
            Gets the <see cref="T:Best.HTTP.HostSetting.HostVariant"/> associated with a connection.
            </summary>
            <param name="connection">The HTTP connection.</param>
            <returns>The <see cref="T:Best.HTTP.HostSetting.HostVariant"/> for the connection's host.</returns>
        </member>
        <member name="M:Best.HTTP.HostSetting.HostManager.GetHostVariant(Best.HTTP.HostSetting.HostKey)">
            <summary>
            Gets the <see cref="T:Best.HTTP.HostSetting.HostVariant"/> associated with a HostKey.
            </summary>
            <param name="key">The HostKey for which to get the HostVariant.</param>
            <returns>The <see cref="T:Best.HTTP.HostSetting.HostVariant"/> for the specified HostKey.</returns>
        </member>
        <member name="M:Best.HTTP.HostSetting.HostManager.RemoveAllIdleConnections">
            <summary>
            Removes all idle connections for all hosts.
            </summary>
        </member>
        <member name="M:Best.HTTP.HostSetting.HostManager.TryToSendQueuedRequests">
            <summary>
            Tries to send queued requests for all hosts.
            </summary>
        </member>
        <member name="M:Best.HTTP.HostSetting.HostManager.Shutdown">
            <summary>
            Shuts down all connections for all hosts.
            </summary>
        </member>
        <member name="M:Best.HTTP.HostSetting.HostManager.Clear">
            <summary>
            Clears all hosts and their associated variants.
            </summary>
        </member>
        <member name="T:Best.HTTP.HostSetting.HostProtocolSupport">
            <summary>
            An enumeration representing the protocol support for a host.
            </summary>
        </member>
        <member name="F:Best.HTTP.HostSetting.HostProtocolSupport.Unknown">
            <summary>
            Protocol support is unknown or undetermined.
            </summary>
        </member>
        <member name="F:Best.HTTP.HostSetting.HostProtocolSupport.HTTP1">
            <summary>
            The host supports HTTP/1.
            </summary>
        </member>
        <member name="F:Best.HTTP.HostSetting.HostProtocolSupport.HTTP2">
            <summary>
            The host supports HTTP/2.
            </summary>
        </member>
        <member name="F:Best.HTTP.HostSetting.HostProtocolSupport.File">
            <summary>
            This is a file-based host.
            </summary>
        </member>
        <member name="T:Best.HTTP.HostSetting.HostVariant">
            <summary>
            <para>The HostVariant class is a critical component in managing HTTP connections and handling HTTP requests for a specific host. It maintains a queue of requests and a list of active connections associated with the host, ensuring efficient utilization of available resources. Additionally, it supports protocol version detection (HTTP/1 or HTTP/2) for optimized communication with the host.</para>
            <list type="bullet">
                <item><description>It maintains a queue of requests to ensure efficient and controlled use of available connections.</description></item>
                <item><description>It supports HTTP/1 and HTTP/2 protocol versions, allowing requests to be sent using the appropriate protocol based on the host's protocol support.</description></item>
                <item><description>Provides methods for sending requests, recycling connections, managing connection state, and handling the shutdown of connections and the host variant itself.</description></item>
                <item><description>It includes logging for diagnostic purposes, helping to monitor and debug the behavior of connections and requests.</description></item>
            </list>
            <para>In summary, the HostVariant class plays a central role in managing HTTP connections and requests for a specific host, ensuring efficient and reliable communication with that host while supporting different protocol versions.</para>
            </summary>
        </member>
        <member name="T:Best.HTTP.HTTPMethods">
            <summary>
            Represents the HTTP methods used in HTTP requests.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPMethods.Get">
            <summary>
            The GET method means retrieve whatever information (in the form of an entity) is identified by the Request-URI.
            If the Request-URI refers to a data-producing process, it is the produced data which shall be returned as the
            entity in the response and not the source text of the process, unless that text happens to be the output of the process.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPMethods.Head">
            <summary>
            The HEAD method is identical to GET except that the server MUST NOT return a message-body in the response.
            The metainformation contained in the HTTP headers in response to a HEAD request SHOULD be identical to the information sent in response to a GET request.
            This method can be used for obtaining metainformation about the entity implied by the request without transferring the entity-body itself.
            This method is often used for testing hypertext links for validity, accessibility, and recent modification.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPMethods.Post">
            <summary>
            The POST method is used to request that the origin server accept the entity enclosed in the request as a new subordinate of the resource identified by the Request-URI in the Request-Line.
            POST is designed to allow a uniform method to cover the following functions:
            <list type="bullet">
                <item><description>Annotation of existing resources;</description></item>
                <item><description>Posting a message to a bulletin board, newsgroup, mailing list, or similar group of articles;</description></item>
                <item><description>Providing a block of data, such as the result of submitting a form, to a data-handling process;</description></item>
                <item><description>Extending a database through an append operation.</description></item>
            </list>
            The actual function performed by the POST method is determined by the server and is usually dependent on the Request-URI.
            The posted entity is subordinate to that URI in the same way that a file is subordinate to a directory containing it,
            a news article is subordinate to a newsgroup to which it is posted, or a record is subordinate to a database.
            The action performed by the POST method might not result in a resource that can be identified by a URI. In this case,
            either 200 (OK) or 204 (No Content) is the appropriate response status, depending on whether or not the response includes an entity that describes the result.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPMethods.Put">
            <summary>
            The PUT method requests that the enclosed entity be stored under the supplied Request-URI.
            If the Request-URI refers to an already existing resource, the enclosed entity SHOULD be considered as a modified version of the one residing on the origin server.
            If the Request-URI does not point to an existing resource, and that URI is capable of being defined as a new resource by the requesting user agent,
            the origin server can create the resource with that URI. If a new resource is created, the origin server MUST inform the user agent via the 201 (Created) response.
            If an existing resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to indicate successful completion of the request.
            If the resource could not be created or modified with the Request-URI, an appropriate error response SHOULD be given that reflects the nature of the problem.
            The recipient of the entity MUST NOT ignore any Content-* (e.g. Content-Range) headers that it does not understand or implement and MUST return a 501 (Not Implemented) response in such cases.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPMethods.Delete">
            <summary>
            The DELETE method requests that the origin server delete the resource identified by the Request-URI. This method MAY be overridden by human intervention (or other means) on the origin server.
            The client cannot be guaranteed that the operation has been carried out, even if the status code returned from the origin server indicates that the action has been completed successfully.
            However, the server SHOULD NOT indicate success unless, at the time the response is given, it intends to delete the resource or move it to an inaccessible location.
            A successful response SHOULD be 200 (OK) if the response includes an entity describing the status, 202 (Accepted) if the action has not yet been enacted, or 204 (No Content)
            if the action has been enacted but the response does not include an entity.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPMethods.Patch">
            <summary>
            The PATCH method requests that a set of changes described in the request entity be applied to the resource identified by the Request-URI.
            The set of changes is represented in a format called a "patchdocument" identified by a media type. If the Request-URI does not point to an existing resource,
            the server MAY create a new resource, depending on the patch document type (whether it can logically modify a null resource) and permissions, etc.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="http://tools.ietf.org/html/rfc5789">RFC-5789</see></description></item>
                <item><description><see href="http://restcookbook.com/HTTP%20Methods/patch/">When should we use the PATCH HTTP method?</see></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.HTTPMethods.Trace">
            <summary>
            The HTTP TRACE method is used to perform a message loop-back test along the path to the target resource.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPMethods.Merge">
            <summary>
            The HTTP MERGE method is used to apply modifications to an existing resource.
            The MERGE HTTP method is not as commonly used as other methods like GET, POST, or PUT.
            It's often used in specific WebDAV (Web Distributed Authoring and Versioning) scenarios.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPMethods.Options">
            <summary>
            The HTTP OPTIONS method requests permitted communication options for a given URL or server.
            A client can specify a URL with this method, or an asterisk (*) to refer to the entire server.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/OPTIONS">Mozilla Developer Networks - OPTIONS</see></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.HTTPMethods.Connect">
            <summary>
            The CONNECT method is primarily used in the context of HTTP proxies to establish a network connection through the proxy to a target host.
            It is used in the context of the HTTP CONNECT tunneling method.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://datatracker.ietf.org/doc/html/rfc2616#section-9.9">RFC-2616</see></description></item>
                <item><description><see href="https://tools.ietf.org/html/rfc8441">RFC-8441</see></description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.HTTPMethods.Query">
            <summary>
            The HTTP QUERY method is used to retrieve data based on a query parameter or search criteria.
            The QUERY method is not a standard HTTP method, and its usage may vary depending on the specific application or API you are working with.
            It might be used for querying data or resources with specific parameters.
            Details about the QUERY method would depend on the API or service you are interacting with.
            You should refer to the documentation or specifications provided by the API/service provider.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://horovits.medium.com/http-s-new-method-for-data-apis-http-query-1ff71e6f73f3">HTTP's New Method For Data APIs: HTTP QUERY</see></description></item>
                <item><description><see href="https://datatracker.ietf.org/doc/draft-ietf-httpbis-safe-method-w-body/">The HTTP QUERY Method (Draft)</see></description></item>
            </list>
            </remarks>
        </member>
        <member name="T:Best.HTTP.HTTPRange">
            <summary>
            Represents an HTTP range that specifies the byte range of a response content, received as an answer for a range-request.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRange.FirstBytePos">
            <summary>
            Gets the position of the first byte in the range that the server sent.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRange.LastBytePos">
            <summary>
            Gets the position of the last byte in the range that the server sent.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRange.ContentLength">
            <summary>
            Gets the total length of the full entity-body on the server. Returns -1 if this length is unknown or difficult to determine.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRange.IsValid">
            <summary>
            Gets a value indicating whether the HTTP range is valid.
            </summary>
        </member>
        <member name="T:Best.HTTP.OnRequestFinishedDelegate">
            <summary>
            Delegate for a callback function that is called after the request is fully processed.
            </summary>
        </member>
        <member name="T:Best.HTTP.OnHeaderEnumerationDelegate">
            <summary>
            Delegate for enumerating headers during request preparation.
            </summary>
            <param name="header">The header name.</param>
            <param name="values">A list of header values.</param>
        </member>
        <member name="T:Best.HTTP.HTTPRequest">
            <summary>
            Represents an HTTP request that allows you to send HTTP requests to remote servers and receive responses asynchronously.
            </summary>
            <remarks>
            <list type="bullet">
                <item><term>Asynchronous HTTP requests</term><description>Utilize a Task-based API for performing HTTP requests asynchronously.</description></item>
                <item><term>Unity coroutine support</term><description>Seamlessly integrate with Unity's coroutine system for coroutine-based request handling.</description></item>
                <item><term>HTTP method support</term><description>Support for various HTTP methods including GET, POST, PUT, DELETE, and more.</description></item>
                <item><term>Compression and decompression</term><description>Automatic request and response compression and decompression for efficient data transfer.</description></item>
                <item><term>Timing information</term><description>Collect detailed timing information about the request for performance analysis.</description></item>
                <item><term>Upload and download support</term><description>Support for uploading and downloading files with progress tracking.</description></item>
                <item><term>Customizable</term><description>Extensive options for customizing request headers, handling cookies, and more.</description></item>
                <item><term>Redirection handling</term><description>Automatic handling of request redirections for a seamless experience.</description></item>
                <item><term>Proxy server support</term><description>Ability to route requests through proxy servers for enhanced privacy and security.</description></item>
                <item><term>Authentication</term><description>Automatic authentication handling using authenticators for secure communication.</description></item>
                <item><term>Cancellation support</term><description>Ability to cancel requests to prevent further processing and release resources.</description></item>
            </list>
            </remarks>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreateGet(System.String)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Get">HTTP GET</see> request with the specified URL.
            </summary>
            <param name="url">The URL of the request.</param>
            <returns>An HTTPRequest instance for the GET request.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreateGet(System.Uri)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Get">HTTP GET</see> request with the specified URI.
            </summary>
            <param name="uri">The URI of the request.</param>
            <returns>An HTTPRequest instance for the GET request.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreateGet(System.String,Best.HTTP.OnRequestFinishedDelegate)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Get">HTTP GET</see> request with the specified URL and registers a callback function to be called
            when the request is fully processed.
            </summary>
            <param name="url">The URL of the request.</param>
            <param name="callback">A callback function to be called when the request is finished.</param>
            <returns>An HTTPRequest instance for the GET request.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreateGet(System.Uri,Best.HTTP.OnRequestFinishedDelegate)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Get">HTTP GET</see> request with the specified URI and registers a callback function to be called
            when the request is fully processed.
            </summary>
            <param name="uri">The URI of the request.</param>
            <param name="callback">A callback function to be called when the request is finished.</param>
            <returns>An HTTPRequest instance for the GET request.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreatePost(System.String)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Post">HTTP POST</see> request with the specified URL.
            </summary>
            <param name="url">The URL of the request.</param>
            <returns>An HTTPRequest instance for the POST request.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreatePost(System.Uri)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Post">HTTP POST</see> request with the specified URI.
            </summary>
            <param name="uri">The URI of the request.</param>
            <returns>An HTTPRequest instance for the POST request.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreatePost(System.String,Best.HTTP.OnRequestFinishedDelegate)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Post">HTTP POST</see> request with the specified URL and registers a callback function to be called
            when the request is fully processed.
            </summary>
            <param name="url">The URL of the request.</param>
            <param name="callback">A callback function to be called when the request is finished.</param>
            <returns>An HTTPRequest instance for the POST request.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreatePost(System.Uri,Best.HTTP.OnRequestFinishedDelegate)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Post">HTTP POST</see> request with the specified URI and registers a callback function to be called
            when the request is fully processed.
            </summary>
            <param name="uri">The URI of the request.</param>
            <param name="callback">A callback function to be called when the request is finished.</param>
            <returns>An HTTPRequest instance for the POST request.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreatePut(System.String)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Put">HTTP PUT</see> request with the specified URL.
            </summary>
            <param name="url">The URL of the request.</param>
            <returns>An HTTPRequest instance for the PUT request.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreatePut(System.Uri)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Put">HTTP PUT</see> request with the specified URI.
            </summary>
            <param name="uri">The URI of the request.</param>
            <returns>An HTTPRequest instance for the PUT request.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreatePut(System.String,Best.HTTP.OnRequestFinishedDelegate)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Put">HTTP PUT</see> request with the specified URL and registers a callback function to be called
            when the request is fully processed.
            </summary>
            <param name="url">The URL of the request.</param>
            <param name="callback">A callback function to be called when the request is finished.</param>
            <returns>An HTTPRequest instance for the PUT request.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.CreatePut(System.Uri,Best.HTTP.OnRequestFinishedDelegate)">
            <summary>
            Creates an <see cref="F:Best.HTTP.HTTPMethods.Put">HTTP PUT</see> request with the specified URI and registers a callback function to be called
            when the request is fully processed.
            </summary>
            <param name="uri">The URI of the request.</param>
            <param name="callback">A callback function to be called when the request is finished.</param>
            <returns>An HTTPRequest instance for the PUT request.</returns>
        </member>
        <member name="F:Best.HTTP.HTTPRequest.MethodNames">
            <summary>
            Cached uppercase values to save some cpu cycles and GC alloc per request.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.MethodType">
            <summary>
            The method that how we want to process our request the server.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.Uri">
            <summary>
            The original request's Uri.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.CurrentUri">
            <summary>
            If redirected it contains the RedirectUri.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.CurrentHostKey">
            <summary>
            A host-key that can be used to find the right host-variant for the request.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.Response">
            <summary>
            The response received from the server.
            </summary>
            <remarks>If an exception occurred during reading of the response stream or can't connect to the server, this will be null!</remarks>
        </member>
        <member name="F:Best.HTTP.HTTPRequest.DownloadSettings">
            <summary>
            Download related options and settings.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequest.UploadSettings">
            <summary>
            Upload related options and settings.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequest.TimeoutSettings">
            <summary>
            Timeout settings for the request.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequest.RetrySettings">
            <summary>
            Retry settings for the request.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequest.ProxySettings">
            <summary>
            Proxy settings for the request.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.RedirectSettings">
            <summary>
            Redirect settings for the request.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.Callback">
            <summary>
            The callback function that will be called after the request is fully processed.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.IsCancellationRequested">
            <summary>
            Indicates if <see cref="M:Best.HTTP.HTTPRequest.Abort"/> is called on this request.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.CancellationTokenSource">
            <summary>
            Gets the cancellation token source for this request.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequest.OnCancellationRequested">
            <summary>
            Action called when <see cref="M:Best.HTTP.HTTPRequest.Abort"/> function is invoked.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.Exception">
            <summary>
            Stores any exception that occurs during processing of the request or response.
            </summary>
            <remarks>This property if for debugging purposes as <see href="https://github.com/Benedicht/BestHTTP-Issues/issues/174">seen here</see>!</remarks>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.Tag">
            <summary>
            Any user-object that can be passed with the request.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.State">
            <summary>
            Current state of this request.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.Timing">
            <summary>
            Timing information about the request.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequest.Authenticator">
            <summary>
            An IAuthenticator implementation that can be used to authenticate the request.
            </summary>
            <remarks>Out-of-the-box included authenticators are <see cref="T:Best.HTTP.Request.Authenticators.CredentialAuthenticator"/> and <see cref="T:Best.HTTP.Request.Authenticators.BearerTokenAuthenticator"/>.</remarks>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.WithCredentials">
            <summary>
            Its value will be set to the XmlHTTPRequest's withCredentials field, required to send 3rd party cookies with the request.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials">Mozilla Developer Networks - XMLHttpRequest.withCredentials</see></description></item>
            </list>
            </remarks>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.Context">
            <summary>
            Logging context of the request.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.#ctor(System.String)">
            <summary>
            Creates an HTTP GET request with the specified URL.
            </summary>
            <param name="url">The URL of the request.</param>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.#ctor(System.String,Best.HTTP.OnRequestFinishedDelegate)">
            <summary>
            Creates an HTTP GET request with the specified URL and registers a callback function to be called
            when the request is fully processed.
            </summary>
            <param name="url">The URL of the request.</param>
            <param name="callback">A callback function to be called when the request is finished.</param>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.#ctor(System.String,Best.HTTP.HTTPMethods)">
            <summary>
            Creates an HTTP GET request with the specified URL and HTTP method type.
            </summary>
            <param name="url">The URL of the request.</param>
            <param name="methodType">The HTTP method type for the request (e.g., GET, POST, PUT).</param>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.#ctor(System.String,Best.HTTP.HTTPMethods,Best.HTTP.OnRequestFinishedDelegate)">
            <summary>
            Creates an HTTP request with the specified URL, HTTP method type, and registers a callback function to be called
            when the request is fully processed.
            </summary>
            <param name="url">The URL of the request.</param>
            <param name="methodType">The HTTP method type for the request (e.g., GET, POST, PUT).</param>
            <param name="callback">A callback function to be called when the request is finished.</param>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.#ctor(System.Uri)">
            <summary>
            Creates an HTTP GET request with the specified URI.
            </summary>
            <param name="uri">The URI of the request.</param>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.#ctor(System.Uri,Best.HTTP.OnRequestFinishedDelegate)">
            <summary>
            Creates an HTTP GET request with the specified URI and registers a callback function to be called
            when the request is fully processed.
            </summary>
            <param name="uri">The URI of the request.</param>
            <param name="callback">A callback function to be called when the request is finished.</param>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.#ctor(System.Uri,Best.HTTP.HTTPMethods)">
            <summary>
            Creates an HTTP request with the specified URI and HTTP method type.
            </summary>
            <param name="uri">The URI of the request.</param>
            <param name="methodType">The HTTP method type for the request (e.g., GET, POST, PUT).</param>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.#ctor(System.Uri,Best.HTTP.HTTPMethods,Best.HTTP.OnRequestFinishedDelegate)">
            <summary>
            Creates an HTTP request with the specified URI, HTTP method type, and registers a callback function
            to be called when the request is fully processed.
            </summary>
            <param name="uri">The URI of the request.</param>
            <param name="methodType">The HTTP method type for the request (e.g., GET, POST, PUT).</param>
            <param name="callback">A callback function to be called when the request is finished.</param>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.AddHeader(System.String,System.String)">
            <summary>
            Adds a header-value pair to the Headers. Use it to add custom headers to the request.
            </summary>
            <example>AddHeader("User-Agent', "FooBar 1.0")</example>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.SetHeader(System.String,System.String)">
            <summary>
            For the given header name, removes any previously added values and sets the given one.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.RemoveHeader(System.String)">
            <summary>
            Removes the specified header and all of its associated values. Returns <c>true</c>, if the header found and succesfully removed.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.HasHeader(System.String)">
            <summary>
            Returns <c>true</c> if the given head name is already in the <see cref="P:Best.HTTP.HTTPRequest.Headers"/>.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.GetFirstHeaderValue(System.String)">
            <summary>
            Returns the first header or <c>null</c> for the given header name.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.GetHeaderValues(System.String)">
            <summary>
            Returns all header values for the given header or <c>null</c>.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.RemoveHeaders">
            <summary>
            Removes all headers.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.SetRangeHeader(System.Int64)">
            <summary>
            Sets the Range header to download the content from the given byte position. See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
            </summary>
            <param name="firstBytePos">Start position of the download.</param>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.SetRangeHeader(System.Int64,System.Int64)">
            <summary>
            Sets the Range header to download the content from the given byte position to the given last position. See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
            </summary>
            <param name="firstBytePos">Start position of the download.</param>
            <param name="lastBytePos">The end position of the download.</param>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.Send">
            <summary>
            Starts processing the request.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.Abort">
            <summary>
            Cancels any further processing of the HTTP request.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.Clear">
            <summary>
            Resets the request for a state where switching MethodType is possible.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPRequest.Current">
            <summary>
            <see cref="P:System.Collections.IEnumerator.Current"/> implementation, required for <see cref="T:UnityEngine.Coroutine"/> support.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.MoveNext">
            <summary>
            <see cref="M:System.Collections.IEnumerator.MoveNext"/> implementation, required for <see cref="T:UnityEngine.Coroutine"/> support.
            </summary>
            <returns><c>true</c> if the request isn't finished yet.</returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.Reset">
            <summary>
            <see cref="M:System.Collections.IEnumerator.MoveNext"/> implementation throwing <see cref="T:System.NotImplementedException"/>, required for <see cref="T:UnityEngine.Coroutine"/> support.
            </summary>
            <exception cref="T:System.NotImplementedException"></exception>
        </member>
        <member name="M:Best.HTTP.HTTPRequest.Dispose">
            <summary>
            Disposes of resources used by the HTTPRequest instance.
            </summary>
        </member>
        <member name="T:Best.HTTP.AsyncHTTPException">
            <summary>
            Represents an exception thrown during or as a result of a Task-based asynchronous HTTP operations.
            </summary>
        </member>
        <member name="F:Best.HTTP.AsyncHTTPException.StatusCode">
            <summary>
            Gets the status code of the server's response.
            </summary>
        </member>
        <member name="F:Best.HTTP.AsyncHTTPException.Content">
            <summary>
            Gets the content sent by the server. This is usually an error page for 4xx or 5xx responses.
            </summary>
        </member>
        <member name="T:Best.HTTP.HTTPRequestAsyncExtensions">
            <summary>
            A collection of extension methods for working with HTTP requests asynchronously using <see cref="T:System.Threading.Tasks.Task`1"/>.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPRequestAsyncExtensions.GetAssetBundleAsync(Best.HTTP.HTTPRequest,System.Threading.CancellationToken)">
            <summary>
            Asynchronously sends an HTTP request and retrieves the response as an <see cref="T:UnityEngine.AssetBundle"/>.
            </summary>
            <param name="request">The <see cref="T:Best.HTTP.HTTPRequest"/> to send.</param>
            <param name="token">A cancellation token that can be used to cancel the operation.</param>
            <returns>
            A Task that represents the asynchronous operation. The Task will complete with the retrieved AssetBundle
            if the request succeeds. If the request fails or is canceled, the Task will complete with an exception.
            </returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequestAsyncExtensions.GetHTTPResponseAsync(Best.HTTP.HTTPRequest,System.Threading.CancellationToken)">
            <summary>
            Asynchronously sends an HTTP request and retrieves the raw <see cref="T:Best.HTTP.HTTPResponse"/>.
            </summary>
            <remarks>
            This method is particularly useful when you want to access the raw response without any specific processing 
            like converting the data into a string, texture, or other formats. It provides flexibility in handling 
            the response for custom or advanced use cases.
            </remarks>
            <param name="request">The <see cref="T:Best.HTTP.HTTPRequest"/> to send.</param>
            <param name="token">An optional <see cref="T:System.Threading.CancellationToken"/> that can be used to cancel the operation.</param>
            <returns>
            A <see cref="T:System.Threading.Tasks.Task`1"/> that represents the asynchronous operation. The value of TResult is the raw <see cref="T:Best.HTTP.HTTPResponse"/>.
            If the request completes successfully, the task will return the HTTPResponse. If there's an error during the request or if 
            the request gets canceled, the task will throw an exception, which can be caught and processed by the calling method.
            </returns>
            <exception cref="T:Best.HTTP.AsyncHTTPException">Thrown if there's an error in the request or if the server returns an error status code.</exception>
        </member>
        <member name="M:Best.HTTP.HTTPRequestAsyncExtensions.GetAsStringAsync(Best.HTTP.HTTPRequest,System.Threading.CancellationToken)">
            <summary>
            Asynchronously sends an <see cref="T:Best.HTTP.HTTPRequest"/> and retrieves the response content as a <c>string</c>.
            </summary>
            <param name="request">The <see cref="T:Best.HTTP.HTTPRequest"/> to send.</param>
            <param name="token">A cancellation token that can be used to cancel the operation.</param>
            <returns>
            A Task that represents the asynchronous operation. The Task will complete with the retrieved <c>string</c> content
            if the request succeeds. If the request fails or is canceled, the Task will complete with an exception.
            </returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequestAsyncExtensions.GetAsTexture2DAsync(Best.HTTP.HTTPRequest,System.Threading.CancellationToken)">
            <summary>
            Asynchronously sends an <see cref="T:Best.HTTP.HTTPRequest"/> and retrieves the response content as a <see cref="T:UnityEngine.Texture2D"/>.
            </summary>
            <param name="request">The <see cref="T:Best.HTTP.HTTPRequest"/> to send.</param>
            <param name="token">A cancellation token that can be used to cancel the operation.</param>
            <returns>
            A Task that represents the asynchronous operation. The Task will complete with the retrieved <see cref="T:UnityEngine.Texture2D"/>
            if the request succeeds. If the request fails or is canceled, the Task will complete with an exception.
            </returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequestAsyncExtensions.GetRawDataAsync(Best.HTTP.HTTPRequest,System.Threading.CancellationToken)">
            <summary>
            Asynchronously sends an <see cref="T:Best.HTTP.HTTPRequest"/> and retrieves the response content as a <c>byte[]</c>.
            </summary>
            <param name="request">The <see cref="T:Best.HTTP.HTTPRequest"/> to send.</param>
            <param name="token">A cancellation token that can be used to cancel the operation.</param>
            <returns>
            A Task that represents the asynchronous operation. The Task will complete with the retrieved <c>byte[]</c>
            if the request succeeds. If the request fails or is canceled, the Task will complete with an exception.
            </returns>
        </member>
        <member name="M:Best.HTTP.HTTPRequestAsyncExtensions.GetFromJsonResultAsync``1(Best.HTTP.HTTPRequest,System.Threading.CancellationToken)">
            <summary>
            Asynchronously sends an <see cref="T:Best.HTTP.HTTPRequest"/> and deserializes the response content into an object of type T using JSON deserialization.
            </summary>
            <typeparam name="T">The type to deserialize the JSON content into.</typeparam>
            <param name="request">The <see cref="T:Best.HTTP.HTTPRequest"/> to send.</param>
            <param name="token">A cancellation token that can be used to cancel the operation.</param>
            <returns>
            A Task that represents the asynchronous operation. The Task will complete with the deserialized object
            if the request succeeds and the response content can be deserialized. If the request fails, is canceled, or
            the response cannot be deserialized, the Task will complete with an exception.
            </returns>
        </member>
        <member name="T:Best.HTTP.HTTPRequestStates">
            <summary>
            Possible logical states of a HTTTPRequest object.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequestStates.Initial">
            <summary>
            Initial status of a request. No callback will be called with this status.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequestStates.Queued">
            <summary>
            The request queued for processing.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequestStates.Processing">
            <summary>
            Processing of the request started. In this state the client will send the request, and parse the response. No callback will be called with this status.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequestStates.Finished">
            <summary>
            The request finished without problem. Parsing the response done, the result can be used. The user defined callback will be called with a valid response object. The request’s Exception property will be null.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequestStates.Error">
            <summary>
            The request finished with an unexpected error. The user defined callback will be called with a null response object. The request's Exception property may contain more info about the error, but it can be null.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequestStates.Aborted">
            <summary>
            The request aborted by the client(HTTPRequest’s Abort() function). The user defined callback will be called with a null response. The request’s Exception property will be null.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequestStates.ConnectionTimedOut">
            <summary>
            Connecting to the server timed out. The user defined callback will be called with a null response. The request’s Exception property will be null.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPRequestStates.TimedOut">
            <summary>
            The request didn't finished in the given time. The user defined callback will be called with a null response. The request’s Exception property will be null.
            </summary>
        </member>
        <member name="T:Best.HTTP.Proxies.ProxyConnectParameters">
            <summary>
            Represents parameters used when connecting through a proxy server.
            </summary>
            <remarks>
            The ProxyConnectParameters struct defines the parameters required when initiating a connection
            through a proxy server. It includes information about the proxy, target URI, and callbacks for success and error handling.
            This struct is commonly used during the negotiation steps in the <see cref="!:Best.HTTP.Shared.PlatformSupport.Network.Tcp.Negotiator"/> class.
            </remarks>
        </member>
        <member name="F:Best.HTTP.Proxies.ProxyConnectParameters.MaxAuthenticationAttempts">
            <summary>
            The maximum number of authentication attempts allowed during proxy connection.
            </summary>
        </member>
        <member name="F:Best.HTTP.Proxies.ProxyConnectParameters.proxy">
            <summary>
            The proxy server through which the connection is established.
            </summary>
        </member>
        <member name="F:Best.HTTP.Proxies.ProxyConnectParameters.stream">
            <summary>
            The stream used for communication with the proxy server.
            </summary>
        </member>
        <member name="F:Best.HTTP.Proxies.ProxyConnectParameters.uri">
            <summary>
            The target URI to reach through the proxy server.
            </summary>
        </member>
        <member name="F:Best.HTTP.Proxies.ProxyConnectParameters.token">
            <summary>
            A cancellation token that allows canceling the proxy connection operation.
            </summary>
        </member>
        <member name="F:Best.HTTP.Proxies.ProxyConnectParameters.AuthenticationAttempts">
            <summary>
            The number of authentication attempts made during proxy connection.
            </summary>
        </member>
        <member name="F:Best.HTTP.Proxies.ProxyConnectParameters.createTunel">
            <summary>
            Gets or sets a value indicating whether to create a proxy tunnel.
            </summary>
            <remarks>
            A proxy tunnel, also known as a TCP tunnel, is established when communication between the client and the target server
            needs to be relayed through the proxy without modification. Setting this field to <c>true</c> indicates the intention
            to create a tunnel, allowing the data to pass through the proxy without interpretation or alteration by the proxy.
            This is typically used for protocols like HTTPS, where end-to-end encryption is desired, and the proxy should act as a
            pass-through conduit.
            </remarks>
        </member>
        <member name="F:Best.HTTP.Proxies.ProxyConnectParameters.context">
            <summary>
            The logging context for debugging purposes.
            </summary>
        </member>
        <member name="F:Best.HTTP.Proxies.ProxyConnectParameters.OnSuccess">
            <summary>
            A callback to be executed upon successful proxy connection.
            </summary>
        </member>
        <member name="F:Best.HTTP.Proxies.ProxyConnectParameters.OnError">
            <summary>
            A callback to be executed upon encountering an error during proxy connection.
            </summary>
            <remarks>
            The callback includes parameters for the current connection parameters, the encountered exception,
            and a flag indicating whether the connection should be retried for authentication.
            </remarks>
        </member>
        <member name="T:Best.HTTP.Proxies.Proxy">
            <summary>
            Base class for proxy implementations, providing common proxy configuration and behavior.
            </summary>
            <remarks>
            The Proxy class serves as the base class for various proxy client implementations,
            such as <see cref="!:HTTPProxy"/> and <see cref="!:SOCKSProxy"/>. It provides a foundation for configuring proxy settings and handling
            proxy-related functionality common to all proxy types, like connecting to a proxy, setting up a request to go through the proxy
            and deciding whether an address is usable with the proxy or the plugin must connect directly.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Proxies.Proxy.Address">
            <summary>
            Address of the proxy server. It has to be in the http://proxyaddress:port form.
            </summary>
        </member>
        <member name="P:Best.HTTP.Proxies.Proxy.Credentials">
            <summary>
            Credentials for authenticating with the proxy server.
            </summary>
        </member>
        <member name="P:Best.HTTP.Proxies.Proxy.Exceptions">
            <summary>
            List of exceptions for which the proxy should not be used. Elements of this list are compared to the Host (DNS or IP address) part of the uri.
            </summary>
        </member>
        <member name="M:Best.HTTP.Proxies.Proxy.#ctor(System.Uri,Best.HTTP.Request.Authentication.Credentials)">
            <summary>
            Initializes a new instance of the Proxy class with the specified proxy address and credentials.
            </summary>
            <param name="address">The address of the proxy server.</param>
            <param name="credentials">The credentials for proxy authentication.</param>
        </member>
        <member name="M:Best.HTTP.Proxies.Proxy.BeginConnect(Best.HTTP.Proxies.ProxyConnectParameters)">
            <summary>
            Initiates a connection through the proxy server. Used during the negotiation steps.
            </summary>
            <param name="parameters">Parameters for the proxy connection.</param>
        </member>
        <member name="M:Best.HTTP.Proxies.Proxy.GetRequestPath(System.Uri)">
            <summary>
            Gets the request path to be used for proxy communication. In some cases with HTTPProxy, the request must send the whole uri as the request path.
            </summary>
            <param name="uri">The target URI.</param>
            <returns>The request path for proxy communication.</returns>
        </member>
        <member name="M:Best.HTTP.Proxies.Proxy.SetupRequest(Best.HTTP.HTTPRequest)">
            <summary>
            Sets up an HTTP request to use the proxy as needed.
            </summary>
            <param name="request">The HTTP request to set up.</param>
            <returns><c>true</c> if the request should use the proxy; otherwise, <c>false</c>.</returns>
        </member>
        <member name="M:Best.HTTP.Proxies.Proxy.UseProxyForAddress(System.Uri)">
            <summary>
            Determines whether the proxy should be used for a specific address based on the configured exceptions.
            </summary>
            <param name="address">The address to check for proxy usage.</param>
            <returns><c>true</c> if the proxy should be used for the address; otherwise, <c>false</c>.</returns>
        </member>
        <member name="T:Best.HTTP.Request.Authentication.AuthenticationTypes">
            <summary>
            Authentication types that supported by Best.HTTP.
            The authentication is defined by the server, so the Basic and Digest are not interchangeable. If you don't know what to use, the preferred way is to choose Unknow.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Authentication.AuthenticationTypes.Unknown">
            <summary>
            If the authentication type is not known this will do a challenge turn to receive what methode should be choosen.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Authentication.AuthenticationTypes.Basic">
            <summary>
            The most basic authentication type. It's easy to do, and easy to crack, don't use it with plain http://
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Authentication.AuthenticationTypes.Digest">
            <summary>
            HTTP Digest authentication
            </summary>
        </member>
        <member name="T:Best.HTTP.Request.Authentication.Credentials">
            <summary>
            Hold all information that required to authenticate to a remote server.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Credentials.Type">
            <summary>
            The type of the Authentication. If you don't know what to use, the preferred way is to choose Unknow.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Credentials.UserName">
            <summary>
            The username to authenticate on the remote server.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Credentials.Password">
            <summary>
            The password to use in the authentication process. The password will be stored only in this class.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Authentication.Credentials.#ctor(System.String,System.String)">
            <summary>
            Set up the authentication credentials with the username and password. The Type will be set to Unknown.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Authentication.Credentials.#ctor(Best.HTTP.Request.Authentication.AuthenticationTypes,System.String,System.String)">
            <summary>
            Set up the authentication credentials with the given authentication type, username and password.
            </summary>
        </member>
        <member name="T:Best.HTTP.Request.Authentication.Digest">
            <summary>
            Internal class that stores all information that received from a server in a WWW-Authenticate and need to construct a valid Authorization header. Based on rfc 2617 (http://tools.ietf.org/html/rfc2617).
            Used only internally by the plugin.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Digest.Uri">
            <summary>
            The Uri that this Digest is bound to.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Digest.Realm">
            <summary>
            A string to be displayed to users so they know which username and password to use.
            This string should contain at least the name of the host performing the authentication and might additionally indicate the collection of users who might have access.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Digest.Stale">
            <summary>
            A flag, indicating that the previous request from the client was rejected because the nonce value was stale.
            If stale is TRUE (case-insensitive), the client may wish to simply retry the request with a new encrypted response, without  the user for a new username and password.
            The server should only set stale to TRUE if it receives a request for which the nonce is invalid but with a valid digest for that nonce
            (indicating that the client knows the correct username/password).
            If stale is FALSE, or anything other than TRUE, or the stale directive is not present, the username and/or password are invalid, and new values must be obtained.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Digest.Nonce">
            <summary>
            A server-specified data string which should be uniquely generated each time a 401 response is made.
            Specifically, since the string is passed in the header lines as a quoted string, the double-quote character is not allowed.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Digest.Opaque">
            <summary>
            A string of data, specified by the server, which should be returned by the client unchanged in the Authorization header of subsequent requests with URIs in the same protection space.
            It is recommended that this string be base64 or data.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Digest.Algorithm">
            <summary>
            A string indicating a pair of algorithms used to produce the digest and a checksum. If this is not present it is assumed to be "MD5".
            If the algorithm is not understood, the challenge should be ignored (and a different one used, if there is more than one).
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Digest.ProtectedUris">
            <summary>
            List of URIs, as specified in RFC XURI, that define the protection space.
            If a URI is an abs_path, it is relative to the canonical root URL (see section 1.2 above) of the server being accessed.
            An absoluteURI in this list may refer to a different server than the one being accessed.
            The client can use this list to determine the set of URIs for which the same authentication information may be sent:
            any URI that has a URI in this list as a prefix (after both have been made absolute) may be assumed to be in the same protection space.
            If this directive is omitted or its value is empty, the client should assume that the protection space consists of all URIs on the responding server.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Digest.QualityOfProtections">
            <summary>
            If present, it is a quoted string of one or more tokens indicating the "quality of protection" values supported by the server.
            The value "auth" indicates authentication. The value "auth-int" indicates authentication with integrity protection.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Digest.NonceCount">
            <summary>
            his MUST be specified if a qop directive is sent (see above), and MUST NOT be specified if the server did not send a qop directive in the WWW-Authenticate header field.
            The nc-value is the hexadecimal count of the number of requests (including the current request) that the client has sent with the nonce value in this request.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authentication.Digest.HA1Sess">
            <summary>
            Used to store the last HA1 that can be used in the next header generation when Algorithm is set to "md5-sess".
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Authentication.Digest.ParseChallange(System.String)">
            <summary>
            Parses a WWW-Authenticate header's value to retrive all information.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Authentication.Digest.GenerateResponseHeader(Best.HTTP.Request.Authentication.Credentials,System.Boolean,Best.HTTP.HTTPMethods,System.Uri)">
            <summary>
            Generates a string that can be set to an Authorization header.
            </summary>
        </member>
        <member name="T:Best.HTTP.Request.Authentication.DigestStore">
            <summary>
            Stores and manages already received digest infos.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Authentication.DigestStore.SupportedAlgorithms">
            <summary>
            Array of algorithms that the plugin supports. It's in the order of priority(first has the highest priority).
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Authentication.DigestStore.GetOrCreate(System.Uri)">
            <summary>
            It will retrieve or create a new Digest for the given Uri.
            </summary>
            <param name="uri"></param>
            <returns></returns>
        </member>
        <member name="T:Best.HTTP.Request.Authentication.WWWAuthenticateHeaderParser">
            <summary>
            Used for parsing WWW-Authenticate headers:
            `Digest realm="my realm", nonce="4664b327a2963503ba58bbe13ad672c0", qop=auth, opaque="f7e38bdc1c66fce214f9019ffe43117c"`
            </summary>
        </member>
        <member name="T:Best.HTTP.Request.Authenticators.BearerTokenAuthenticator">
            <summary>
            An <see cref="T:Best.HTTP.Request.Authenticators.IAuthenticator"/> implementation for Bearer Token authentication.
            </summary>
            <remarks>
            Bearer Token authentication is a method used to access protected resources on a server.
            It involves including a bearer token in the Authorization header of an HTTP request to prove the identity of the requester.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Request.Authenticators.BearerTokenAuthenticator.Token">
            <summary>
            Initializes a new instance of the BearerTokenAuthenticator class with the specified Bearer Token.
            </summary>
            <param name="token">The Bearer Token to use for authentication.</param>
        </member>
        <member name="M:Best.HTTP.Request.Authenticators.BearerTokenAuthenticator.#ctor(System.String)">
            <summary>
            Sets up the required Authorization header with the Bearer Token for the HTTP request.
            </summary>
            <param name="request">The HTTP request for which the Authorization header should be added.</param>
            <remarks>
            When sending an HTTP request to a server that requires Bearer Token authentication,
            this method sets the Authorization header with the Bearer Token to prove the identity of the requester.
            This allows the requester to access protected resources on the server.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Request.Authenticators.BearerTokenAuthenticator.HandleChallange(Best.HTTP.HTTPRequest,Best.HTTP.HTTPResponse)">
            <summary>
            Handles the server response with a 401 (Unauthorized) status code and a WWW-Authenticate header.
            This authenticator does not handle challenges and always returns <c>false</c>.
            </summary>
            <param name="req">The HTTP request that received the 401 response.</param>
            <param name="resp">The HTTP response containing the 401 (Unauthorized) status.</param>
            <returns><c>false</c>, as this authenticator does not handle challenges.</returns>
            <remarks>
            Bearer Token authentication typically does not require handling challenges,
            as the Bearer Token is included directly in the Authorization header of the request.
            This method always returns <c>false</c>, as no additional challenge processing is needed.
            </remarks>
        </member>
        <member name="T:Best.HTTP.Request.Authenticators.CredentialAuthenticator">
            <summary>
            An <see cref="T:Best.HTTP.Request.Authenticators.IAuthenticator"/> implementation for HTTP Basic or Digest authentication.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Authenticators.CredentialAuthenticator.Credentials">
            <summary>
            Gets or sets the <see cref="T:Best.HTTP.Request.Authentication.Credentials"/> associated with this authenticator.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Authenticators.CredentialAuthenticator.#ctor(Best.HTTP.Request.Authentication.Credentials)">
            <summary>
            Initializes a new instance of the CrendetialAuthenticator class with the specified <see cref="T:Best.HTTP.Request.Authentication.Credentials"/>.
            </summary>
            <param name="credentials">The <see cref="T:Best.HTTP.Request.Authentication.Credentials"/> to use for authentication.</param>
            <exception cref="T:System.ArgumentNullException">Thrown if <paramref name="credentials"/> is null.</exception>
        </member>
        <member name="M:Best.HTTP.Request.Authenticators.CredentialAuthenticator.SetupRequest(Best.HTTP.HTTPRequest)">
            <summary>
            Sets up the required headers for the HTTP request based on the provided credentials.
            </summary>
            <param name="request">The HTTP request for which headers should be added.</param>
        </member>
        <member name="M:Best.HTTP.Request.Authenticators.CredentialAuthenticator.HandleChallange(Best.HTTP.HTTPRequest,Best.HTTP.HTTPResponse)">
            <summary>
            Handles the server response with a 401 (Unauthorized) status code and a WWW-Authenticate header.
            The authenticator might determine the authentication method to use and initiate authentication if needed.
            </summary>
            <param name="req">The HTTP request that received the 401 response.</param>
            <param name="resp">The HTTP response containing the 401 (Unauthorized) status.</param>
            <returns><c>true</c> if the challenge is handled by the authenticator and the request can be resent with authentication; otherwise, <c>false</c>.</returns>
        </member>
        <member name="T:Best.HTTP.Request.Authenticators.IAuthenticator">
            <summary>
            Represents an interface for various authentication implementations used in HTTP requests.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Authenticators.IAuthenticator.SetupRequest(Best.HTTP.HTTPRequest)">
            <summary>
            Set required headers or content for the HTTP request. Called right before the request is sent out.
            </summary>
            <remarks>
            <para>
            The SetupRequest method will be called every time the request is redirected or retried.
            </para>
            </remarks>
            <param name="request">The HTTP request to which headers or content will be added.</param>
        </member>
        <member name="M:Best.HTTP.Request.Authenticators.IAuthenticator.HandleChallange(Best.HTTP.HTTPRequest,Best.HTTP.HTTPResponse)">
            <summary>
            Called when the server is sending a 401 (Unauthorized) response with an WWW-Authenticate header.
            The authenticator might find additional knowledge about the authentication requirements (like what auth method it should use).
            If the authenticator is confident it can successfully (re)authenticate the request it can return true and the request will be resent to the server.
            </summary>
            <remarks>
            More details can be found here:
            <list type="bullet">
                <item><description><see href="https://www.rfc-editor.org/rfc/rfc9110.html#status.401">RFC-9110 - 401 Unauthorized</see></description></item>
                <item><description><see href="https://www.rfc-editor.org/rfc/rfc9110.html#name-www-authenticate">RFC-9110 - WWW-Authenticate header</see></description></item>
            </list>
            </remarks>
            <param name="req">The HTTP request that received the 401 response.</param>
            <param name="resp">The HTTP response containing the 401 (Unauthorized) status.</param>
            <returns><c>true</c> if the challange is handled by the authenticator and the request can be re-sent with authentication.</returns>
        </member>
        <member name="T:Best.HTTP.Request.Settings.OnHeadersReceivedDelegate">
            <summary>
            Delegate for handling the event when headers are received in a response.
            </summary>
            <param name="req">The <see cref="T:Best.HTTP.HTTPRequest"/> object.</param>
            <param name="resp">The <see cref="T:Best.HTTP.HTTPResponse"/> object.</param>
            <param name="headers">The headers received from the server.</param>
        </member>
        <member name="T:Best.HTTP.Request.Settings.OnProgressDelegate">
            <summary>
            Delegate for handling progress during the download.
            </summary>
            <param name="req">The <see cref="T:Best.HTTP.HTTPRequest"/> object.</param>
            <param name="progress">The number of bytes downloaded so far.</param>
            <param name="length">The total length of the content being downloaded, or -1 if the length cannot be determined.</param>
        </member>
        <member name="T:Best.HTTP.Request.Settings.OnDownloadStartedDelegate">
            <summary>
            Delegate for handling the event when the download of content starts.
            </summary>
            <param name="req">The <see cref="T:Best.HTTP.HTTPRequest"/> object.</param>
            <param name="resp">The <see cref="T:Best.HTTP.HTTPResponse"/> object.</param>
            <param name="stream">The <see cref="T:Best.HTTP.Response.DownloadContentStream"/> used for receiving downloaded content.</param>
        </member>
        <member name="T:Best.HTTP.Request.Settings.OnCreateDownloadStreamDelegate">
            <summary>
            Delegate for creating a new <see cref="T:Best.HTTP.Response.DownloadContentStream"/> object.
            </summary>
            <param name="req">The <see cref="T:Best.HTTP.HTTPRequest"/> object.</param>
            <param name="resp">The <see cref="T:Best.HTTP.HTTPResponse"/> object.</param>
            <param name="bufferAvailableHandler">An interface for notifying connections that the buffer has free space for downloading data.</param>
            <returns>The newly created <see cref="T:Best.HTTP.Response.DownloadContentStream"/>.</returns>
        </member>
        <member name="T:Best.HTTP.Request.Settings.DownloadSettings">
            <summary>
            Represents settings for configuring an HTTP request's download behavior.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Settings.DownloadSettings.ContentStreamMaxBuffered">
            <summary>
            Gets or sets the maximum number of bytes the <see cref="T:Best.HTTP.Response.DownloadContentStream"/> will buffer before pausing the download until its buffer has free space again.
            </summary>
            <remarks>
            When the download content stream buffers data up to this specified limit, it will temporarily pause downloading until it has free space in its buffer.
            Increasing this value may help reduce the frequency of pauses during downloads, but it also increases memory usage.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Request.Settings.DownloadSettings.DisableCache">
            <summary>
            Gets or sets a value indicating whether caching should be enabled for this request.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Settings.DownloadSettings.CacheOnly">
            <summary>
            Gets or sets a value indicating whether the response's <see cref="T:Best.HTTP.Response.DownloadContentStream"/> should be populated with downloaded data or if the content should be written only to the local cache when available.
            </summary>
            <remarks>
            If set to <c>true</c> and the content isn't cacheable (e.g., it doesn't have any cache-related headers), the content will be downloaded but will be lost.
            </remarks>
            <summary>
            Gets or sets a value indicating whether the response's <see cref="P:Best.HTTP.HTTPResponse.DownStream"/> should be populated with downloaded data or if the content should be written only to the local cache when available.
            </summary>
            <remarks>
            If set to <c>true</c> and the content isn't cacheable (e.g., it doesn't have any cache-related headers), the content will be downloaded but will be lost.
            This is because the downloaded data would be written exclusively to the local cache and will not be stored in memory or the response's <see cref="P:Best.HTTP.HTTPResponse.DownStream"/> for further use.
            </remarks>
        </member>
        <member name="F:Best.HTTP.Request.Settings.DownloadSettings.OnHeadersReceived">
            <summary>
            This event is called when the plugin received and parsed all headers.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Settings.DownloadSettings.DownloadStreamFactory">
            <summary>
            Represents a function that creates a new <see cref="T:Best.HTTP.Response.DownloadContentStream"/> object when needed for downloading content.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Settings.DownloadSettings.OnDownloadStarted">
            <summary>
            Event for handling the start of the download process for 2xx status code responses.
            </summary>
            <param name="req">The <see cref="T:Best.HTTP.HTTPRequest"/> object.</param>
            <param name="resp">The <see cref="T:Best.HTTP.HTTPResponse"/> object representing the response.</param>
            <param name="stream">
            The <see cref="T:Best.HTTP.Response.DownloadContentStream"/> containing the downloaded data. It might already be populated with some content.
            </param>
            <remarks>
            This event is called when the plugin expects the server to send content. When called, the <see cref="T:Best.HTTP.Response.DownloadContentStream"/>
            might already be populated with some content. It is specifically meant for responses with 2xx status codes.
            </remarks>
        </member>
        <member name="F:Best.HTTP.Request.Settings.DownloadSettings.OnDownloadProgress">
            <summary>
            Gets or sets the event that is called when new data is downloaded from the server.
            </summary>
            <remarks>
            The first parameter is the original <see cref="T:Best.HTTP.HTTPRequest"/> object itself, the second parameter is the downloaded bytes, and the third parameter is the content length.
            There are download modes where we can't figure out the exact length of the final content. In these cases, we guarantee that the third parameter will be at least the size of the second one.
            </remarks>
        </member>
        <member name="T:Best.HTTP.Request.Settings.ProxySettings">
            <summary>
            Represents settings related to using a proxy server for HTTP requests.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Settings.ProxySettings.HasProxyFor(System.Uri)">
            <summary>
            Checks if there is a proxy configured for the given URI.
            </summary>
            <param name="uri">The URI to check for proxy usage.</param>
            <returns><c>true</c> if a proxy is configured and should be used for the URI; otherwise, <c>false</c>.</returns>
        </member>
        <member name="P:Best.HTTP.Request.Settings.ProxySettings.Proxy">
            <summary>
            Gets or sets the proxy object used for the request.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Settings.ProxySettings.SetupRequest(Best.HTTP.HTTPRequest)">
            <summary>
            Sets up the HTTP request for passing through a proxy server.
            </summary>
            <param name="request">The HTTP request to set up.</param>
        </member>
        <member name="M:Best.HTTP.Request.Settings.ProxySettings.Handle407(Best.HTTP.HTTPRequest)">
            <summary>
            Handles the proxy's response with status code <c>407</c>.
            </summary>
            <param name="request">The HTTP request that received a <c>407</c> response.</param>
            <returns><c>true</c> to resend the request through the proxy; otherwise, <c>false</c>.</returns>
        </member>
        <member name="M:Best.HTTP.Request.Settings.ProxySettings.AddToHash(System.Uri,UnityEngine.Hash128@)">
            <summary>
            Adds the proxy address to a hash for the given request URI.
            </summary>
            <param name="requestUri">The request URI for which the proxy address is added to the hash.</param>
            <param name="hash">The hash to which the proxy address is added.</param>
        </member>
        <member name="T:Best.HTTP.Request.Settings.RedirectSettings">
            <summary>
            Represents settings related to handling HTTP request redirection.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Settings.RedirectSettings.IsRedirected">
            <summary>
            Indicates whether the request has been redirected.
            A request's IsRedirected might be true while <see cref="P:Best.HTTP.Request.Settings.RedirectSettings.RedirectCount"/> is zero if the redirection is made to the local cache.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Settings.RedirectSettings.RedirectUri">
            <summary>
            The Uri that the request is redirected to.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Settings.RedirectSettings.MaxRedirects">
            <summary>
            How many redirection is supported for this request. The default is 10. Zero or a negative value means no redirections are supported.
            </summary>
            <summary>
            Gets or sets the maximum number of redirections supported for this request. The default is <c>10</c>.
            A value of zero or a negative value means no redirections are supported.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Settings.RedirectSettings.RedirectCount">
            <summary>
            Gets the number of times the request has been redirected.
            </summary>
        </member>
        <member name="E:Best.HTTP.Request.Settings.RedirectSettings.OnBeforeRedirection">
            <summary>
            Occurs before the plugin makes a new request to the new URI during redirection.
            The return value of this event handler controls whether the redirection is aborted (<c>false</c>) or allowed (<c>true</c>).
            This event is called on a thread other than the main Unity thread.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Settings.RedirectSettings.#ctor(System.Int32)">
            <summary>
            Initializes a new instance of the RedirectSettings class with the specified maximum redirections.
            </summary>
            <param name="maxRedirects">The maximum number of redirections allowed.</param>
        </member>
        <member name="M:Best.HTTP.Request.Settings.RedirectSettings.Reset">
            <summary>
            Resets <see cref="P:Best.HTTP.Request.Settings.RedirectSettings.IsRedirected"/> and <see cref="P:Best.HTTP.Request.Settings.RedirectSettings.RedirectCount"/> to their default values.
            </summary>
        </member>
        <member name="T:Best.HTTP.Request.Settings.RetrySettings">
            <summary>
            Represents settings related to request retry behavior.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Settings.RetrySettings.Retries">
            <summary>
            Gets the number of times that the plugin has retried the request.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Settings.RetrySettings.MaxRetries">
            <summary>
            Gets or sets the maximum number of retry attempts allowed. To disable retries, set this value to <c>0</c>.
            The default value is <c>1</c> for GET requests, otherwise <c>0</c>.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Settings.RetrySettings.#ctor(System.Int32)">
            <summary>
            Initializes a new instance of the RetrySettings class with the specified maximum retry attempts.
            </summary>
            <param name="maxRetries">The maximum number of retry attempts allowed.</param>
        </member>
        <member name="T:Best.HTTP.Request.Settings.TimeoutSettings">
            <summary>
            Represents settings related to connection-timeouts and processing duration.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Settings.TimeoutSettings.QueuedAt">
            <summary>
            Gets the timestamp when the request was queued for processing.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Settings.TimeoutSettings.ProcessingStarted">
            <summary>
            Gets the timestamp when the processing of the request started by a connection.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Settings.TimeoutSettings.ConnectTimeout">
            <summary>
            Gets or sets the maximum time to wait for establishing the connection to the target server.
            If set to <c>TimeSpan.Zero</c> or lower, no connect timeout logic is executed. Default value is 20 seconds.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Settings.TimeoutSettings.Timeout">
            <summary>
            Gets or sets the maximum time to wait for the request to finish after the connection is established.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Settings.TimeoutSettings.IsConnectTimedOut(System.DateTime)">
            <summary>
            Returns <c>true</c> if the request has been stuck in the connection phase for too long.
            </summary>
            <param name="now">The current timestamp.</param>
            <returns><c>true</c> if the connection has timed out; otherwise, <c>false</c>.</returns>
        </member>
        <member name="M:Best.HTTP.Request.Settings.TimeoutSettings.IsTimedOut(System.DateTime)">
            <summary>
            Returns <c>true</c> if the time has passed the specified Timeout setting since processing started or if the connection has timed out.
            </summary>
            <param name="now">The current timestamp.</param>
            <returns><c>true</c> if the request has timed out; otherwise, <c>false</c>.</returns>
        </member>
        <member name="M:Best.HTTP.Request.Settings.TimeoutSettings.#ctor(Best.HTTP.HTTPRequest)">
            <summary>
            Initializes a new instance of the TimeoutSettings class for a specific <see cref="T:Best.HTTP.HTTPRequest"/>.
            </summary>
            <param name="request">The <see cref="T:Best.HTTP.HTTPRequest"/> associated with these timeout settings.</param>
        </member>
        <member name="T:Best.HTTP.Request.Settings.UploadSettings">
            <summary>
            Options for sending the request headers and content, including upload progress monitoring.
            </summary>
            <remarks><see cref="M:Best.HTTP.Request.Settings.UploadSettings.SetupRequest(Best.HTTP.HTTPRequest,System.Boolean)"/> might be called when redirected or retried!</remarks>
        </member>
        <member name="F:Best.HTTP.Request.Settings.UploadSettings.UploadChunkSize">
            <summary>
            Size of the internal buffer, and upload progress will be fired when this size of data sent to the wire. Its default value is 4 KiB.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Settings.UploadSettings.UploadStream">
            <summary>
            The stream that the plugin will use to send data to the server.
            </summary>
            <remarks>
            The stream can be any regular <see cref="T:System.IO.Stream"/> implementation or a specialized one inheriting from <see cref="T:Best.HTTP.Request.Upload.UploadStreamBase"/>:
            <list type="bullet">
                <item><term><see cref="T:Best.HTTP.Request.Upload.DynamicUploadStream"/></term><description>A specialized <see cref="T:Best.HTTP.Request.Upload.UploadStreamBase"/> for data generated on-the-fly or periodically. The request remains active until the <see cref="M:Best.HTTP.Request.Upload.DynamicUploadStream.Complete"/> method is invoked, ensuring continuous data feed even during temporary empty states.</description></item>
                <item><term><see cref="T:Best.HTTP.Request.Upload.JSonDataStream`1"/></term><description>An <see cref="T:Best.HTTP.Request.Upload.UploadStreamBase"/> implementation to convert and upload the object as JSON data. It sets the <c>"Content-Type"</c> header to <c>"application/json; charset=utf-8"</c>.</description></item>
                <item><term><see cref="T:Best.HTTP.Request.Upload.Forms.UrlEncodedStream"/></term><description>An <see cref="T:Best.HTTP.Request.Upload.UploadStreamBase"/> implementation representing a stream that prepares and sends data as URL-encoded form data in an HTTP request.</description></item>
                <item><term><see cref="T:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream"/></term><description>An <see cref="T:Best.HTTP.Request.Upload.UploadStreamBase"/> based implementation of the <c>multipart/form-data</c> Content-Type. It's very memory-effective, streams are read into memory in chunks.</description></item>
            </list>
            </remarks>
        </member>
        <member name="F:Best.HTTP.Request.Settings.UploadSettings.DisposeStream">
            <summary>
            Set to <c>false</c> if the plugin MUST NOT dispose <see cref="F:Best.HTTP.Request.Settings.UploadSettings.UploadStream"/> after the request is finished.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Settings.UploadSettings.OnUploadProgress">
            <summary>
            Called periodically when data sent to the server.
            </summary>
        </member>
        <member name="E:Best.HTTP.Request.Settings.UploadSettings.OnHeadersSent">
            <summary>
            This event is fired after the headers are sent to the server.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Settings.UploadSettings.SetupRequest(Best.HTTP.HTTPRequest,System.Boolean)">
            <summary>
            Called every time the request is sent out (redirected or retried).
            </summary>
            <param name="request">The <see cref="T:Best.HTTP.HTTPRequest"/> being prepared.</param>
            <param name="dispatchHeadersSentCallback"><c>true</c> if the <see cref="E:Best.HTTP.Request.Settings.UploadSettings.OnHeadersSent"/> can be fired.</param>
        </member>
        <member name="M:Best.HTTP.Request.Settings.UploadSettings.Dispose">
            <summary>
            Dispose of resources used by the UploadSettings instance.
            </summary>
        </member>
        <member name="T:Best.HTTP.Request.Timings.TimingCollector">
            <summary>
            Helper class to store, calculate and manage request related events and theirs duration, referenced by <see cref="P:Best.HTTP.HTTPRequest.Timing"/> field.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Timings.TimingCollector.Created">
            <summary>
            When the TimingCollector instance created.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Timings.TimingCollector.Finished">
            <summary>
            When the closing Finish event is sent.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Timings.TimingCollector.Events">
            <summary>
            List of added events.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Timings.TimingCollector.Finish">
            <summary>
            Finish the last event.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Timings.TimingCollector.Abort">
            <summary>
            Abort the currently running event.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Timings.TimingCollector.AddEvent(System.String,System.DateTime,System.TimeSpan)">
            <summary>
            When the event happened and for how long.
            </summary>
        </member>
        <member name="T:Best.HTTP.Request.Timings.TimingEvent">
            <summary>
            Struct to hold information about one timing event recorded for a <see cref="T:Best.HTTP.HTTPRequest"/>. Timing events are managed by the <see cref="T:Best.HTTP.Request.Timings.TimingCollector"/>.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Timings.TimingEvent.Name">
            <summary>
            Name of the event
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Timings.TimingEvent.Duration">
            <summary>
            Duration of the event.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Timings.TimingEvent.When">
            <summary>
            When the event occurred.
            </summary>
        </member>
        <member name="T:Best.HTTP.Request.Upload.BodyLengths">
            <summary>
            Provides constants representing different, special body lengths for HTTP requests with upload streams.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Upload.BodyLengths.UnknownWithChunkedTransferEncoding">
            <summary>
            The <see cref="T:Best.HTTP.Request.Upload.UploadStreamBase"/>'s length is unknown and the plugin have to send data with '<c>chunked</c>' transfer-encoding.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Upload.BodyLengths.UnknownRaw">
            <summary>
            The <see cref="T:Best.HTTP.Request.Upload.UploadStreamBase"/>'s length is unknown and the plugin have to send data as-is, without any encoding.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Upload.BodyLengths.NoBody">
            <summary>
            No content to send.
            </summary>
        </member>
        <member name="T:Best.HTTP.Request.Upload.DynamicUploadStream">
            <summary>
            A specialized upload stream designed to handle data that's generated on-the-fly or periodically.
            </summary>
            <remarks>
            This implementation is designed to handle scenarios where data may not always be immediately available for upload.
            The request will remain active until the <see cref="M:Best.HTTP.Request.Upload.DynamicUploadStream.Complete"/> method is invoked, ensuring that data can continue to be fed into the stream even if it's temporarily empty during a Read operation.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Request.Upload.DynamicUploadStream.Length">
            <summary>
            Gets the length of the upload stream.
            </summary>
            <remarks>
            This implementation returns a constant value of <c>-1</c>, indicating that the length of the data to be uploaded is unknown. When the processing connection encounters this value, it should utilize chunked uploading to handle the data transfer.
            </remarks>
            <value>The constant value of <c>-1</c>, representing unknown length.</value>
        </member>
        <member name="P:Best.HTTP.Request.Upload.DynamicUploadStream.BufferedLength">
            <summary>
            Gets the length of data currently buffered and ready for upload.
            </summary>
            <value>The length of buffered data in bytes.</value>
        </member>
        <member name="M:Best.HTTP.Request.Upload.DynamicUploadStream.#ctor(System.String)">
            <summary>
            Initializes a new instance of the DynamicUploadStream class with an optional content type.
            </summary>
            <param name="contentType">The MIME type of the content to be uploaded. Defaults to "<c>application/octet-stream</c>" if not specified.</param>
            <remarks>
            This constructor allows the caller to specify the content type of the data to be uploaded. If not provided, it defaults to a general binary data type.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Request.Upload.DynamicUploadStream.BeforeSendHeaders(Best.HTTP.HTTPRequest)">
            <summary>
            Sets the necessary headers before sending the request.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Upload.DynamicUploadStream.BeforeSendBody(Best.HTTP.HTTPRequest,Best.HTTP.Hosts.Connections.IThreadSignaler)">
            <summary>
            Prepares the stream before the request body is sent.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Upload.DynamicUploadStream.Read(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Reads data from the stream to be uploaded.
            </summary>
            <remarks>
            The returned value indicates the state of the stream:
            <list type="bullet">
                <item><term>-1</term><description>More data is expected in the future, but isn't currently available. When new data is ready, the IThreadSignaler must be notified.</description></item>
                <item><term>0</term><description>The stream has been closed and no more data will be provided.</description></item>
                <item><description>Otherwise it returns with the number bytes copied to the buffer.</description></item>
            </list>
            Note: A zero return value can come after a -1 return, indicating a transition from waiting to completion.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Request.Upload.DynamicUploadStream.Write(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Writes data to the stream, making it available for upload.
            </summary>
            <remarks>
            After writing data to the stream using this method, the connection is signaled that data is available to send.
            </remarks>
            <param name="buffer">The array of unsigned bytes from which to copy count bytes to the current stream.</param>
            <param name="offset">The zero-based byte offset in buffer at which to begin copying bytes to the current stream.</param>
            <param name="count">The number of bytes to be written to the current stream.</param>
            <exception cref="T:System.InvalidOperationException">Thrown when trying to write after the stream has been marked as complete.</exception>
        </member>
        <member name="M:Best.HTTP.Request.Upload.DynamicUploadStream.Write(Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment)">
            <summary>
            Writes a segment of data to the stream, making it available for upload.
            </summary>
            <param name="segment">A segment of data to be written to the stream.</param>
            <exception cref="T:System.InvalidOperationException">Thrown when trying to write after the stream has been marked as complete.</exception>
            <remarks>
            After writing a segment to the stream using this method, the connection is signaled that data is available to send.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Request.Upload.DynamicUploadStream.Complete">
            <summary>
            Marks the stream as complete, signaling that no more data will be added.
            </summary>
            <remarks>
            All remaining buffered data will be sent to the server.
            </remarks>
        </member>
        <member name="T:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream">
            <summary>
            An <see cref="T:Best.HTTP.Request.Upload.UploadStreamBase"/> based implementation of the <c>multipart/form-data</c> Content-Type. It's very memory-effective, streams are read into memory in chunks.
            </summary>
            <remarks>
            <para>The return value of <see cref="M:System.IO.Stream.Read(System.Byte[],System.Int32,System.Int32)"/> is treated specially in the plugin:
            <list type="bullet">
                <item>
                    <term>Less than zero(<c>-1</c>) value </term>
                    <description> indicates that no data is currently available but more is expected in the future. In this case, when new data becomes available the IThreadSignaler object must be signaled.</description>
                </item>
                <item>
                    <term>Zero (<c>0</c>)</term>
                    <description> means that the stream is closed, no more data can be expected.</description>
                </item>
            </list>
            A zero value to signal stream closure can follow a less than zero value.</para>
            </remarks>
        </member>
        <member name="P:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.Length">
            <summary>
            Gets the length of this multipart/form-data stream.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.boundary">
            <summary>
            A random boundary generated in the constructor.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.#ctor">
            <summary>
            Initializes a new instance of the MultipartFormDataStream class.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.#ctor(System.String)">
            <summary>
            Initializes a new instance of the MultipartFormDataStream class with a custom boundary.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.AddField(System.String,System.String)">
            <summary>
            Adds a textual field to the multipart/form-data stream.
            </summary>
            <param name="fieldName">The name of the field.</param>
            <param name="value">The textual value of the field.</param>
            <returns>The MultipartFormDataStream instance for method chaining.</returns>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.AddField(System.String,System.String,System.Text.Encoding)">
            <summary>
            Adds a textual field to the multipart/form-data stream.
            </summary>
            <param name="fieldName">The name of the field.</param>
            <param name="value">The textual value of the field.</param>
            <param name="encoding">The encoding to use for the value.</param>
            <returns>The MultipartFormDataStream instance for method chaining.</returns>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.AddField(System.String,System.Byte[])">
            <summary>
            Adds a stream field to the multipart/form-data stream.
            </summary>
            <param name="fieldName">The name of the field.</param>
            <param name="data">The data containing the field data.</param>
            <returns>The MultipartFormDataStream instance for method chaining.</returns>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.AddStreamField(System.String,System.IO.Stream)">
            <summary>
            Adds a stream field to the multipart/form-data stream.
            </summary>
            <param name="stream">The stream containing the field data.</param>
            <param name="fieldName">The name of the field.</param>
            <returns>The MultipartFormDataStream instance for method chaining.</returns>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.AddStreamField(System.String,System.IO.Stream,System.String)">
            <summary>
            Adds a stream field to the multipart/form-data stream.
            </summary>
            <param name="stream">The stream containing the field data.</param>
            <param name="fieldName">The name of the field.</param>
            <param name="fileName">The name of the file, if applicable.</param>
            <returns>The MultipartFormDataStream instance for method chaining.</returns>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.AddStreamField(System.String,System.IO.Stream,System.String,System.String)">
            <summary>
            Adds a stream field to the multipart/form-data stream.
            </summary>
            <param name="stream">The stream containing the field data.</param>
            <param name="fieldName">The name of the field.</param>
            <param name="fileName">The name of the file, if applicable.</param>
            <param name="mimeType">The MIME type of the content.</param>
            <returns>The MultipartFormDataStream instance for method chaining.</returns>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.BeforeSendBody(Best.HTTP.HTTPRequest,Best.HTTP.Hosts.Connections.IThreadSignaler)">
            <summary>
            Adds the final boundary to the multipart/form-data stream before sending the request body.
            </summary>
            <param name="request">The HTTP request.</param>
            <param name="threadSignaler">The thread signaler for handling asynchronous operations.</param>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.MultipartFormDataStream.Read(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Reads data from the multipart/form-data stream into the provided buffer.
            </summary>
            <param name="buffer">The buffer to read data into.</param>
            <param name="offset">The starting offset in the buffer.</param>
            <param name="length">The maximum number of bytes to read.</param>
            <returns>The number of bytes read into the buffer.</returns>
        </member>
        <member name="T:Best.HTTP.Request.Upload.Forms.FormField">
            <summary>
            Readonly struct to hold key -> value pairs, where the value is either textual or binary.
            </summary>
        </member>
        <member name="T:Best.HTTP.Request.Upload.Forms.UrlEncodedStream">
            <summary>
            An <see cref="T:Best.HTTP.Request.Upload.UploadStreamBase"/> implementation representing a stream that prepares and sends data as URL-encoded form data in an HTTP request.
            </summary>
            <remarks>
            <para>This stream is used to send data as URL-encoded form data in an HTTP request. It sets the <c>"Content-Type"</c> header to <c>"application/x-www-form-urlencoded"</c>.
            URL-encoded form data is typically used for submitting form data to a web server. It is commonly used in HTTP POST requests to send data to a server, such as submitting HTML form data.</para>
            
            <para>The return value of <see cref="M:System.IO.Stream.Read(System.Byte[],System.Int32,System.Int32)"/> is treated specially in the plugin:
            <list type="bullet">
                <item>
                    <term>Less than zero(<c>-1</c>) value </term>
                    <description> indicates that no data is currently available but more is expected in the future. In this case, when new data becomes available the IThreadSignaler object must be signaled.</description>
                </item>
                <item>
                    <term>Zero (<c>0</c>)</term>
                    <description> means that the stream is closed, no more data can be expected.</description>
                </item>
            </list>
            A zero value to signal stream closure can follow a less than zero value.</para>
            <para>While it's possible, it's not advised to send binary data url-encoded!</para>
            </remarks>
        </member>
        <member name="P:Best.HTTP.Request.Upload.Forms.UrlEncodedStream.Length">
            <summary>
            Gets the length of the stream.
            </summary>
        </member>
        <member name="F:Best.HTTP.Request.Upload.Forms.UrlEncodedStream._fields">
            <summary>
            A list that holds the form's fields.
            </summary>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.UrlEncodedStream.BeforeSendHeaders(Best.HTTP.HTTPRequest)">
            <summary>
            Sets up the HTTP request by adding the <c>"Content-Type"</c> header as <c>"application/x-www-form-urlencoded"</c>.
            </summary>
            <param name="request">The HTTP request.</param>
        </member>
        <member name="M:Best.HTTP.Request.Upload.Forms.UrlEncodedStream.AddBinaryData(System.String,System.Byte[])">
            <summary>
            Adds binary data to the form. It is not advised to send binary data with an URL-encoded form due to the conversion cost of binary to text conversion.
            </summary>
            <param name="fieldName">The name of the field.</param>
            <param name="content">The binary data content.</param>
            <returns>The UrlEncodedStream instance for method chaining.</returns>
        </member>
        <member name="T:Best.HTTP.Request.Upload.JSonDataStream`1">
            <summary>
            An <see cref="T:Best.HTTP.Request.Upload.UploadStreamBase"/> implementation to convert and upload the object as JSON data. It sets the <c>"Content-Type"</c> header to <c>"application/json; charset=utf-8"</c>.
            </summary>
            <typeparam name="T">The type of the object to be converted to JSON.</typeparam>
            <remarks>
            <para>This stream keeps a reference to the object until the preparation in <see cref="M:Best.HTTP.Request.Upload.JSonDataStream`1.BeforeSendHeaders(Best.HTTP.HTTPRequest)"/>. This means, changes to the object after passing it to the constructor will be reflected in the sent data too.</para>
            <para>The return value of <see cref="M:System.IO.Stream.Read(System.Byte[],System.Int32,System.Int32)"/> is treated specially in the plugin:
            <list type="bullet">
                <item>
                    <term>Less than zero(<c>-1</c>) value </term>
                    <description> indicates that no data is currently available but more is expected in the future. In this case, when new data becomes available the IThreadSignaler object must be signaled.</description>
                </item>
                <item>
                    <term>Zero (<c>0</c>)</term>
                    <description> means that the stream is closed, no more data can be expected.</description>
                </item>
            </list>
            A zero value to signal stream closure can follow a less than zero value.</para>
            </remarks>
        </member>
        <member name="M:Best.HTTP.Request.Upload.JSonDataStream`1.#ctor(`0)">
            <summary>
            Initializes a new instance of the <see cref="T:Best.HTTP.Request.Upload.JSonDataStream`1"/> class with the specified object.
            </summary>
            <param name="obj">The object to be converted to JSON and uploaded.</param>
        </member>
        <member name="M:Best.HTTP.Request.Upload.JSonDataStream`1.BeforeSendHeaders(Best.HTTP.HTTPRequest)">
            <summary>
            Called before sending out the request's headers. It sets the <c>"Content-Type"</c> header to <c>"application/json; charset=utf-8"</c>.
            </summary>
            <param name="request">The HTTP request.</param>
        </member>
        <member name="M:Best.HTTP.Request.Upload.JSonDataStream`1.Read(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
            </summary>
            <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between <paramref name="offset"/> and ( <paramref name="offset"/> + <paramref name="count"/> - 1) replaced by the bytes read from the current source.</param>
            <param name="offset">The zero-based byte offset in <paramref name="buffer"/> at which to begin storing the data read from the current stream.</param>
            <param name="count">The maximum number of bytes to be read from the current stream.</param>
            <returns>The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.</returns>
        </member>
        <member name="M:Best.HTTP.Request.Upload.JSonDataStream`1.Dispose(System.Boolean)">
            <summary>
            Releases the unmanaged resources used by the <see cref="T:Best.HTTP.Request.Upload.JSonDataStream`1"/> and optionally releases the managed resources.
            </summary>
            <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
        </member>
        <member name="T:Best.HTTP.Request.Upload.UploadStreamBase">
            <summary>
            Abstract class to serve as a base for non-conventional streams used in HTTP requests.
            </summary>
            <remarks>
            The return value of <see cref="M:System.IO.Stream.Read(System.Byte[],System.Int32,System.Int32)"/> is treated specially in the plugin:
            <list type="bullet">
                <item>
                    <term>Less than zero(<c>-1</c>)</term>
                    <description> indicates that no data is currently available but more is expected in the future. In this case, when new data becomes available the IThreadSignaler object must be signaled.</description>
                </item>
                <item>
                    <term>Zero (<c>0</c>)</term>
                    <description> means that the stream is closed, no more data can be expected.</description>
                </item>
                <item><description>Otherwise it must return with the number bytes copied to the buffer.</description></item>
            </list>
            A zero value to signal stream closure can follow a less than zero value.
            </remarks>
        </member>
        <member name="P:Best.HTTP.Request.Upload.UploadStreamBase.Signaler">
            <summary>
            Gets the <see cref="T:Best.HTTP.Hosts.Connections.IThreadSignaler"/> object for signaling when new data is available.
            </summary>
        </member>
        <member name="P:Best.HTTP.Request.Upload.UploadStreamBase.Length">
            <summary>
            Length in bytes that the stream will upload.
            </summary>
            <remarks>
            The return value of Length is treated specially in the plugin:
            <list type="bullet">
                <item><term>-2</term><description>The stream's length is unknown and the plugin have to send data <c>with 'chunked' transfer-encoding</c>.</description></item>
                <item><term>-1</term><description>The stream's length is unknown and the plugin have to send data <c>as-is, without any encoding</c>.</description></item>
                <item><term>0</term><description>No content to send. The content-length header will contain zero (<c>0</c>).</description></item>
                <item><term>>0</term><description>Length of the content is known, will be sent <c>as-is, without any encoding</c>. The content-length header will contain zero (<c>0</c>).</description></item>
            </list>
            Constants for the first three points can be found in <see cref="T:Best.HTTP.Request.Upload.BodyLengths"/>.
            </remarks>
        </member>
        <member name="M:Best.HTTP.Request.Upload.UploadStreamBase.BeforeSendHeaders(Best.HTTP.HTTPRequest)">
            <summary>
            Called before sending out the request's headers. Perform content processing to calculate the final length if possible.
            In this function the implementor can set headers and other parameters to the request.
            </summary>
            <remarks>Typically called on a thread.</remarks>
            <param name="request">The <see cref="T:Best.HTTP.HTTPRequest"/> associated with the stream.</param>
        </member>
        <member name="M:Best.HTTP.Request.Upload.UploadStreamBase.BeforeSendBody(Best.HTTP.HTTPRequest,Best.HTTP.Hosts.Connections.IThreadSignaler)">
            <summary>
            Called just before sending out the request's body, and saves the <see cref="T:Best.HTTP.Hosts.Connections.IThreadSignaler"/> for signaling when new data is available.
            </summary>
            <param name="request">The HTTPRequest associated with the stream.</param>
            <param name="threadSignaler">The <see cref="T:Best.HTTP.Hosts.Connections.IThreadSignaler"/> object to be used for signaling.</param>
            <remarks>Typically called on a separate thread.</remarks>
            <summary>
            Called just before sending out the request's body, saves the <see cref="T:Best.HTTP.Hosts.Connections.IThreadSignaler"/> that can be used for signaling when new data is available.
            </summary>
            <param name="request">The HTTPRequest associated with the stream.</param>
            <param name="threadSignaler">The <see cref="T:Best.HTTP.Hosts.Connections.IThreadSignaler"/> object to be used for signaling.</param>
            <remarks>Typically called on a separate thread.</remarks>
        </member>
        <member name="T:Best.HTTP.Response.BlockingDownloadContentStream">
            <summary>
            A blocking variant of the <see cref="T:Best.HTTP.Response.DownloadContentStream"/> that allows clients to wait for downloaded data when the buffer is empty but not completed.
            </summary>
            <remarks>
            <para>
            The BlockingDownloadContentStream is a specialized variant of the <see cref="T:Best.HTTP.Response.DownloadContentStream"/> designed to provide a blocking mechanism for clients waiting for downloaded data.
            This class is particularly useful when clients need to read from the stream, but the buffer is temporarily empty due to ongoing downloads.
            </para>
            <para>
            Key Features:
            <list type="bullet">
                <item>
                    <term>Blocking Data Retrieval</term>
                    <description>Provides a blocking <see cref="M:Best.HTTP.Response.BlockingDownloadContentStream.Take"/> method that allows clients to wait for data if the buffer is empty but not yet completed.</description>
                </item>
                <item>
                    <term>Timeout Support</term>
                    <description>The <see cref="M:Best.HTTP.Response.BlockingDownloadContentStream.Take(System.TimeSpan)"/> method accepts a timeout parameter, allowing clients to set a maximum wait time for data availability.</description>
                </item>
                <item>
                    <term>Exception Handling</term>
                    <description>Handles exceptions and errors that occur during download, ensuring that clients receive any relevant exception information.</description>
                </item>
            </list>
            </para>
            <para>
            Clients can use the <see cref="M:Best.HTTP.Response.BlockingDownloadContentStream.Take"/> method to retrieve data from the stream, and if the buffer is empty, the method will block until new data is downloaded or a timeout occurs.
            This blocking behavior is particularly useful in scenarios where clients need to consume data sequentially but can't proceed until data is available.
            </para>
            <para>
            When the download is completed or if an error occurs during download, this stream allows clients to inspect the completion status and any associated exceptions, just like the base <see cref="T:Best.HTTP.Response.DownloadContentStream"/>.
            </para>
            </remarks>
        </member>
        <member name="M:Best.HTTP.Response.BlockingDownloadContentStream.#ctor(Best.HTTP.HTTPResponse,System.Int64,Best.HTTP.Hosts.Connections.IDownloadContentBufferAvailable)">
            <summary>
            Initializes a new instance of the <see cref="T:Best.HTTP.Response.BlockingDownloadContentStream"/> class.
            </summary>
            <param name="response">The HTTP response associated with this download stream.</param>
            <param name="maxBuffered">The maximum size of the internal buffer.</param>
            <param name="bufferAvailableHandler">Handler for notifying when buffer space becomes available.</param>
        </member>
        <member name="M:Best.HTTP.Response.BlockingDownloadContentStream.TryTake(Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment@)">
            <summary>
            Attempts to retrieve a downloaded content-segment from the stream, blocking if necessary until a segment is available.
            </summary>
            <param name="segment">When this method returns, contains the <see cref="T:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment"/> instance representing the data, if available; otherwise, contains the value of <see cref="F:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment.Empty"/>. This parameter is passed uninitialized.</param>
            <returns><c>true</c> if a segment could be retrieved; otherwise, <c>false</c>.</returns>
            <remarks>
            <para>
            The TryTake function provides a blocking approach to retrieve data from the stream.
            If the stream has data available, it immediately returns the data.
            If there's no data available, the method will block until new data is downloaded or the buffer is marked as completed.
            </para>
            <para>
            This method is designed for scenarios where clients need to read from the stream sequentially and are willing to wait until data is available.
            It ensures that clients receive data as soon as it becomes available, without having to repeatedly check or poll the stream.
            </para>
            </remarks>
        </member>
        <member name="M:Best.HTTP.Response.BlockingDownloadContentStream.Take">
            <summary>
            Returns with a download content-segment. If the stream is currently empty but not completed the execution is blocked until new data downloaded.
            A segment is an arbitrary length array of bytes the plugin could read in one operation, it can range from couple of bytes to kilobytes.
            </summary>
            <returns>A BufferSegment holding a reference to the byte[] containing the downloaded data, offset and count of bytes in the array.</returns>
            <exception cref="T:System.ObjectDisposedException">The stream is disposed.</exception>
            <exception cref="T:System.InvalidOperationException">The stream is empty and marked as completed.</exception>
        </member>
        <member name="M:Best.HTTP.Response.BlockingDownloadContentStream.Take(System.TimeSpan)">
            <summary>
            Returns with a download content-segment. If the stream is currently empty but not completed the execution is blocked until new data downloaded or the timeout is reached.
            A segment is an arbitrary length array of bytes the plugin could read in one operation, it can range from couple of bytes to kilobytes.
            </summary>
            <param name="timeout">A TimeSpan that represents the number of milliseconds to wait, or a TimeSpan that represents -1 milliseconds to wait indefinitely.</param>
            <returns>A BufferSegment holding a reference to the byte[] containing the downloaded data, offset and count of bytes in the array. In case of a timeout, BufferSegment.Empty returned.</returns>
            <exception cref="T:System.ObjectDisposedException">The stream is disposed.</exception>
            <exception cref="T:System.InvalidOperationException">The stream is empty and marked as completed.</exception>
        </member>
        <member name="M:Best.HTTP.Response.BlockingDownloadContentStream.Read(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Reads a sequence of bytes from the current stream and advances the position within the stream by the number of bytes read.
            </summary>
            <remarks>
            <para>
            This override of the <see cref="M:Best.HTTP.Response.BlockingDownloadContentStream.Read(System.Byte[],System.Int32,System.Int32)"/> method provides blocking behavior, meaning if there are no bytes available in the stream, the method will block until new data is downloaded or until the stream completes. Once data is available, or if the stream completes, the method will return with the number of bytes read.
            </para>
            <para>
            This behavior ensures that consumers of the stream can continue reading data sequentially, even if the stream's internal buffer is temporarily empty due to ongoing downloads.
            </para>
            </remarks>
            <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values between <paramref name="offset"/> and (<paramref name="offset"/> + <paramref name="count"/> - 1) replaced by the bytes read from the current source.</param>
            <param name="offset">The zero-based byte offset in <paramref name="buffer"/> at which to begin storing the data read from the current stream.</param>
            <param name="count">The maximum number of bytes to be read from the current stream.</param>
            <returns>
            The total number of bytes read into the buffer. This can be less than the number of bytes requested if that many bytes are not currently available, or zero if the end of the stream is reached.
            </returns>
        </member>
        <member name="M:Best.HTTP.Response.BlockingDownloadContentStream.WaitForEvent(System.TimeSpan)">
            <summary>
            Instead of calling WaitOne once for the total duration of the timeout, 
            periodically check whether we are disposed or not.
            </summary>
        </member>
        <member name="T:Best.HTTP.Response.DownloadContentStream">
            <summary>
            A read-only stream that the plugin uses to store the downloaded content. This stream is designed to buffer downloaded data efficiently and provide it to consumers.
            </summary>
            <remarks>
            <para>
            The DownloadContentStream serves as a storage medium for content downloaded during HTTP requests.
            It buffers the downloaded data in segments and allows clients to read from the buffer as needed.
            This buffering mechanism is essential for optimizing download performance, especially in scenarios where the download rate may vary or be faster than the rate at which data is consumed.
            </para>
            <para>
            The stream operates in conjunction with the <see cref="T:Best.HTTP.Hosts.Connections.IDownloadContentBufferAvailable"/> interface, which is used to signal connections when buffer space becomes available.
            Connections can then transfer additional data into the buffer for processing.
            </para>
            <para>
            <list type="bullet">
                <item>
                    <term>Efficient Buffering</term>
                    <description>The stream efficiently buffers downloaded content, ensuring that data is readily available for reading without extensive delays.</description>
                </item>
                <item>
                    <term>Dynamic Resizing</term>
                    <description>The internal buffer dynamically resizes to accommodate varying amounts of downloaded data, optimizing memory usage.</description>
                </item>
                <item>
                    <term>Asynchronous Signal Handling</term>
                    <description>Asynchronous signaling mechanisms are used to notify connections when buffer space is available, enabling efficient data transfer.</description>
                </item>
                <item>
                    <term>Error Handling</term>
                    <description>The stream captures and propagates errors that occur during download, allowing clients to handle exceptions gracefully.</description>
                </item>
                <item>
                    <term>Blocking Variant</term>
                    <description>A blocking variant, <see cref="T:Best.HTTP.Response.BlockingDownloadContentStream"/>, allows clients to wait for data when the buffer is empty but not completed.</description>
                </item>
            </list>
            </para>
            <para>
            Clients can read from this stream using standard stream reading methods, and the stream will release memory segments as data is read.
            When the download is completed or if an error occurs during download, this stream allows clients to inspect the completion status and any associated exceptions.
            </para>
            </remarks>
        </member>
        <member name="P:Best.HTTP.Response.DownloadContentStream.Response">
            <summary>
            Gets the HTTP response from which this download stream originated.
            </summary>
        </member>
        <member name="P:Best.HTTP.Response.DownloadContentStream.IsCompleted">
            <summary>
            Gets a value indicating whether the download is completed, and there's no more data buffered in the stream to read.
            </summary>
        </member>
        <member name="P:Best.HTTP.Response.DownloadContentStream.CompletedWith">
            <summary>
            Gets a reference to an exception if the download completed with an error.
            </summary>
        </member>
        <member name="P:Best.HTTP.Response.DownloadContentStream.Length">
            <summary>
            Gets the length of the buffered data. Because downloads happen in parallel, a <see cref="M:Best.HTTP.Response.DownloadContentStream.Read(System.Byte[],System.Int32,System.Int32)"/> call can return with more data after checking Length.
            </summary>
        </member>
        <member name="P:Best.HTTP.Response.DownloadContentStream.MaxBuffered">
            <summary>
            Gets the maximum size of the internal buffer of this stream.
            </summary>
            <remarks>In some cases, the plugin may put more data into the stream than the specified size.</remarks>
        </member>
        <member name="P:Best.HTTP.Response.DownloadContentStream.IsFull">
            <summary>
            Gets a value indicating whether the internal buffer holds at least the <see cref="P:Best.HTTP.Response.DownloadContentStream.MaxBuffered"/> amount of data.
            </summary>
        </member>
        <member name="P:Best.HTTP.Response.DownloadContentStream.IsDetached">
            <summary>
            Gets or sets whether the stream is detached from the <see cref="T:Best.HTTP.HTTPRequest"/>/<see cref="T:Best.HTTP.HTTPResponse"/> when <see cref="M:Best.HTTP.Response.DownloadContentStream.Read(System.Byte[],System.Int32,System.Int32)"/> is used before the request is finished.
            When the stream is detached from the response object, their lifetimes are not bound together,
            meaning that the stream isn't disposed automatically, and the client code is responsible for calling the stream's <see cref="M:System.IO.Stream.Dispose"/> function.
            </summary>
        </member>
        <member name="M:Best.HTTP.Response.DownloadContentStream.EmergencyIncreaseMaxBuffered">
            <summary>
            There are cases where the plugin have to put more data into the buffer than its previously set maximum.
            For example when the underlying connection is closed, but the content provider still have buffered data,
            in witch case we have to push all processed data to the user facing download stream.
            </summary>
        </member>
        <member name="F:Best.HTTP.Response.DownloadContentStream._isFullCheckCount">
            <summary>
            Count of consecutive calls with DoFullCheck that found the stream fully buffered.
            </summary>
        </member>
        <member name="M:Best.HTTP.Response.DownloadContentStream.#ctor(Best.HTTP.HTTPResponse,System.Int64,Best.HTTP.Hosts.Connections.IDownloadContentBufferAvailable)">
            <summary>
            Initializes a new instance of the DownloadContentStream class.
            </summary>
            <param name="response">The HTTP response associated with this download stream.</param>
            <param name="maxBuffered">The maximum size of the internal buffer.</param>
            <param name="bufferAvailableHandler">Handler for notifying when buffer space becomes available.</param>
        </member>
        <member name="M:Best.HTTP.Response.DownloadContentStream.CompleteAdding(System.Exception)">
            <summary>
            Completes the download stream with an optional error. Called when the download is finished.
            </summary>
            <param name="error">The exception that occurred during download, if any.</param>
        </member>
        <member name="M:Best.HTTP.Response.DownloadContentStream.TryTake(Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment@)">
            <summary>
            Tries to remove a downloaded segment from the stream. If the stream is empty, it returns immediately with false.
            </summary>
            <param name="segment">A <see cref="T:Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment"/> containing the reference to a byte[] and the offset and count of the data in the array.</param>
            <returns><c>true</c> if a downloaded segment was available and could return with, otherwise <c>false</c></returns>
        </member>
        <member name="M:Best.HTTP.Response.DownloadContentStream.Read(System.Byte[],System.Int32,System.Int32)">
            <summary>
            A non-blocking Read function. When it returns <c>0</c>, it doesn't mean the download is complete. If the download interrupted before completing, the next Read call can throw an exception.
            </summary>
            <param name="buffer">The buffer to read data into.</param>
            <param name="offset">The zero-based byte offset in the buffer at which to begin copying bytes.</param>
            <param name="count">The maximum number of bytes to read.</param>
            <returns>The number of bytes copied to the buffer, or zero if no downloaded data is available at the time of the call.</returns>
            <exception cref="T:System.ObjectDisposedException">If the stream is already disposed.</exception>
        </member>
        <member name="M:Best.HTTP.Response.DownloadContentStream.Write(Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment)">
            <summary>
            Writes a downloaded data segment to the stream.
            </summary>
            <param name="segment">The downloaded data segment to write.</param>
        </member>
        <member name="M:Best.HTTP.Response.DownloadContentStream.DoFullCheck(System.Int32)">
            <summary>
            Checks whether the stream is fully buffered and increases a counter if it's full, resetting it otherwise.
            </summary>
            <param name="limit">The limit for the full check counter.</param>
            <returns><c>true</c> if the counter is equal to or larger than the limit parameter; otherwise <c>false</c>.</returns>
        </member>
        <member name="M:Best.HTTP.Response.DownloadContentStream.Dispose(System.Boolean)">
            <summary>
            Disposes of the stream, releasing any resources held by it.
            </summary>
            <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
        </member>
        <member name="T:Best.HTTP.Response.HTTPStatusCodes">
            <summary>
            Provides constants representing various HTTP status codes.
            </summary>
        </member>
        <member name="T:Best.HTTP.HTTPResponse">
            <summary>
            Represents an HTTP response received from a remote server, containing information about the response status, headers, and data.
            </summary>
            <remarks>
            <para>
            The HTTPResponse class represents an HTTP response received from a remote server. It contains information about the response status, headers, and the data content.
            </para>
            <para>
            Key Features:
            <list type="bullet">
                <item>
                    <term>Response Properties</term>
                    <description>Provides access to various properties such as <see cref="P:Best.HTTP.HTTPResponse.HTTPVersion"/>, <see cref="P:Best.HTTP.HTTPResponse.StatusCode"/>, <see cref="P:Best.HTTP.HTTPResponse.Message"/>, and more, to inspect the response details.</description>
                </item>
                <item>
                    <term>Data Access</term>
                    <description>Allows access to the response data in various forms, including raw bytes, UTF-8 text, and as a <see cref="T:UnityEngine.Texture2D"/> for image data.</description>
                </item>
                <item>
                    <term>Header Management</term>
                    <description>Provides methods to add, retrieve, and manipulate HTTP headers associated with the response, making it easy to inspect and work with header information.</description>
                </item>
                <item>
                    <term>Caching Support</term>
                    <description>Supports response caching, enabling the storage of downloaded data in local cache storage for future use.</description>
                </item>
                <item>
                    <term>Stream Management</term>
                    <description>Manages the download process and data streaming through a <see cref="T:Best.HTTP.Response.DownloadContentStream"/> (<see cref="P:Best.HTTP.HTTPResponse.DownStream"/>) to optimize memory usage and ensure efficient handling of large response bodies.</description>
                </item>
            </list>
            </para>
            </remarks>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.HTTPVersion">
            <summary>
            Gets the version of the HTTP protocol with which the response was received. Typically, this is HTTP/1.1 for local file and cache responses, even if the original response received with a different version.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.StatusCode">
            <summary>
            Gets the HTTP status code sent from the server, indicating the outcome of the HTTP request.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.Message">
            <summary>
            Gets the message sent along with the status code from the server. This message can add some details, but it's empty for HTTP/2 responses.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.IsSuccess">
            <summary>
            Gets a value indicating whether the response represents a successful HTTP request. Returns true if the status code is in the range of [200..300[ or 304 (Not Modified).
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.IsFromCache">
            <summary>
            Gets a value indicating whether the response body is read from the cache.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.Headers">
            <summary>
            Gets the headers sent from the server as key-value pairs. You can use additional methods to manage and retrieve header information.
            </summary>
            <remarks>
            The Headers property provides access to the headers sent by the server in the HTTP response. You can use the following methods to work with headers:
            <list type="bullet">
                <item><term><see cref="M:Best.HTTP.HTTPResponse.AddHeader(System.String,System.String)"/> </term><description>Adds an HTTP header with the specified name and value to the response headers.</description></item>
                <item><term><see cref="M:Best.HTTP.HTTPResponse.GetHeaderValues(System.String)"/> </term><description>Retrieves the list of values for a given header name as received from the server.</description></item>
                <item><term><see cref="M:Best.HTTP.HTTPResponse.GetFirstHeaderValue(System.String)"/> </term><description>Retrieves the first value for a given header name as received from the server.</description></item>
                <item><term><see cref="M:Best.HTTP.HTTPResponse.HasHeaderWithValue(System.String,System.String)"/> </term><description>Checks if a header with the specified name and value exists in the response headers.</description></item>
                <item><term><see cref="M:Best.HTTP.HTTPResponse.HasHeader(System.String)"/> </term><description>Checks if a header with the specified name exists in the response headers.</description></item>
                <item><term><see cref="M:Best.HTTP.HTTPResponse.GetRange"/></term><description>Parses the 'Content-Range' header's value and returns a <see cref="T:Best.HTTP.HTTPRange"/> object representing the byte range of the response content.</description></item>
            </list>
            </remarks>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.Data">
            <summary>
            The data that downloaded from the server. All Transfer and Content encodings decoded if any(eg. chunked, gzip, deflate).
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.IsUpgraded">
            <summary>
            The normal HTTP protocol is upgraded to an other.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPResponse.dataAsText">
            <summary>
            Cached, converted data.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.DataAsText">
            <summary>
            The data converted to an UTF8 string.
            </summary>
        </member>
        <member name="F:Best.HTTP.HTTPResponse.texture">
            <summary>
            Cached converted data.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.DataAsTexture2D">
            <summary>
            The data loaded to a Texture2D.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.DownStream">
            <summary>
            Reference to the <see cref="T:Best.HTTP.Response.DownloadContentStream"/> instance that contains the downloaded data.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.Context">
            <summary>
            IProtocol.LoggingContext implementation.
            </summary>
        </member>
        <member name="P:Best.HTTP.HTTPResponse.Request">
            <summary>
            The original request that this response is created for.
            </summary>
        </member>
        <member name="M:Best.HTTP.HTTPResponse.AddHeader(System.String,System.String)">
            <summary>
            Adds an HTTP header with the specified name and value to the response headers.
            </summary>
            <param name="name">The name of the header.</param>
            <param name="value">The value of the header.</param>
        </member>
        <member name="M:Best.HTTP.HTTPResponse.GetHeaderValues(System.String)">
            <summary>
            Retrieves the list of values for a given header name as received from the server.
            </summary>
            <param name="name">The name of the header.</param>
            <returns>
            A list of header values if the header exists and contains values; otherwise, returns <c>null</c>.
            </returns>
        </member>
        <member name="M:Best.HTTP.HTTPResponse.GetFirstHeaderValue(System.String)">
            <summary>
            Retrieves the first value for a given header name as received from the server.
            </summary>
            <param name="name">The name of the header.</param>
            <returns>
            The first header value if the header exists and contains values; otherwise, returns <c>null</c>.
            </returns>
        </member>
        <member name="M:Best.HTTP.HTTPResponse.HasHeaderWithValue(System.String,System.String)">
            <summary>
            Checks if a header with the specified name and value exists in the response headers.
            </summary>
            <param name="headerName">The name of the header to check.</param>
            <param name="value">The value to check for in the header.</param>
            <returns>
            <c>true</c> if a header with the given name and value exists in the response headers; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:Best.HTTP.HTTPResponse.HasHeader(System.String)">
            <summary>
            Checks if a header with the specified name exists in the response headers.
            </summary>
            <param name="headerName">The name of the header to check.</param>
            <returns>
            <c>true</c> if a header with the given name exists in the response headers; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:Best.HTTP.HTTPResponse.GetRange">
            <summary>
            Parses the <c>'Content-Range'</c> header's value and returns a <see cref="T:Best.HTTP.HTTPRange"/> object representing the byte range of the response content.
            </summary>
            <remarks>
            If the server ignores a byte-range-spec because it is syntactically invalid, the server SHOULD treat the request as if the invalid Range header field did not exist.
            (Normally, this means return a 200 response containing the full entity). In this case because there are no <c>'Content-Range'</c> header values, this function will return <c>null</c>.
            </remarks>
            <returns>
            A <see cref="T:Best.HTTP.HTTPRange"/> object representing the byte range of the response content, or <c>null</c> if no '<c>Content-Range</c>' header is found.
            </returns>
        </member>
        <member name="M:Best.HTTP.HTTPResponse.FeedDownloadedContentChunk(Best.HTTP.Shared.PlatformSupport.Memory.BufferSegment)">
            <summary>
            Add data to the fragments list.
            </summary>
            <param name="buffer">The buffer to be added.</param>
            <param name="pos">The position where we start copy the data.</param>
            <param name="length">How many data we want to copy.</param>
        </member>
        <member name="M:Best.HTTP.HTTPResponse.Dispose">
            <summary>
            IDisposable implementation.
            </summary>
        </member>
        <member name="T:Best.HTTP.Futures.FutureState">
            <summary>
            Describes the state of a future.
            </summary>
        </member>
        <member name="F:Best.HTTP.Futures.FutureState.Pending">
            <summary>
            The future hasn't begun to resolve a value.
            </summary>
        </member>
        <member name="F:Best.HTTP.Futures.FutureState.Processing">
            <summary>
            The future is working on resolving a value.
            </summary>
        </member>
        <member name="F:Best.HTTP.Futures.FutureState.Success">
            <summary>
            The future has a value ready.
            </summary>
        </member>
        <member name="F:Best.HTTP.Futures.FutureState.Error">
            <summary>
            The future failed to resolve a value.
            </summary>
        </member>
        <member name="T:Best.HTTP.Futures.IFuture`1">
            <summary>
            Defines the interface of an object that can be used to track a future value.
            </summary>
            <typeparam name="T">The type of object being retrieved.</typeparam>
        </member>
        <member name="P:Best.HTTP.Futures.IFuture`1.state">
            <summary>
            Gets the state of the future.
            </summary>
        </member>
        <member name="P:Best.HTTP.Futures.IFuture`1.value">
            <summary>
            Gets the value if the State is Success.
            </summary>
        </member>
        <member name="P:Best.HTTP.Futures.IFuture`1.error">
            <summary>
            Gets the failure exception if the State is Error.
            </summary>
        </member>
        <member name="M:Best.HTTP.Futures.IFuture`1.OnItem(Best.HTTP.Futures.FutureValueCallback{`0})">
            <summary>
            Adds a new callback to invoke when an intermediate result is known.
            </summary>
            <param name="callback">The callback to invoke.</param>
            <returns>The future so additional calls can be chained together.</returns>
        </member>
        <member name="M:Best.HTTP.Futures.IFuture`1.OnSuccess(Best.HTTP.Futures.FutureValueCallback{`0})">
            <summary>
            Adds a new callback to invoke if the future value is retrieved successfully.
            </summary>
            <param name="callback">The callback to invoke.</param>
            <returns>The future so additional calls can be chained together.</returns>
        </member>
        <member name="M:Best.HTTP.Futures.IFuture`1.OnError(Best.HTTP.Futures.FutureErrorCallback)">
            <summary>
            Adds a new callback to invoke if the future has an error.
            </summary>
            <param name="callback">The callback to invoke.</param>
            <returns>The future so additional calls can be chained together.</returns>
        </member>
        <member name="M:Best.HTTP.Futures.IFuture`1.OnComplete(Best.HTTP.Futures.FutureCallback{`0})">
            <summary>
            Adds a new callback to invoke if the future value is retrieved successfully or has an error.
            </summary>
            <param name="callback">The callback to invoke.</param>
            <returns>The future so additional calls can be chained together.</returns>
        </member>
        <member name="T:Best.HTTP.Futures.FutureCallback`1">
            <summary>
            Defines the signature for callbacks used by the future.
            </summary>
            <param name="future">The future.</param>
        </member>
        <member name="T:Best.HTTP.Futures.Future`1">
            <summary>
            An implementation of <see cref="T:Best.HTTP.Futures.IFuture`1"/> that can be used internally by methods that return futures.
            </summary>
            <remarks>
            Methods should always return the <see cref="T:Best.HTTP.Futures.IFuture`1"/> interface when calling code requests a future.
            This class is intended to be constructed internally in the method to provide a simple implementation of
            the interface. By returning the interface instead of the class it ensures the implementation can change
            later on if requirements change, without affecting the calling code.
            </remarks>
            <typeparam name="T">The type of object being retrieved.</typeparam>
        </member>
        <member name="P:Best.HTTP.Futures.Future`1.state">
            <summary>
            Gets the state of the future.
            </summary>
        </member>
        <member name="P:Best.HTTP.Futures.Future`1.value">
            <summary>
            Gets the value if the State is Success.
            </summary>
        </member>
        <member name="P:Best.HTTP.Futures.Future`1.error">
            <summary>
            Gets the failure exception if the State is Error.
            </summary>
        </member>
        <member name="M:Best.HTTP.Futures.Future`1.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:Best.HTTP.Futures.Future`1"/> class.
            </summary>
        </member>
        <member name="M:Best.HTTP.Futures.Future`1.OnSuccess(Best.HTTP.Futures.FutureValueCallback{`0})">
            <summary>
            Adds a new callback to invoke if the future value is retrieved successfully.
            </summary>
            <param name="callback">The callback to invoke.</param>
            <returns>The future so additional calls can be chained together.</returns>
        </member>
        <member name="M:Best.HTTP.Futures.Future`1.OnError(Best.HTTP.Futures.FutureErrorCallback)">
            <summary>
            Adds a new callback to invoke if the future has an error.
            </summary>
            <param name="callback">The callback to invoke.</param>
            <returns>The future so additional calls can be chained together.</returns>
        </member>
        <member name="M:Best.HTTP.Futures.Future`1.OnComplete(Best.HTTP.Futures.FutureCallback{`0})">
            <summary>
            Adds a new callback to invoke if the future value is retrieved successfully or has an error.
            </summary>
            <param name="callback">The callback to invoke.</param>
            <returns>The future so additional calls can be chained together.</returns>
        </member>
        <member name="M:Best.HTTP.Futures.Future`1.Process(System.Func{`0})">
            <summary>
            Begins running a given function on a background thread to resolve the future's value, as long
            as it is still in the Pending state.
            </summary>
            <param name="func">The function that will retrieve the desired value.</param>
        </member>
        <member name="M:Best.HTTP.Futures.Future`1.Assign(`0)">
            <summary>
            Allows manually assigning a value to a future, as long as it is still in the pending state.
            </summary>
            <remarks>
            There are times where you may not need to do background processing for a value. For example,
            you may have a cache of values and can just hand one out. In those cases you still want to
            return a future for the method signature, but can just call this method to fill in the future.
            </remarks>
            <param name="value">The value to assign the future.</param>
        </member>
        <member name="M:Best.HTTP.Futures.Future`1.Fail(System.Exception)">
            <summary>
            Allows manually failing a future, as long as it is still in the pending state.
            </summary>
            <remarks>
            As with the Assign method, there are times where you may know a future value is a failure without
            doing any background work. In those cases you can simply fail the future manually and return it.
            </remarks>
            <param name="error">The exception to use to fail the future.</param>
        </member>
        <member name="T:PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction">
            <summary>
            This enum describes the action that caused a CollectionChanged event.
            </summary>
        </member>
        <member name="F:PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction.Add">
            <summary> One or more items were added to the collection. </summary>
        </member>
        <member name="F:PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction.Remove">
            <summary> One or more items were removed from the collection. </summary>
        </member>
        <member name="F:PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction.Replace">
            <summary> One or more items were replaced in the collection. </summary>
        </member>
        <member name="F:PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction.Move">
            <summary> One or more items were moved within the collection. </summary>
        </member>
        <member name="F:PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction.Reset">
            <summary> The contents of the collection changed dramatically. </summary>
        </member>
        <member name="T:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs">
            <summary>
            Arguments for the CollectionChanged event.
            A collection that supports INotifyCollectionChangedThis raises this event
            whenever an item is added or removed, or when the contents of the collection
            changes dramatically.
            </summary>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs that describes a reset change.
            </summary>
            <param name="action">The action that caused the event (must be Reset).</param>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction,System.Object)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs that describes a one-item change.
            </summary>
            <param name="action">The action that caused the event; can only be Reset, Add or Remove action.</param>
            <param name="changedItem">The item affected by the change.</param>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction,System.Object,System.Int32)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs that describes a one-item change.
            </summary>
            <param name="action">The action that caused the event.</param>
            <param name="changedItem">The item affected by the change.</param>
            <param name="index">The index where the change occurred.</param>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction,System.Collections.IList)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs that describes a multi-item change.
            </summary>
            <param name="action">The action that caused the event.</param>
            <param name="changedItems">The items affected by the change.</param>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction,System.Collections.IList,System.Int32)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs that describes a multi-item change (or a reset).
            </summary>
            <param name="action">The action that caused the event.</param>
            <param name="changedItems">The items affected by the change.</param>
            <param name="startingIndex">The index where the change occurred.</param>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction,System.Object,System.Object)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs that describes a one-item Replace event.
            </summary>
            <param name="action">Can only be a Replace action.</param>
            <param name="newItem">The new item replacing the original item.</param>
            <param name="oldItem">The original item that is replaced.</param>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction,System.Object,System.Object,System.Int32)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs that describes a one-item Replace event.
            </summary>
            <param name="action">Can only be a Replace action.</param>
            <param name="newItem">The new item replacing the original item.</param>
            <param name="oldItem">The original item that is replaced.</param>
            <param name="index">The index of the item being replaced.</param>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction,System.Collections.IList,System.Collections.IList)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs that describes a multi-item Replace event.
            </summary>
            <param name="action">Can only be a Replace action.</param>
            <param name="newItems">The new items replacing the original items.</param>
            <param name="oldItems">The original items that are replaced.</param>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction,System.Collections.IList,System.Collections.IList,System.Int32)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs that describes a multi-item Replace event.
            </summary>
            <param name="action">Can only be a Replace action.</param>
            <param name="newItems">The new items replacing the original items.</param>
            <param name="oldItems">The original items that are replaced.</param>
            <param name="startingIndex">The starting index of the items being replaced.</param>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction,System.Object,System.Int32,System.Int32)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs that describes a one-item Move event.
            </summary>
            <param name="action">Can only be a Move action.</param>
            <param name="changedItem">The item affected by the change.</param>
            <param name="index">The new index for the changed item.</param>
            <param name="oldIndex">The old index for the changed item.</param>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction,System.Collections.IList,System.Int32,System.Int32)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs that describes a multi-item Move event.
            </summary>
            <param name="action">The action that caused the event.</param>
            <param name="changedItems">The items affected by the change.</param>
            <param name="index">The new index for the changed items.</param>
            <param name="oldIndex">The old index for the changed items.</param>
        </member>
        <member name="M:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.#ctor(PlatformSupport.Collections.Specialized.NotifyCollectionChangedAction,System.Collections.IList,System.Collections.IList,System.Int32,System.Int32)">
            <summary>
            Construct a NotifyCollectionChangedEventArgs with given fields (no validation). Used by WinRT marshaling.
            </summary>
        </member>
        <member name="P:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.Action">
            <summary>
            The action that caused the event.
            </summary>
        </member>
        <member name="P:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.NewItems">
            <summary>
            The items affected by the change.
            </summary>
        </member>
        <member name="P:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.OldItems">
            <summary>
            The old items affected by the change (for Replace events).
            </summary>
        </member>
        <member name="P:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.NewStartingIndex">
            <summary>
            The index where the change occurred.
            </summary>
        </member>
        <member name="P:PlatformSupport.Collections.Specialized.NotifyCollectionChangedEventArgs.OldStartingIndex">
            <summary>
            The old index where the change occurred (for Move events).
            </summary>
        </member>
        <member name="T:UnitySourceGeneratedAssemblyMonoScriptTypes_v1.MonoScriptData">
            <summary>
            Data is UTF-8 encoded strings
            </summary>
        </member>
    </members>
</doc>