using System;
using Vanara.InteropServices;
using static Vanara.PInvoke.Schannel;
using static Vanara.PInvoke.Ws2_32;

namespace Vanara.PInvoke
{
	/// <summary>Items from the WinHTTP.dll.</summary>
	public static partial class WinHTTP
	{
		/// <summary>The default internet HTTP port.</summary>
		public const ushort INTERNET_DEFAULT_HTTP_PORT = 80;

		/// <summary>The default internet HTTPS port.</summary>
		public const ushort INTERNET_DEFAULT_HTTPS_PORT = 443;

		/// <summary>The default internet port for the specified protocol.</summary>
		public const ushort INTERNET_DEFAULT_PORT = 0;

		/// <summary/>
		public const WINHTTP_ADDREQ_FLAG WINHTTP_ADDREQ_FLAGS_MASK = (WINHTTP_ADDREQ_FLAG)0xFFFF0000;

		/// <summary/>
		public const WINHTTP_ADDREQ_FLAG WINHTTP_ADDREQ_INDEX_MASK = (WINHTTP_ADDREQ_FLAG)0x0000FFFF;

		/// <summary>Default value.</summary>
		public const string WINHTTP_HEADER_NAME_BY_INDEX = null;

		/// <summary>Default value.</summary>
		public const string WINHTTP_NO_ADDITIONAL_HEADERS = null;

		/// <summary>Default value.</summary>
		public const string WINHTTP_NO_HEADER_INDEX = null;

		/// <summary>Default value.</summary>
		public const string WINHTTP_NO_OUTPUT_BUFFER = null;

		/// <summary/>
		public const string WINHTTP_NO_PROXY_BYPASS = null;

		/// <summary/>
		public const string WINHTTP_NO_PROXY_NAME = null;

		/// <summary>Default value.</summary>
		public const string WINHTTP_NO_REQUEST_DATA = null;

		/// <summary>The size of a string buffer to recieve a formatted time.</summary>
		public const uint WINHTTP_TIME_FORMAT_BUFSIZE = 62;

		/// <summary>If the following value is returned by WinHttpSetStatusCallback, then probably an invalid (non-code) address was supplied for the callback.</summary>
		public static readonly IntPtr WINHTTP_INVALID_STATUS_CALLBACK = new(-1);

		/// <summary>Return value from an asynchronous Microsoft Windows HTTP Services (WinHTTP) function.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NS:winhttp._WINHTTP_ASYNC_RESULT")]
		public enum ASYNC_RESULT : ulong
		{
			/// <summary>The error occurred during a call to WinHttpReceiveResponse.</summary>
			API_RECEIVE_RESPONSE = 1,

			/// <summary>The error occurred during a call to WinHttpQueryDataAvailable.</summary>
			API_QUERY_DATA_AVAILABLE = 2,

			/// <summary>The error occurred during a call to WinHttpReadData.</summary>
			API_READ_DATA = 3,

			/// <summary>The error occurred during a call to WinHttpWriteData.</summary>
			API_WRITE_DATA = 4,

			/// <summary>The error occurred during a call to WinHttpSendRequest.</summary>
			API_SEND_REQUEST = 5,

			/// <summary>The error occurred during a call to WinHttpGetProxyForUrl.</summary>
			API_GET_PROXY_FOR_URL = 6,
		}

		/// <summary>These constants and corresponding values indicate HTTP status codes returned by servers on the Internet.</summary>
		[PInvokeData("winhttp.h")]
		public enum HTTP_STATUS
		{
			/// <summary>The request can be continued.</summary>
			HTTP_STATUS_CONTINUE = 100,

			/// <summary>The server has switched protocols in an upgrade header.</summary>
			HTTP_STATUS_SWITCH_PROTOCOLS = 101,

			/// <summary>The request completed successfully.</summary>
			HTTP_STATUS_OK = 200,

			/// <summary>The request has been fulfilled and resulted in the creation of a new resource.</summary>
			HTTP_STATUS_CREATED = 201,

			/// <summary>The request has been accepted for processing, but the processing has not been completed.</summary>
			HTTP_STATUS_ACCEPTED = 202,

			/// <summary>The returned meta information in the entity-header is not the definitive set available from the originating server.</summary>
			HTTP_STATUS_PARTIAL = 203,

			/// <summary>The server has fulfilled the request, but there is no new information to send back.</summary>
			HTTP_STATUS_NO_CONTENT = 204,

			/// <summary>
			/// The request has been completed, and the client program should reset the document view that caused the request to be sent to
			/// allow the user to easily initiate another input action.
			/// </summary>
			HTTP_STATUS_RESET_CONTENT = 205,

			/// <summary>The server has fulfilled the partial GET request for the resource.</summary>
			HTTP_STATUS_PARTIAL_CONTENT = 206,

			/// <summary>
			/// During a World Wide Web Distributed Authoring and Versioning (WebDAV) operation, this indicates multiple status codes for a
			/// single response. The response body contains Extensible Markup Language (XML) that describes the status codes. For more
			/// information, see HTTP Extensions for Distributed Authoring.
			/// </summary>
			HTTP_STATUS_WEBDAV_MULTI_STATUS = 207,

			/// <summary>The requested resource is available at one or more locations.</summary>
			HTTP_STATUS_AMBIGUOUS = 300,

			/// <summary>
			/// The requested resource has been assigned to a new permanent Uniform Resource Identifier (URI), and any future references to
			/// this resource should be done using one of the returned URIs.
			/// </summary>
			HTTP_STATUS_MOVED = 301,

			/// <summary>The requested resource resides temporarily under a different URI.</summary>
			HTTP_STATUS_REDIRECT = 302,

			/// <summary>
			/// The response to the request can be found under a different URI and should be retrieved using a GET HTTP verb on that resource.
			/// </summary>
			HTTP_STATUS_REDIRECT_METHOD = 303,

			/// <summary>The requested resource has not been modified.</summary>
			HTTP_STATUS_NOT_MODIFIED = 304,

			/// <summary>The requested resource must be accessed through the proxy given by the location field.</summary>
			HTTP_STATUS_USE_PROXY = 305,

			/// <summary>The redirected request keeps the same HTTP verb. HTTP/1.1 behavior.</summary>
			HTTP_STATUS_REDIRECT_KEEP_VERB = 307,

			/// <summary>The request could not be processed by the server due to invalid syntax.</summary>
			HTTP_STATUS_BAD_REQUEST = 400,

			/// <summary>The requested resource requires user authentication.</summary>
			HTTP_STATUS_DENIED = 401,

			/// <summary>Not implemented in the HTTP protocol.</summary>
			HTTP_STATUS_PAYMENT_REQ = 402,

			/// <summary>The server understood the request, but cannot fulfill it.</summary>
			HTTP_STATUS_FORBIDDEN = 403,

			/// <summary>The server has not found anything that matches the requested URI.</summary>
			HTTP_STATUS_NOT_FOUND = 404,

			/// <summary>The HTTP verb used is not allowed.</summary>
			HTTP_STATUS_BAD_METHOD = 405,

			/// <summary>No responses acceptable to the client were found.</summary>
			HTTP_STATUS_NONE_ACCEPTABLE = 406,

			/// <summary>Proxy authentication required.</summary>
			HTTP_STATUS_PROXY_AUTH_REQ = 407,

			/// <summary>The server timed out waiting for the request.</summary>
			HTTP_STATUS_REQUEST_TIMEOUT = 408,

			/// <summary>
			/// The request could not be completed due to a conflict with the current state of the resource. The user should resubmit with
			/// more information.
			/// </summary>
			HTTP_STATUS_CONFLICT = 409,

			/// <summary>The requested resource is no longer available at the server, and no forwarding address is known.</summary>
			HTTP_STATUS_GONE = 410,

			/// <summary>The server cannot accept the request without a defined content length.</summary>
			HTTP_STATUS_LENGTH_REQUIRED = 411,

			/// <summary>
			/// The precondition given in one or more of the request header fields evaluated to false when it was tested on the server.
			/// </summary>
			HTTP_STATUS_PRECOND_FAILED = 412,

			/// <summary>The server cannot process the request because the request entity is larger than the server is able to process.</summary>
			HTTP_STATUS_REQUEST_TOO_LARGE = 413,

			/// <summary>The server cannot service the request because the request URI is longer than the server can interpret.</summary>
			HTTP_STATUS_URI_TOO_LONG = 414,

			/// <summary>
			/// The server cannot service the request because the entity of the request is in a format not supported by the requested
			/// resource for the requested method.
			/// </summary>
			HTTP_STATUS_UNSUPPORTED_MEDIA = 415,

			/// <summary>The request should be retried after doing the appropriate action.</summary>
			HTTP_STATUS_RETRY_WITH = 449,

			/// <summary>The server encountered an unexpected condition that prevented it from fulfilling the request.</summary>
			HTTP_STATUS_SERVER_ERROR = 500,

			/// <summary>The server does not support the functionality required to fulfill the request.</summary>
			HTTP_STATUS_NOT_SUPPORTED = 501,

			/// <summary>
			/// The server, while acting as a gateway or proxy, received an invalid response from the upstream server it accessed in
			/// attempting to fulfill the request.
			/// </summary>
			HTTP_STATUS_BAD_GATEWAY = 502,

			/// <summary>The service is temporarily overloaded.</summary>
			HTTP_STATUS_SERVICE_UNAVAIL = 503,

			/// <summary>The request was timed out waiting for a gateway.</summary>
			HTTP_STATUS_GATEWAY_TIMEOUT = 504,

			/// <summary>The server does not support the HTTP protocol version that was used in the request message.</summary>
			HTTP_STATUS_VERSION_NOT_SUP = 505,
		}

		/// <summary>Flags that control the operation of this function.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NF:winhttp.WinHttpCreateUrl")]
		[Flags]
		public enum ICU : uint
		{
			/// <summary>Does not convert unsafe characters to escape sequences.</summary>
			ICU_NO_ENCODE = 0x20000000,

			/// <summary>Converts all %XX sequences to characters, including escape sequences, before the URL is parsed.</summary>
			ICU_DECODE = 0x10000000,

			/// <summary>Does not remove meta sequences (such as "." and "..") from the URL.</summary>
			ICU_NO_META = 0x08000000,

			/// <summary>Encodes spaces only.</summary>
			ICU_ENCODE_SPACES_ONLY = 0x04000000,

			/// <summary>
			/// Does not encode or decode characters after "#" or "?", and does not remove trailing white space after "?". If this value is
			/// not specified, the entire URL is encoded and trailing white space is removed.
			/// </summary>
			ICU_BROWSER_MODE = 0x02000000,

			/// <summary>
			/// Encodes any percent signs encountered. By default, percent signs are not encoded. This value is available in Microsoft
			/// Internet Explorer 5 and later.
			/// </summary>
			ICU_ENCODE_PERCENT = 0x00001000,

			/// <summary>
			/// Converts all unsafe characters to their corresponding escape sequences in the path string pointed to by the
			/// <c>lpszUrlPath</c> member and in <c>lpszExtraInfo</c> the extra-information string pointed to by the member of the
			/// URL_COMPONENTS structure pointed to by the <c>lpUrlComponents</c> parameter.
			/// </summary>
			ICU_ESCAPE = 0x80000000,

			/// <summary>
			/// The percent character (%) in the IPv6 literal address must be percent escaped when present in the URI. For example, the scope
			/// ID FE80::2%3, must appear in the URI as "https://[FE80::2%253]/", where %25 is the hex encoded percent character (%). If the
			/// application retrieves the URI from a Unicode API, such as the Winsock WSAAddressToString API, the application must add the
			/// escaped version of the percent character (%) in the hostname of the URI. To create the escaped version of the URI,
			/// applications call InternetCreateUrl with the dwFlags parameter set to ICU_ESCAPE_AUTHORITY, and the IPv6 hostname specified
			/// in the URL components structure specified in the lpUrlComponents parameter.
			/// </summary>
			ICU_ESCAPE_AUTHORITY = 0x00002000,

			/// <summary>
			/// Rejects URLs as input that contains either a username, or a password, or both. If the function fails because of an invalid
			/// URL, subsequent calls to GetLastError will return ERROR_WINHTTP_INVALID_URL.
			/// </summary>
			ICU_REJECT_USERPWD = 0x00004000,
		}

		/// <summary>Internet schemes supported by WinHTTP.</summary>
		[PInvokeData("winhttp.h")]
		public enum INTERNET_SCHEME
		{
			/// <summary>An HTTP internet scheme.</summary>
			INTERNET_SCHEME_HTTP = 1,

			/// <summary>An HTTPS (SSL) internet scheme.</summary>
			INTERNET_SCHEME_HTTPS = 2,

			/// <summary>An FTP internet scheme. This scheme is only supported for use in WinHttpGetProxyForUrl and WinHttpGetProxyForUrlEx.</summary>
			INTERNET_SCHEME_FTP = 3,

			/// <summary>A SOCKS internet scheme. This scheme is only supported for use in WINHTTP_PROXY_RESULT_ENTRY.</summary>
			INTERNET_SCHEME_SOCKS = 4,
		}

		/// <summary>Contains the security flags for a handle.</summary>
		[PInvokeData("winhttp.h")]
		[Flags]
		public enum SECURITY_FLAG : uint
		{
			/// <summary>Uses secure transfers. This is only returned in a call to WinHttpQueryOption.</summary>
			SECURITY_FLAG_SECURE = 0x00000001,

			/// <summary>Uses weak (40-bit) encryption. This is only returned in a call to WinHttpQueryOption.</summary>
			SECURITY_FLAG_STRENGTH_WEAK = 0x10000000,

			/// <summary>Uses medium (56-bit) encryption. This is only returned in a call to WinHttpQueryOption.</summary>
			SECURITY_FLAG_STRENGTH_MEDIUM = 0x40000000,

			/// <summary>Uses strong (128-bit) encryption. This is only returned in a call to WinHttpQueryOption.</summary>
			SECURITY_FLAG_STRENGTH_STRONG = 0x20000000,

			/// <summary>
			/// Allows an invalid certificate authority. If this flag is set, the application does not receive a
			/// WINHTTP_CALLBACK_STATUS_FLAG_INVALID_CA callback.
			/// </summary>
			SECURITY_FLAG_IGNORE_UNKNOWN_CA = 0x00000100,

			/// <summary>
			/// Allows an invalid certificate date, that is, an expired or not-yet-effective certificate. If this flag is set, the
			/// application does not receive a WINHTTP_CALLBACK_STATUS_FLAG_CERT_DATE_INVALID callback.
			/// </summary>
			SECURITY_FLAG_IGNORE_CERT_DATE_INVALID = 0x00002000,

			/// <summary>
			/// Allows an invalid common name in a certificate; that is, the server name specified by the application does not match the
			/// common name in the certificate. If this flag is set, the application does not receive a
			/// WINHTTP_CALLBACK_STATUS_FLAG_CERT_CN_INVALID callback.
			/// </summary>
			SECURITY_FLAG_IGNORE_CERT_CN_INVALID = 0x00001000,

			/// <summary>Allows the identity of a server to be established with a non-server certificate (for example, a client certificate).</summary>
			SECURITY_FLAG_IGNORE_CERT_WRONG_USAGE = 0x00000200,

			/// <summary>
			/// Allows a weak signature to be ignored. This flag is available in the rollup update for each OS starting with Windows 7 and
			/// Windows Server 2008 R2.
			/// </summary>
			SECURITY_FLAG_IGNORE_ALL_CERT_ERRORS = SECURITY_FLAG_IGNORE_UNKNOWN_CA | SECURITY_FLAG_IGNORE_CERT_DATE_INVALID | SECURITY_FLAG_IGNORE_CERT_CN_INVALID | SECURITY_FLAG_IGNORE_CERT_WRONG_USAGE
		}

		/// <summary>The access type.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NS:winhttp._WINHTTP_PROXY_INFO")]
		public enum WINHTTP_ACCESS_TYPE : uint
		{
			/// <summary>Applies only when setting proxy information.</summary>
			WINHTTP_ACCESS_TYPE_DEFAULT_PROXY = 0,

			/// <summary>Internet accessed through a direct connection.</summary>
			WINHTTP_ACCESS_TYPE_NO_PROXY = 1,

			/// <summary>Internet accessed using a proxy.</summary>
			WINHTTP_ACCESS_TYPE_NAMED_PROXY = 3,

			/// <summary>Internet accessed using an automatic proxy.</summary>
			WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY = 4,
		}

		/// <summary>contains the flags used to modify the semantics of this function.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NF:winhttp.WinHttpAddRequestHeaders")]
		[Flags]
		public enum WINHTTP_ADDREQ_FLAG : uint
		{
			/// <summary>Adds the header only if it does not already exist; otherwise, an error is returned.</summary>
			WINHTTP_ADDREQ_FLAG_ADD_IF_NEW = 0x10000000,

			/// <summary>Adds the header if it does not exist. Used with <c>WINHTTP_ADDREQ_FLAG_REPLACE</c>.</summary>
			WINHTTP_ADDREQ_FLAG_ADD = 0x20000000,

			/// <summary>
			/// Merges headers of the same name using a comma. For example, adding "Accept: text/*" followed by "Accept: audio/*" with this
			/// flag results in a single header "Accept: text/*, audio/*". This causes the first header found to be merged. The calling
			/// application must to ensure a cohesive scheme with respect to merged and separate headers.
			/// </summary>
			WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA = 0x40000000,

			/// <summary>Merges headers of the same name using a semicolon.</summary>
			WINHTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON = 0x01000000,

			/// <summary>Merges headers of the same name.</summary>
			WINHTTP_ADDREQ_FLAG_COALESCE = WINHTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA,

			/// <summary>
			/// Replaces or removes a header. If the header value is empty and the header is found, it is removed. If the value is not empty,
			/// it is replaced.
			/// </summary>
			WINHTTP_ADDREQ_FLAG_REPLACE = 0x80000000,
		}

		/// <summary>A flag that contains the authentication scheme.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NS:winhttp.tagWINHTTP_CREDS")]
		[Flags]
		public enum WINHTTP_AUTH_SCHEME : uint
		{
			/// <term>Use basic authentication.</term>
			WINHTTP_AUTH_SCHEME_BASIC = 0x00000001,

			/// <term>Use NTLM authentication.</term>
			WINHTTP_AUTH_SCHEME_NTLM = 0x00000002,

			/// <summary>Indicates passport authentication is available.</summary>
			WINHTTP_AUTH_SCHEME_PASSPORT = 0x00000004,

			/// <term>Use digest authentication.</term>
			WINHTTP_AUTH_SCHEME_DIGEST = 0x00000008,

			/// <term>Select between NTLM and Kerberos authentication.</term>
			WINHTTP_AUTH_SCHEME_NEGOTIATE = 0x00000010,
		}

		/// <summary>Specifies a flag that contains the authentication target.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NF:winhttp.WinHttpQueryAuthSchemes")]
		[Flags]
		public enum WINHTTP_AUTH_TARGET : uint
		{
			/// <summary>Authentication target is a server. Indicates that a 401 status code has been received.</summary>
			WINHTTP_AUTH_TARGET_SERVER = 0x00000000,

			/// <summary>Authentication target is a proxy. Indicates that a 407 status code has been received.</summary>
			WINHTTP_AUTH_TARGET_PROXY = 0x00000001,
		}

		/// <summary>Specifies what protocols are to be used to locate the PAC file.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NS:winhttp._WINHTTP_AUTOPROXY_OPTIONS")]
		[Flags]
		public enum WINHTTP_AUTO_DETECT_TYPE : uint
		{
			/// <summary>Use DHCP to locate the proxy auto-configuration file.</summary>
			WINHTTP_AUTO_DETECT_TYPE_DHCP = 0x00000001,

			/// <summary>
			/// Use DNS to attempt to locate the proxy auto-configuration file at a well-known location on the domain of the local computer.
			/// </summary>
			WINHTTP_AUTO_DETECT_TYPE_DNS_A = 0x00000002,
		}

		/// <summary>Values for WINHTTP_OPTION_AUTOLOGON_POLICY.</summary>
		[PInvokeData("winhttp.h")]
		public enum WINHTTP_AUTOLOGON_SECURITY_LEVEL : uint
		{
			/// <summary>WINHTTP_AUTOLOGON_SECURITY_LEVEL_MEDIUM</summary>
			WINHTTP_AUTOLOGON_SECURITY_LEVEL_DEFAULT = WINHTTP_AUTOLOGON_SECURITY_LEVEL_MEDIUM,

			/// <summary>An authenticated log on using the default credentials is performed only for requests on the local Intranet.</summary>
			WINHTTP_AUTOLOGON_SECURITY_LEVEL_MEDIUM = 0,

			/// <summary>An authenticated log on using the default credentials is performed for all requests.</summary>
			WINHTTP_AUTOLOGON_SECURITY_LEVEL_LOW = 1,

			/// <summary>
			/// Default credentials are not used. Note that this flag takes effect only if you specify the server by the actual machine name.
			/// It will not take effect, if you specify the server by "localhost" or IP address.
			/// </summary>
			WINHTTP_AUTOLOGON_SECURITY_LEVEL_HIGH = 2,
		}

		/// <summary>Mechanisms should be used to obtain the PAC file.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NS:winhttp._WINHTTP_AUTOPROXY_OPTIONS")]
		[Flags]
		public enum WINHTTP_AUTOPROXY : uint
		{
			/// <summary>Attempt to automatically discover the URL of the PAC file using both DHCP and DNS queries to the local network.</summary>
			WINHTTP_AUTOPROXY_AUTO_DETECT = 0x00000001,

			/// <summary>
			/// Download the PAC file from the URL specified by <c>lpszAutoConfigUrl</c> in the <c>WINHTTP_AUTOPROXY_OPTIONS</c> structure.
			/// </summary>
			WINHTTP_AUTOPROXY_CONFIG_URL = 0x00000002,

			/// <summary>Maintains the case of the hostnames passed to the PAC script. This is the default behavior.</summary>
			WINHTTP_AUTOPROXY_HOST_KEEPCASE = 0x00000004,

			/// <summary>Converts hostnames to lowercase before passing them to the PAC script.</summary>
			WINHTTP_AUTOPROXY_HOST_LOWERCASE = 0x00000008,

			/// <summary>Enables proxy detection via autoconfig URL.</summary>
			WINHTTP_AUTOPROXY_ALLOW_AUTOCONFIG = 0x00000100,

			/// <summary>Enables proxy detection via static configuration.</summary>
			WINHTTP_AUTOPROXY_ALLOW_STATIC = 0x00000200,

			/// <summary>Enables proxy detection via connection manager.</summary>
			WINHTTP_AUTOPROXY_ALLOW_CM = 0x00000400,

			/// <summary>
			/// Executes the Web Proxy Auto-Discovery (WPAD) protocol in-process instead of delegating to an out-of-process WinHTTP AutoProxy
			/// Service, if available. This flag must be combined with one of the other flags. This option has no effect when passed to WinHttpGetProxyForUrlEx.
			/// </summary>
			WINHTTP_AUTOPROXY_RUN_INPROCESS = 0x00010000,

			/// <summary>
			/// By default, WinHTTP is configured to fall back to auto-discover a proxy in-process. If this fallback behavior is undesirable
			/// in the event that an out-of-process discovery fails, it can be disabled using this flag. This option has no effect when
			/// passed to WinHttpGetProxyForUrlEx.
			/// </summary>
			WINHTTP_AUTOPROXY_RUN_OUTPROCESS_ONLY = 0x00020000,

			/// <summary>Disables querying Direct Access proxy settings for this request.</summary>
			WINHTTP_AUTOPROXY_NO_DIRECTACCESS = 0x00040000,

			/// <summary>Disables querying a host to proxy cache of script execution results in the current process.</summary>
			WINHTTP_AUTOPROXY_NO_CACHE_CLIENT = 0x00080000,

			/// <summary>Disables querying a host to proxy cache of script execution results in the autoproxy service.</summary>
			WINHTTP_AUTOPROXY_NO_CACHE_SVC = 0x00100000,

			/// <summary>Orders the proxy results based on a heuristic placing the fastest proxies first.</summary>
			WINHTTP_AUTOPROXY_SORT_RESULTS = 0x00400000,
		}

		/// <summary>Specifies flags to indicate which events activate the callback function.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NF:winhttp.WinHttpSetStatusCallback")]
		[Flags]
		public enum WINHTTP_CALLBACK_FLAG : uint
		{
			/// <summary>Activates upon beginning and completing name resolution.</summary>
			WINHTTP_CALLBACK_FLAG_RESOLVE_NAME = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_RESOLVING_NAME | WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_NAME_RESOLVED,

			/// <summary>Activates upon beginning and completing connection to the server.</summary>
			WINHTTP_CALLBACK_FLAG_CONNECT_TO_SERVER = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER | WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER,

			/// <summary>Activates upon beginning and completing the sending of a request header with WinHttpSendRequest.</summary>
			WINHTTP_CALLBACK_FLAG_SEND_REQUEST = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_SENDING_REQUEST | WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_REQUEST_SENT,

			/// <summary>Activates upon beginning and completing the receipt of a resource from the HTTP server.</summary>
			WINHTTP_CALLBACK_FLAG_RECEIVE_RESPONSE = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE | WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED,

			/// <summary>Activates when beginning and completing the closing of an HTTP connection.</summary>
			WINHTTP_CALLBACK_FLAG_CLOSE_CONNECTION = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION | WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED,

			/// <summary>Activates when an HINTERNET handle is created or closed.</summary>
			WINHTTP_CALLBACK_FLAG_HANDLES = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_HANDLE_CREATED | WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING,

			/// <summary>Activates when detecting the proxy server.</summary>
			WINHTTP_CALLBACK_FLAG_DETECTING_PROXY = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_DETECTING_PROXY,

			/// <summary>Activates when the request is redirected.</summary>
			WINHTTP_CALLBACK_FLAG_REDIRECT = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_REDIRECT,

			/// <summary>Activates when receiving an intermediate (100 level) status code message from the server.</summary>
			WINHTTP_CALLBACK_FLAG_INTERMEDIATE_RESPONSE = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_INTERMEDIATE_RESPONSE,

			/// <summary>Activates upon a secure connection failure.</summary>
			WINHTTP_CALLBACK_FLAG_SECURE_FAILURE = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_SECURE_FAILURE,

			/// <summary>Activates when a request header has been sent with WinHttpSendRequest.</summary>
			WINHTTP_CALLBACK_FLAG_SENDREQUEST_COMPLETE = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE,

			/// <summary>Activates when the response headers are available for retrieval.</summary>
			WINHTTP_CALLBACK_FLAG_HEADERS_AVAILABLE = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE,

			/// <summary>Activates when completing a query for data.</summary>
			WINHTTP_CALLBACK_FLAG_DATA_AVAILABLE = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE,

			/// <summary>Activates upon completion of a data-read operation.</summary>
			WINHTTP_CALLBACK_FLAG_READ_COMPLETE = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_READ_COMPLETE,

			/// <summary>Activates upon completion of a data-post operation.</summary>
			WINHTTP_CALLBACK_FLAG_WRITE_COMPLETE = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE,

			/// <summary>Activates when an asynchronous error occurs.</summary>
			WINHTTP_CALLBACK_FLAG_REQUEST_ERROR = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_REQUEST_ERROR,

			/// <summary/>
			WINHTTP_CALLBACK_FLAG_GETPROXYFORURL_COMPLETE = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_GETPROXYFORURL_COMPLETE,

			/// <summary>
			/// Activates upon any completion notification. This flag specifies that all notifications required for read or write operations
			/// are used. See WINHTTP_STATUS_CALLBACK for a list of completions.
			/// </summary>
			WINHTTP_CALLBACK_FLAG_ALL_COMPLETIONS = WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE |
				WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE | WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE |
				WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_READ_COMPLETE | WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE |
				WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_REQUEST_ERROR | WINHTTP_CALLBACK_STATUS.WINHTTP_CALLBACK_STATUS_GETPROXYFORURL_COMPLETE,

			/// <summary>
			/// Activates upon any status change notification including completions. See WINHTTP_STATUS_CALLBACK for a list of notifications.
			/// </summary>
			WINHTTP_CALLBACK_FLAG_ALL_NOTIFICATIONS = 0xffffffff,
		}

		/// <summary>Specifies the status code that indicates why the callback function is called.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NC:winhttp.WINHTTP_STATUS_CALLBACK")]
		[Flags]
		public enum WINHTTP_CALLBACK_STATUS : uint
		{
			/// <summary>The connection was successfully closed via a call to WinHttpWebSocketClose.</summary>
			WINHTTP_CALLBACK_STATUS_CLOSE_COMPLETE = 0x02000000,

			/// <summary>Closing the connection to the server. The <c>lpvStatusInformation</c> parameter is <c>NULL</c>.</summary>
			WINHTTP_CALLBACK_STATUS_CLOSING_CONNECTION = 0x00000100,

			/// <summary>
			/// Successfully connected to the server. The <c>lpvStatusInformation</c> parameter contains a pointer to an <c>LPWSTR</c> that
			/// indicates the IP address of the server in dotted notation.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_CONNECTED_TO_SERVER = 0x00000008,

			/// <summary>
			/// Connecting to the server. The <c>lpvStatusInformation</c> parameter contains a pointer to an <c>LPWSTR</c> that indicates the
			/// IP address of the server in dotted notation.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_CONNECTING_TO_SERVER = 0x00000004,

			/// <summary>Successfully closed the connection to the server. The <c>lpvStatusInformation</c> parameter is <c>NULL</c>.</summary>
			WINHTTP_CALLBACK_STATUS_CONNECTION_CLOSED = 0x00000200,

			/// <summary>
			/// Data is available to be retrieved with WinHttpReadData. The <c>lpvStatusInformation</c> parameter points to a <c>DWORD</c>
			/// that contains the number of bytes of data available. The <c>dwStatusInformationLength</c> parameter itself is 4 (the size of
			/// a <c>DWORD</c>).
			/// </summary>
			WINHTTP_CALLBACK_STATUS_DATA_AVAILABLE = 0x00040000,

			/// <summary>Not implemented.</summary>
			WINHTTP_CALLBACK_STATUS_DETECTING_PROXY = 0x00001000,

			/// <summary>
			/// The operation initiated by a call to WinHttpGetProxyForUrlEx is complete. Data is available to be retrieved with WinHttpReadData.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_GETPROXYFORURL_COMPLETE = 0x01000000,

			/// <summary>
			/// This handle value has been terminated. The <c>lpvStatusInformation</c> parameter contains a pointer to the HINTERNET handle.
			/// There will be no more callbacks for this handle.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_HANDLE_CLOSING = 0x00000800,

			/// <summary>
			/// An HINTERNET handle has been created. The <c>lpvStatusInformation</c> parameter contains a pointer to the HINTERNET handle.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_HANDLE_CREATED = 0x00000400,

			/// <summary>
			/// The response header has been received and is available with WinHttpQueryHeaders. The <c>lpvStatusInformation</c> parameter is <c>NULL</c>.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_HEADERS_AVAILABLE = 0x00020000,

			/// <summary>
			/// Received an intermediate (100 level) status code message from the server. The <c>lpvStatusInformation</c> parameter contains
			/// a pointer to a <c>DWORD</c> that indicates the status code.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_INTERMEDIATE_RESPONSE = 0x00008000,

			/// <summary>
			/// Successfully found the IP address of the server. The <c>lpvStatusInformation</c> parameter contains a pointer to a
			/// <c>LPWSTR</c> that indicates the name that was resolved.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_NAME_RESOLVED = 0x00000002,

			/// <summary>
			/// <para>
			/// Data was successfully read from the server. The <c>lpvStatusInformation</c> parameter contains a pointer to the buffer
			/// specified in the call to WinHttpReadData. The <c>dwStatusInformationLength</c> parameter contains the number of bytes read.
			/// </para>
			/// <para>
			/// When used by WinHttpWebSocketReceive, the <c>lpvStatusInformation</c> parameter contains a pointer to a
			/// WINHTTP_WEB_SOCKET_STATUS structure, and the <c>dwStatusInformationLength</c> parameter indicates the size of <c>lpvStatusInformation</c>.
			/// </para>
			/// </summary>
			WINHTTP_CALLBACK_STATUS_READ_COMPLETE = 0x00080000,

			/// <summary>Waiting for the server to respond to a request. The <c>lpvStatusInformation</c> parameter is <c>NULL</c>.</summary>
			WINHTTP_CALLBACK_STATUS_RECEIVING_RESPONSE = 0x00000040,

			/// <summary>
			/// An HTTP request is about to automatically redirect the request. The <c>lpvStatusInformation</c> parameter contains a pointer
			/// to an <c>LPWSTR</c> indicating the new URL. At this point, the application can read any data returned by the server with the
			/// redirect response and can query the response headers. It can also cancel the operation by closing the handle.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_REDIRECT = 0x00004000,

			/// <summary>
			/// An error occurred while sending an HTTP request. The <c>lpvStatusInformation</c> parameter contains a pointer to a
			/// WINHTTP_ASYNC_RESULT structure. Its <c>dwResult</c> member indicates the ID of the called function and <c>dwError</c>
			/// indicates the return value.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_REQUEST_ERROR = 0x00200000,

			/// <summary>
			/// Successfully sent the information request to the server. The <c>lpvStatusInformation</c> parameter contains a pointer to a
			/// <c>DWORD</c> indicating the number of bytes sent.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_REQUEST_SENT = 0x00000020,

			/// <summary>
			/// Looking up the IP address of a server name. The <c>lpvStatusInformation</c> parameter contains a pointer to the server name
			/// being resolved.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_RESOLVING_NAME = 0x00000001,

			/// <summary>
			/// Successfully received a response from the server. The <c>lpvStatusInformation</c> parameter contains a pointer to a
			/// <c>DWORD</c> indicating the number of bytes received.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_RESPONSE_RECEIVED = 0x00000080,

			/// <summary>
			/// One or more errors were encountered while retrieving a Secure Sockets Layer (SSL) certificate from the server. The
			/// <c>lpvStatusInformation</c> parameter contains a flag. For more information, see the description for <c>lpvStatusInformation</c>.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_SECURE_FAILURE = 0x00010000,

			/// <summary>Sending the information request to the server. The <c>lpvStatusInformation</c> parameter is <c>NULL</c>.</summary>
			WINHTTP_CALLBACK_STATUS_SENDING_REQUEST = 0x00000010,

			/// <summary>The request completed successfully. The <c>lpvStatusInformation</c> parameter is <c>NULL</c>.</summary>
			WINHTTP_CALLBACK_STATUS_SENDREQUEST_COMPLETE = 0x00400000,

			/// <summary/>
			WINHTTP_CALLBACK_STATUS_SETTINGS_READ_COMPLETE = 0x20000000,

			/// <summary/>
			WINHTTP_CALLBACK_STATUS_SETTINGS_WRITE_COMPLETE = 0x10000000,

			/// <summary>The connection was successfully shut down via a call to WinHttpWebSocketShutdown.</summary>
			WINHTTP_CALLBACK_STATUS_SHUTDOWN_COMPLETE = 0x04000000,

			/// <summary>
			/// <para>
			/// Data was successfully written to the server. The <c>lpvStatusInformation</c> parameter contains a pointer to a <c>DWORD</c>
			/// that indicates the number of bytes written.
			/// </para>
			/// <para>
			/// When used by WinHttpWebSocketSend, the <c>lpvStatusInformation</c> parameter contains a pointer to a
			/// WINHTTP_WEB_SOCKET_STATUS structure, and the <c>dwStatusInformationLength</c> parameter indicates the size of <c>lpvStatusInformation</c>.
			/// </para>
			/// </summary>
			WINHTTP_CALLBACK_STATUS_WRITE_COMPLETE = 0x00100000,
		}

		/// <summary>
		/// If the <c>dwInternetStatus</c> argument is WINHTTP_CALLBACK_STATUS_SECURE_FAILURE, then <c>lpvStatusInformation</c> points to a
		/// DWORD which is a bitwise-OR combination of one or more of the following values.
		/// </summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NC:winhttp.WINHTTP_STATUS_CALLBACK")]
		[Flags]
		public enum WINHTTP_CALLBACK_STATUS_FLAG : uint
		{
			/// <summary>
			/// Certification revocation checking has been enabled, but the revocation check failed to verify whether a certificate has been
			/// revoked. The server used to check for revocation might be unreachable.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_FLAG_CERT_REV_FAILED = 0x00000001,

			/// <summary>SSL certificate is invalid.</summary>
			WINHTTP_CALLBACK_STATUS_FLAG_INVALID_CERT = 0x00000002,

			/// <summary>SSL certificate was revoked.</summary>
			WINHTTP_CALLBACK_STATUS_FLAG_CERT_REVOKED = 0x00000004,

			/// <summary>The function is unfamiliar with the Certificate Authority that generated the server's certificate.</summary>
			WINHTTP_CALLBACK_STATUS_FLAG_INVALID_CA = 0x00000008,

			/// <summary>
			/// SSL certificate common name (host name field) is incorrect, for example, if you entered www.microsoft.com and the common name
			/// on the certificate says www.msn.com.
			/// </summary>
			WINHTTP_CALLBACK_STATUS_FLAG_CERT_CN_INVALID = 0x00000010,

			/// <summary>SSL certificate date that was received from the server is bad. The certificate is expired.</summary>
			WINHTTP_CALLBACK_STATUS_FLAG_CERT_DATE_INVALID = 0x00000020,

			/// <summary/>
			WINHTTP_CALLBACK_STATUS_FLAG_CERT_WRONG_USAGE = 0x00000040,

			/// <summary>The application experienced an internal error loading the SSL libraries.</summary>
			WINHTTP_CALLBACK_STATUS_FLAG_SECURITY_CHANNEL_ERROR = 0x80000000,
		}

		/// <summary>Flags which determine whether WinHTTP will automatically decompress response bodies with compressed Content-Encodings.</summary>
		[PInvokeData("winhttp.h")]
		[Flags]
		public enum WINHTTP_DECOMPRESSION_FLAG : uint
		{
			/// <summary>Decompress Content-Encoding: gzip responses.</summary>
			WINHTTP_DECOMPRESSION_FLAG_GZIP = 0x00000001,

			/// <summary>Decompress Content-Encoding: deflate responses.</summary>
			WINHTTP_DECOMPRESSION_FLAG_DEFLATE = 0x00000002,

			/// <summary>Decompress responses with any supported Content-Encoding.</summary>
			WINHTTP_DECOMPRESSION_FLAG_ALL = WINHTTP_DECOMPRESSION_FLAG_GZIP | WINHTTP_DECOMPRESSION_FLAG_DEFLATE
		}

		/// <summary>Specifies which features are disabled.</summary>
		[PInvokeData("winhttp.h")]
		[Flags]
		public enum WINHTTP_DISABLE : uint
		{
			/// <summary>
			/// Automatic addition of cookie headers to requests is disabled. Also, returned cookies are not automatically added to the
			/// cookie database. Disabling cookies can result in poor performance for Passport authentication.
			/// </summary>
			WINHTTP_DISABLE_COOKIES = 0x00000001,

			/// <summary>
			/// Automatic redirection is disabled when sending requests with WinHttpSendRequest. If automatic redirection is disabled, an
			/// application must register a callback function in order for Passport authentication to succeed.
			/// </summary>
			WINHTTP_DISABLE_REDIRECTS = 0x00000002,

			/// <summary>Automatic authentication is disabled.</summary>
			WINHTTP_DISABLE_AUTHENTICATION = 0x00000004,

			/// <summary>
			/// Disables keep-alive semantics for the connection. Keep-alive semantics are required for MSN, NTLM, and other types of authentication.
			/// </summary>
			WINHTTP_DISABLE_KEEP_ALIVE = 0x00000008,
		}

		/// <summary>Specifies whether Passport Authentication in WinHTTP authentication is enabled.</summary>
		[PInvokeData("winhttp.h")]
		[Flags]
		public enum WINHTTP_DISABLE_PASSPORT : uint
		{
			/// <summary>Microsoft Passport authentication is disabled. This is the default.</summary>
			WINHTTP_DISABLE_PASSPORT_AUTH = 0x00000000,

			/// <summary>Passport authentication is enabled.</summary>
			WINHTTP_ENABLE_PASSPORT_AUTH = 0x10000000,

			/// <summary>The Passport keyring is disabled. This is the default.</summary>
			WINHTTP_DISABLE_PASSPORT_KEYRING = 0x20000000,

			/// <summary>The Passport keyring is enabled.</summary>
			WINHTTP_ENABLE_PASSPORT_KEYRING = 0x40000000,
		}

		/// <summary>Specifies the features currently enabled.</summary>
		[PInvokeData("winhttp.h")]
		[Flags]
		public enum WINHTTP_ENABLE_SSL : uint
		{
			/// <summary>If enabled, WinHTTP allows SSL revocation. This value can be set only on the request handle.</summary>
			WINHTTP_ENABLE_SSL_REVOCATION = 0x00000001,

			/// <summary>
			/// If enabled, WinHTTP temporarily reverts client impersonation for the duration of SSL certificate authentication operations.
			/// This value can be set only on the session handle.
			/// </summary>
			WINHTTP_ENABLE_SSL_REVERT_IMPERSONATION = 0x00000002,
		}

		/// <summary>Flags for WinHttpAddRequestHeadersEx.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NF:winhttp.WinHttpAddRequestHeadersEx")]
		[Flags]
		public enum WINHTTP_EXTENDED_HEADER_FLAG : ulong
		{
			/// <summary>Indicate that the strings passed in are Unicode strings.</summary>
			WINHTTP_EXTENDED_HEADER_FLAG_UNICODE = 1
		}

		/// <summary>Specifies which secure protocols are acceptable.</summary>
		[PInvokeData("winhttp.h")]
		[Flags]
		public enum WINHTTP_FLAG_SECURE_PROTOCOL : uint
		{
			/// <summary>The SSL 2.0 protocol can be used.</summary>
			WINHTTP_FLAG_SECURE_PROTOCOL_SSL2 = 0x00000008,

			/// <summary>The SSL 3.0 protocol can be used.</summary>
			WINHTTP_FLAG_SECURE_PROTOCOL_SSL3 = 0x00000020,

			/// <summary>The TLS 1.0 protocol can be used.</summary>
			WINHTTP_FLAG_SECURE_PROTOCOL_TLS1 = 0x00000080,

			/// <summary>The TLS 1.1 protocol can be used.</summary>
			WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_1 = 0x00000200,

			/// <summary>The TLS 1.2 protocol can be used.</summary>
			WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_2 = 0x00000800,

			/// <summary>The TLS 1.3 protocol can be used.</summary>
			WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_3 = 0x00002000,

			/// <summary>The Secure Sockets Layer (SSL) 2.0, SSL 3.0, and Transport Layer Security (TLS) 1.0 protocols can be used.</summary>
			WINHTTP_FLAG_SECURE_PROTOCOL_ALL = WINHTTP_FLAG_SECURE_PROTOCOL_SSL2 | WINHTTP_FLAG_SECURE_PROTOCOL_SSL3 | WINHTTP_FLAG_SECURE_PROTOCOL_TLS1,
		}

		/// <summary>The type of the HINTERNET handle passed in.</summary>
		[PInvokeData("winhttp.h")]
		public enum WINHTTP_HANDLE_TYPE : uint
		{
			/// <summary>The handle is a session handle.</summary>
			WINHTTP_HANDLE_TYPE_SESSION = 1,

			/// <summary>The handle is a connection handle.</summary>
			WINHTTP_HANDLE_TYPE_CONNECT = 2,

			/// <summary>The handle is a request handle.</summary>
			WINHTTP_HANDLE_TYPE_REQUEST = 3,
		}

		/// <summary>Flags for WINHTTP_MATCH_CONNECTION_GUID.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NS:winhttp._WINHTTP_MATCH_CONNECTION_GUID")]
		[Flags]
		public enum WINHTTP_MATCH_CONNECTION_GUID_FLAG : ulong
		{
			/// <summary>
			/// If you don't want an unmarked connection to be matched. When using that flag, if no matching marked connection is found, then
			/// a new connection is created, and the request is sent on that connection.
			/// </summary>
			WINHTTP_MATCH_CONNECTION_GUID_FLAG_REQUIRE_MARKED_CONNECTION = 0x00000001
		}

		/// <summary>The flags that indicate various options affecting the behavior of WinHttpOpen.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NF:winhttp.WinHttpOpen")]
		[Flags]
		public enum WINHTTP_OPEN_FLAG : uint
		{
			/// <summary>
			/// Use the WinHTTP functions asynchronously. By default, all WinHTTP functions that use the returned HINTERNET handle are
			/// performed synchronously. When this flag is set, the caller needs to specify a callback function through WinHttpSetStatusCallback.
			/// </summary>
			WINHTTP_FLAG_ASYNC = 0x10000000,

			/// <summary>
			/// When this flag is set, WinHttp will require use of TLS 1.2 or newer. If the caller attempts to enable older TLS versions by
			/// setting <c>WINHTTP_OPTION_SECURE_PROTOCOLS</c>, it will fail with <c>ERROR_ACCESS_DENIED</c>. Additionally, TLS fallback will
			/// be disabled. Note that setting this flag also sets flag <c>WINHTTP_FLAG_ASYNC</c>.
			/// </summary>
			WINHTTP_FLAG_SECURE_DEFAULTS = 0x30000000,
		}

		/// <summary></summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NF:winhttp.WinHttpOpenRequest")]
		[Flags]
		public enum WINHTTP_OPENREQ_FLAG : uint
		{
			/// <summary>
			/// Uses secure transaction semantics. This translates to using Secure Sockets Layer (SSL)/Transport Layer Security (TLS).
			/// </summary>
			WINHTTP_FLAG_SECURE = 0x00800000,

			/// <summary>
			/// The string passed in for <c>pwszObjectName</c> is converted from an <c>LPCWSTR</c> to an <c>LPSTR</c>. All unsafe characters
			/// are converted to an escape sequence including the percent symbol. By default, all unsafe characters except the percent symbol
			/// are converted to an escape sequence.
			/// </summary>
			WINHTTP_FLAG_ESCAPE_PERCENT = 0x00000004,

			/// <summary>
			/// The string passed in for <c>pwszObjectName</c> is assumed to consist of valid ANSI characters represented by <c>WCHAR</c>. No
			/// check are done for unsafe characters. <c>Windows 7:</c> This option is obsolete.
			/// </summary>
			WINHTTP_FLAG_NULL_CODEPAGE = 0x00000008,

			/// <summary>This flag provides the same behavior as <c>WINHTTP_FLAG_REFRESH</c>.</summary>
			WINHTTP_FLAG_BYPASS_PROXY_CACHE = 0x00000100,

			/// <summary>
			/// Indicates that the request should be forwarded to the originating server rather than sending a cached version of a resource
			/// from a proxy server. When this flag is used, a "Pragma: no-cache" header is added to the request handle. When creating an
			/// HTTP/1.1 request header, a "Cache-Control: no-cache" is also added.
			/// </summary>
			WINHTTP_FLAG_REFRESH = WINHTTP_FLAG_BYPASS_PROXY_CACHE,

			/// <summary>Unsafe characters in the URL passed in for <c>pwszObjectName</c> are not converted to escape sequences.</summary>
			WINHTTP_FLAG_ESCAPE_DISABLE = 0x00000040,

			/// <summary>
			/// Unsafe characters in the query component of the URL passed in for <c>pwszObjectName</c> are not converted to escape sequences.
			/// </summary>
			WINHTTP_FLAG_ESCAPE_DISABLE_QUERY = 0x00000080,
		}

		/// <summary>
		/// The following option flags are supported by WinHttpQueryOption and WinHttpSetOption.
		/// <para>WINHTTP_OPTION_ASSURED_NON_BLOCKING_CALLBACKS</para>
		/// <para>
		/// The default is FALSE. If set to TRUE, WinHTTP does not guarantee progress if status callbacks are blocked by the client application.
		/// </para>
		/// <para>
		/// The client application must take special care to perform minimal operations within the callback without blocking, returning as
		/// quickly as possible, and in particular must not wait for any subsequent WinHTTP calls. If it does not follow these guidelines,
		/// there is likely to be a negative performance impact or a potential application hang. If used in the prescribed manner, this
		/// option may improve performance.
		/// </para>
		/// </summary>
		[PInvokeData("winhttp.h")]
		public enum WINHTTP_OPTION
		{
			/// <summary>Undocumented.</summary>
			WINHTTP_OPTION_AGGREGATE_PROXY_CONFIG = 181,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_ASSURED_NON_BLOCKING_CALLBACKS = 111,

			/// <summary>
			/// Sets an unsigned long integer value that specifies the Automatic Logon Policy with one of the
			/// WINHTTP_AUTOLOGON_SECURITY_LEVEL values.
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_AUTOLOGON_SECURITY_LEVEL), CorrespondingAction.Set)]
			WINHTTP_OPTION_AUTOLOGON_POLICY = 77,

			/// <summary>
			/// When you set this option on a session handle, you must pass the number of connections you wish to open. Then, upon first
			/// sending a request, rather than opening only a single connection, WinHttp opens a number of connections in parallel. This can
			/// improve the performance of subsequent requests to the same destination, which won't have the overhead of connection establishment.
			/// </summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_BACKGROUND_CONNECTIONS = 172,

			/// <summary>Retrieves the pointer to the callback function set with WinHttpSetStatusCallback.</summary>
			[CorrespondingType(typeof(WINHTTP_STATUS_CALLBACK))]
			WINHTTP_OPTION_CALLBACK = 1,

			/// <summary>
			/// <para>
			/// Sets the client certificate context. If an application receives ERROR_WINHTTP_CLIENT_AUTH_CERT_NEEDED, it must call
			/// WinHttpSetOption to supply a certificate before retrying the request. As a part of processing this option, WinHttp calls
			/// CertDuplicateCertificateContext on the caller-provided certificate context so that the certificate context can be
			/// independently released by the caller.
			/// </para>
			/// <para>
			/// <note type="note">The application should not attempt to close the certificate store with the CERT_CLOSE_STORE_FORCE_FLAG flag
			/// in the call to CertCloseStore on the certificate store from which the certificate context was retrieved. An access violation
			/// may occur.</note>
			/// </para>
			/// <para>
			/// When the server requests a client certificate, WinHttpSendRequest, or WinHttpReceiveResponse returns an
			/// ERROR_WINHTTP_CLIENT_AUTH_CERT_NEEDED error. If the server requests the certificate but does not require it, the application
			/// can specify this option to indicate that it does not have a certificate. The server can choose another authentication scheme
			/// or allow anonymous access to the server. The application provides the WINHTTP_NO_CLIENT_CERT_CONTEXT macro in the lpBuffer
			/// parameter of WinHttpSetOption as shown in the following code example.
			/// </para>
			/// <para>
			/// <code language="c">BOOL fRet = WinHttpSetOption(hRequest, WINHTTP_OPTION_CLIENT_CERT_CONTEXT, WINHTTP_NO_CLIENT_CERT_CONTEXT, 0);</code>
			/// </para>
			/// <para>
			/// If the server requires a client certificate, it may send a 403 HTTP status code in response. For more information, see the
			/// WINHTTP_OPTION_CLIENT_CERT_ISSUER_LIST option.
			/// </para>
			/// </summary>
			[CorrespondingType(typeof(Crypt32.CERT_CONTEXT), CorrespondingAction.Set)]
			WINHTTP_OPTION_CLIENT_CERT_CONTEXT = 47,

			/// <summary>
			/// Retrieves a SecPkgContext_IssuerListInfoEx structure when the error from WinHttpSendRequest or WinHttpReceiveResponse is
			/// ERROR_WINHTTP_CLIENT_AUTH_CERT_NEEDED. The issuer list in the structure contains a list of acceptable Certificate Authorities
			/// (CA) from the server. The client application can filter the CA list to retrieve the client certificate for SSL authentication.
			/// <para>
			/// Alternately, if the server requests the client certificate, but does not require it, the application can call
			/// WinHttpSetOption with the WINHTTP_OPTION_CLIENT_CERT_CONTEXT option. For more information, see the
			/// WINHTTP_OPTION_CLIENT_CERT_CONTEXT option.
			/// </para>
			/// </summary>
			[CorrespondingType(typeof(SecPkgContext_IssuerListInfoEx), CorrespondingAction.Get)]
			WINHTTP_OPTION_CLIENT_CERT_ISSUER_LIST = 94,

			/// <summary>Sets the code page that is used to process the URL (that is, query string). The default is UTF8.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_CODEPAGE = 68,

			/// <summary>
			/// Sets a WINHTTP_DISABLE_PASSPORT value that specifies whether Passport Authentication in WinHTTP authentication is enabled.
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_DISABLE_PASSPORT), CorrespondingAction.Set)]
			WINHTTP_OPTION_CONFIGURE_PASSPORT_AUTH = 83,

			/// <summary>
			/// Sets or retrieves an unsigned long integer value that contains the number of timesWinHTTP attempts to connect to a host.
			/// Microsoft Windows HTTP Services (WinHTTP) only attempts once per Internet Protocol (IP) address. For example, if you attempt
			/// to connect to a multihomed host that has 10 IP addresses and WINHTTP_OPTION_CONNECT_RETRIES is set to 7, then WinHTTP only
			/// attempts to connect to the first seven IP address. Given the same set of 10 IP addresses, if WINHTTP_OPTION_CONNECT_RETRIES
			/// is set to 20, WinHTTP attempts each of the 10 only once. If a connection attempt still fails after the specified number of
			/// attempts, or if the connect timeout expired before then, the request is canceled. The default value for
			/// WINHTTP_OPTION_CONNECT_RETRIES is five attempts.
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_CONNECT_RETRIES = 4,

			/// <summary>
			/// Sets or retrieves an unsigned long integer value that contains the time-out value, in milliseconds. Setting this option to
			/// infinite (0xFFFFFFFF) will disable this timer.
			/// <para>
			/// If a TCP connection request takes longer than this time-out value, the request is canceled. The default timeout is 60
			/// seconds. When you are attempting to connect to multiple IP addresses for a single host (a multihomed host), the timeout limit
			/// is for each individual connection.
			/// </para>
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_CONNECT_TIMEOUT = 3,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_CONNECTION_FILTER = 131,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(Guid))]
			WINHTTP_OPTION_CONNECTION_GUID = 178,

			/// <summary>
			/// Retrieves the source and destination IP address, and port of the request that generated the response when
			/// WinHttpReceiveResponse returns. The application calls WinHttpQueryOption with the WINHTTP_OPTION_CONNECTION_INFO option, and
			/// provides the WINHTTP_CONNECTION_INFO structure in the lpBuffer parameter. For more information, see WINHTTP_CONNECTION_INFO.
			/// <para>Windows Server 2003 with SP1 and Windows XP with SP2: This flag is obsolete.</para>
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_CONNECTION_INFO))]
			WINHTTP_OPTION_CONNECTION_INFO = 93,

			/// <summary>
			/// Retreives the TCP_INFO_v0 struct for the underlying connection used by the request. The returned struct may contain
			/// statistics from prior requests sent over the same connection. <note type="note">This option has been superseded by WINHTTP_OPTION_CONNECTION_STATS_V1.</note>
			/// </summary>
			[CorrespondingType(typeof(TCP_INFO_v0))]
			WINHTTP_OPTION_CONNECTION_STATS_V0 = 141,

			/// <summary>
			/// Retreives the TCP_INFO_v1 struct for the underlying connection used by the request. The returned struct may contain
			/// statistics from prior requests sent over the same connection.
			/// </summary>
			[CorrespondingType(typeof(TCP_INFO_v1))]
			WINHTTP_OPTION_CONNECTION_STATS_V1 = 150,

			/// <summary>
			/// Sets or retrieves a DWORD_PTR that contains a pointer to the context value associated with this HINTERNET handle. The value
			/// stored in the buffer is used and the WINHTTP_OPTION_CONTEXT_VALUE option flag is assigned a new value.
			/// </summary>
			[CorrespondingType(typeof(IntPtr))]
			WINHTTP_OPTION_CONTEXT_VALUE = 45,

			/// <summary>
			/// Sets a WINHTTP_DECOMPRESSION_FLAG flag value which determine whether WinHTTP will automatically decompress response bodies
			/// with compressed Content-Encodings. WinHTTP will also set an appropriate Accept-Encoding header, overriding any supplied by
			/// the caller.
			/// <para>By default, WinHTTP will deliver compressed responses to the caller unmodified.</para>
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_DECOMPRESSION_FLAG), CorrespondingAction.Set)]
			WINHTTP_OPTION_DECOMPRESSION = 118,

			/// <summary>
			/// Setting this option on a WinHttp session handle allows you to enable/disable whether the server certificate chain is built.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_DISABLE_CERT_CHAIN_BUILDING = 171,

			/// <summary>
			/// Sets a WINHTTP_DISABLE value that specifies which features are disabled with one or more of the following flags. Be aware
			/// that this feature should only be passed to WinHttpSetOption on request handles after the request handle is created with
			/// WinHttpOpenRequest, and before the request is sent with WinHttpSendRequest.
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_DISABLE), CorrespondingAction.Set)]
			WINHTTP_OPTION_DISABLE_FEATURE = 63,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_DISABLE_PROXY_LINK_LOCAL_NAME_RESOLUTION = 176,

			/// <summary>
			/// Prevents WinHTTP from retrying a connection with a lower version of the security protocol when the initial protocol
			/// negotiation fails.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_DISABLE_SECURE_PROTOCOL_FALLBACK = 144,

			/// <summary>
			/// Allows new requests to open an additional HTTP/2 connection when the maximum concurrent stream limit is reached, rather than
			/// waiting for the next available stream on an existing connection.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_DISABLE_STREAM_QUEUE = 139,

			/// <summary>Sets a WINHTTP_ENABLE_SSL value that specifies the features currently enabled.</summary>
			[CorrespondingType(typeof(WINHTTP_ENABLE_SSL), CorrespondingAction.Set)]
			WINHTTP_OPTION_ENABLE_FEATURE = 79,

			/// <summary>
			/// Sets a DWORD bitmask of acceptable advanced HTTP versions.
			/// <para>Legacy versions of HTTP (1.1 and prior) cannot be disabled using this option. The default is 0x0.</para>
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_PROTOCOL_FLAG), CorrespondingAction.Set)]
			WINHTTP_OPTION_ENABLE_HTTP_PROTOCOL = 133,

			/// <summary>
			/// This option can be set on a WinHttp session handle to allow WinHttp to use the caller-provided client certificate context
			/// when HTTP/2 is being used.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_ENABLE_HTTP2_PLUS_CLIENT_CERT = 161,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_ENABLE_TEST_SIGNING = 174,

			/// <summary>
			/// Sets a BOOL value that specifies whether tracing is currently enabled. For more information about the trace facility in
			/// WinHTTP, see WinHTTP Trace Facility. This option can only be set on a NULL HINTERNET handle.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_ENABLETRACING = 85,

			/// <summary>
			/// Enables URL percent encoding for path and query string. Alternatively, you can percent encode before calling WinHttp.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_ENCODE_EXTRA = 138,

			/// <summary>
			/// This option can only be set on a request handle which is still active (sending or receiving). Setting this option will tell
			/// WinHttp to stop serving requests on the connection associated with the request handle passed in. The connection will be
			/// closed after the request handle this option is called with is completed. This option does not take any parameters.
			/// </summary>
			[CorrespondingType(null, CorrespondingAction.Set)]
			WINHTTP_OPTION_EXPIRE_CONNECTION = 143,

			/// <summary>
			/// Retrieves an unsigned long integer value that contains a Microsoft Windows Sockets error code that was mapped to the
			/// ERROR_WINHTTP_* error messages last returned in this thread context. You can pass NULL as the handle value.
			/// </summary>
			[CorrespondingType(typeof(Win32Error), CorrespondingAction.Get)]
			WINHTTP_OPTION_EXTENDED_ERROR = 24,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_FAILED_CONNECTION_RETRIES = 162,

			/// <summary>
			/// By default, when WinHttp sends a request, if there are no available connections to serve the request, WinHttp will attempt to
			/// establish a new connection, and the request will be bound to this new connection. When you set this option, such a request
			/// will instead be served on the first connection that becomes available, and not necessarily the one being established.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_FIRST_AVAILABLE_CONNECTION = 173,

			/// <summary>
			/// Takes a pointer to a WINHTTP_CREDS_EX structure with the hInternet function parameter set to NULL. This option requires
			/// registry key HKLM\Software\Microsoft\Windows\CurrentVersion\Internet Settings!ShareCredsWithWinHttp. If this registry key is
			/// not set WinHTTP will return error ERROR_WINHTTP_INVALID_OPTION. This registry key is not present by default. When it is set,
			/// WinINet will send credentials down to WinHTTP. Whenever WinHttp gets an authentication challenge and if there are no
			/// credentials set on the current handle, it will use the credentials provided by WinINet. In order to share server credentials
			/// in addition to proxy credentials, users needs to set WINHTTP_OPTION_USE_GLOBAL_SERVER_CREDENTIALS.
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_CREDS_EX), CorrespondingAction.Set)]
			WINHTTP_OPTION_GLOBAL_PROXY_CREDS = 97,

			/// <summary>
			/// Takes a pointer to a WINHTTP_CREDS_EX structure with the hInternet function parameter set to NULL. This option requires
			/// registry key HKLM\Software\Microsoft\Windows\CurrentVersion\Internet Settings!ShareCredsWithWinHttp. If this registry key is
			/// not set WinHTTP will return error ERROR_WINHTTP_INVALID_OPTION. This registry key is not present by default. When it is set,
			/// WinINet will send credentials down to WinHTTP. Whenever WinHttp gets an authentication challenge and if there are no
			/// credentials set on the current handle, it will use the credentials provided by WinINet. In order to share server credentials
			/// in addition to proxy credentials, users needs to set WINHTTP_OPTION_USE_GLOBAL_SERVER_CREDENTIALS.
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_CREDS_EX), CorrespondingAction.Set)]
			WINHTTP_OPTION_GLOBAL_SERVER_CREDS = 98,

			/// <summary>Retrieves an unsigned long integer value that contains the type of the HINTERNET handle passed in.</summary>
			[CorrespondingType(typeof(WINHTTP_HANDLE_TYPE), CorrespondingAction.Get)]
			WINHTTP_OPTION_HANDLE_TYPE = 9,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_HEAP_EXTENSION = 157,

			/// <summary>
			/// Prevents protocol versions other than those enabled by WINHTTP_OPTION_ENABLE_HTTP_PROTOCOL from being used for the request.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_HTTP_PROTOCOL_REQUIRED = 145,

			/// <summary>
			/// Gets a DWORD indicating which advanced HTTP version was used on a given request. For a list of possible values, see WINHTTP_OPTION_ENABLE_HTTP_PROTOCOL.
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_PROTOCOL_FLAG), CorrespondingAction.Get)]
			WINHTTP_OPTION_HTTP_PROTOCOL_USED = 134,

			/// <summary>
			/// Sets or retrieves an HTTP_VERSION_INFO structure that contains the HTTP version being supported. This is a process-wide
			/// option; use NULL for the handle.
			/// </summary>
			[CorrespondingType(typeof(HTTP_VERSION_INFO))]
			WINHTTP_OPTION_HTTP_VERSION = 59,

			/// <summary>
			/// This option can be set on a session handle to have WinHttp use HTTP/2 PING frames as a keepalive mechanism. Callers specify a
			/// timeout in milliseconds, and after there is no activity on a connection for that timeout period, WinHttp will begin to send
			/// HTTP/2 PING frames. Callers cannot set a timeout value less than 5000 milliseconds.
			/// </summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_HTTP2_KEEPALIVE = 164,

			/// <summary>
			/// This option can be set on a WinHttp request handle to control how WinHttp behaves when an HTTP/2 response contains a
			/// "Transfer-Encoding" header. In such a case, WinHttp will return an error if this option is set to FALSE.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_HTTP2_PLUS_TRANSFER_ENCODING = 169,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_HTTP2_RECEIVE_WINDOW = 183,

			/// <summary>
			/// Allows secure connections to use security certificates for which the certificate revocation list could not be downloaded.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_IGNORE_CERT_REVOCATION_OFFLINE = 155,

			/// <summary>
			/// Enables IPv6 fast fallback (Happier Eyeballs) for the connection. This behavior is similar to the Happy Eyeballs behavior
			/// described in RFC 6555 for improving connection times on networks where IPv6 is unreliable.
			/// <list type="bullet">
			/// <item>
			/// If both IPv6 and IPv4 addresses are resolved for a given host, WinHttp will begin by connecting to the first resolved IPv6
			/// address with a short (300ms) timeout.
			/// </item>
			/// <item>Should that connection fail, WinHttp will attempt to connect to the first resolved IPv4 address with the standard timeout.</item>
			/// <item>Should the second connection fail, WinHttp will retry the first resolved IPv6 address with the standard timeout.</item>
			/// <item>
			/// Should the third connection fail, WinHttp will revert to the default behavior for any remaining addresses, attempting a
			/// connection to each one with the standard timeout until a connection is made or no addresses remain.
			/// </item>
			/// </list>
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_IPV6_FAST_FALLBACK = 140,

			/// <summary>Gets whether or not a Proxy Return Connect Response can be retrieved.</summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Get)]
			WINHTTP_OPTION_IS_PROXY_CONNECT_RESPONSE = 104,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_KDC_PROXY_SETTINGS = 136,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(Guid), CorrespondingAction.Set)]
			WINHTTP_OPTION_MATCH_CONNECTION_GUID = 179,

			/// <summary>
			/// Sets or retrieves an unsigned long integer value that contains the maximum number of connections allowed per HTTP/1.0 server.
			/// The default value is INFINITE.
			/// <para>Windows Vista with SP1 and Windows Server 2008: This flag is obsolete.</para>
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_MAX_CONNS_PER_1_0_SERVER = 74,

			/// <summary>
			/// Sets or retrieves an unsigned long integer value that contains the maximum number of connections allowed per server. The
			/// default value is INFINITE.
			/// <para>When this option is set to zero, WinHTTP sets the limit on the number of connections to 2.</para>
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_MAX_CONNS_PER_SERVER = 73,

			/// <summary>
			/// Sets the maximum number of redirects that WinHTTP follows; the default is 10. This limit prevents unauthorized sites from
			/// making the WinHTTP client pause following a large number of redirects.
			/// <para>Windows XP with SP1 and Windows 2000 with SP3: This flag is obsolete.</para>
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_MAX_HTTP_AUTOMATIC_REDIRECTS = 89,

			/// <summary>
			/// The maximum number of Informational 100-199 status code responses ignored before returning the final status code to the
			/// WinHTTP client. Informational 100-199 status codes can be sent by the server before the final status code, and are described
			/// in the specification for HTTP/1.1 (for more information, see RFC 2616). The default is 10.
			/// <para>Windows XP with SP1 and Windows 2000 with SP3: This flag is obsolete.</para>
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_MAX_HTTP_STATUS_CONTINUE = 90,

			/// <summary>
			/// A bound on the amount of data drained from responses in order to reuse a connection, specified in bytes. The default is 1MB.
			/// <para>Windows XP with SP1 and Windows 2000 with SP3: This flag is obsolete.</para>
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_MAX_RESPONSE_DRAIN_SIZE = 92,

			/// <summary>
			/// A bound set on the maximum size of the header portion of the server response, specified in bytes. This bound protects the
			/// client from an unauthorized server attempting to stall the client by sending a response with an infinite amount of header
			/// data. The default value is 64KB.
			/// <para>Windows XP with SP1 and Windows 2000 with SP3: This flag is obsolete.</para>
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_MAX_RESPONSE_HEADER_SIZE = 91,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_NTSERVICE_FLAG_TEST = 175,

			/// <summary>Retrieves the parent handle to this handle.</summary>
			[CorrespondingType(typeof(HINTERNET), CorrespondingAction.Get)]
			WINHTTP_OPTION_PARENT_HANDLE = 21,

			/// <summary>
			/// Retrieves a string that contains the cobranding text provided by the Passport logon server. This option should be retrieved
			/// immediately after the logon server responds with a 401 status code. An application should pass in a buffer size, in bytes,
			/// that is big enough to hold the returned string.
			/// </summary>
			[CorrespondingType(typeof(string), CorrespondingAction.Get)]
			WINHTTP_OPTION_PASSPORT_COBRANDING_TEXT = 81,

			/// <summary>
			/// Retrieves a string that contains a URL for a cobranding graphic provided by the Passport logon server. This option should be
			/// retrieved immediately after the logon server responds with a 401 status code. An application should pass in a buffer size, in
			/// bytes, that is big enough to hold the returned string.
			/// </summary>
			[CorrespondingType(typeof(string), CorrespondingAction.Get)]
			WINHTTP_OPTION_PASSPORT_COBRANDING_URL = 82,

			/// <summary>Sets a read-only option on a request handle that retrieves the Passport return URL.</summary>
			[CorrespondingType(typeof(IntPtr), CorrespondingAction.Set)]
			WINHTTP_OPTION_PASSPORT_RETURN_URL = 87,

			/// <summary>
			/// Sets the option on a session handle to sign out of any Passport logins. An application should pass in the Passport return URL
			/// that was retrieved with WINHTTP_OPTION_PASSPORT_RETURN_URL. All cookies related to the return URL are cleared.
			/// </summary>
			[CorrespondingType(typeof(IntPtr), CorrespondingAction.Set)]
			WINHTTP_OPTION_PASSPORT_SIGN_OUT = 86,

			/// <summary>Sets or retrieves a string value that contains the password associated with a request handle.</summary>
			[CorrespondingType(typeof(string))]
			WINHTTP_OPTION_PASSWORD = 0x1001,

			/// <summary>
			/// Sets or retrieves an WINHTTP_PROXY_INFO structure that contains the proxy data on an existing session handle or request
			/// handle. When retrieving proxy data, an application must free the lpszProxy and lpszProxyBypass strings contained in this
			/// structure (if they are non-NULL) using the GlobalFree function. An application can query for the global proxy data (the
			/// default proxy) by passing a NULL handle.
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_PROXY_INFO), CorrespondingAction.Get)]
			[CorrespondingType(typeof(WINHTTP_PROXY_INFO_IN), CorrespondingAction.Set)]
			WINHTTP_OPTION_PROXY = 38,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(WINHTTP_PROXY_SETTINGS))]
			WINHTTP_OPTION_PROXY_CONFIG_INFO = 180,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_PROXY_DISABLE_SERVICE_CALLS = 137,

			/// <summary>Sets or retrieves a string value that contains the password used to access the proxy.</summary>
			[CorrespondingType(typeof(string))]
			WINHTTP_OPTION_PROXY_PASSWORD = 0x1003,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(WINHTTP_PROXY_RESULT_ENTRY), CorrespondingAction.Set)]
			WINHTTP_OPTION_PROXY_RESULT_ENTRY = 39,

			/// <summary>
			/// Gets the proxy Server Principal Name that WinHTTP supplied to SSPI during authentication. This string value is usefor passing
			/// to SspiPromptForCredentials after an authentication failure.
			/// </summary>
			[CorrespondingType(typeof(string), CorrespondingAction.Get)]
			WINHTTP_OPTION_PROXY_SPN_USED = 107,

			/// <summary>Sets or retrieves a string value that contains the user name used to access the proxy.</summary>
			[CorrespondingType(typeof(string))]
			WINHTTP_OPTION_PROXY_USERNAME = 0x1002,

			/// <summary>This option has been deprecated; it has no effect.</summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_READ_BUFFER_SIZE = 12,

			/// <summary>Sets whether or not the proxy response entity can be retrieved. This option is disabled by default.</summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_RECEIVE_PROXY_CONNECT_RESPONSE = 103,

			/// <summary>
			/// Sets or retrieves an unsigned long integer value that contains the timeout value, in milliseconds, to wait to receive all
			/// response headers to a request. If WinHTTP fails to receive all the headers within this timeout period, the request is
			/// canceled. The default timeout value is 90 seconds.
			/// <para>
			/// This timeout is checked only when data is received from the socket. As a result, when the timeout expires the client
			/// application is not notified until more data arrives from the server. If no data arrives from the server, the delay between
			/// the timeout expiration and notification of the client application could be as large as the timeout value set using the
			/// dwReceiveTimeout parameter of the WinHttpSetTimeouts function.
			/// </para>
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT = 7,

			/// <summary>
			/// Sets or retrieves an unsigned long integer value that contains the time-out value, in milliseconds, to receive a partial
			/// response to a request or read some data. If the response takes longer than this time-out value, the request is canceled. The
			/// default timeout value is 30 seconds.
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_RECEIVE_TIMEOUT = 6,

			/// <summary>
			/// Sets the behavior of WinHTTP regarding the handling of a 30x HTTP redirect status code. This option can be set on a session
			/// or request handle.
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_OPTION_REDIRECT_POLICY), CorrespondingAction.Set)]
			WINHTTP_OPTION_REDIRECT_POLICY = 88,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_REFERER_TOKEN_BINDING_HOSTNAME = 168,

			/// <summary>
			/// Rejects URLs that contain a username and password. This option also rejects URLs that contain username:password semantics,
			/// even if no username or password is specified. For example, "u:p@hostname", ":@hostname", "u:@hostname", and ":p@hostname"
			/// would all be flagged as invalid. If an invalid URL is passed to the function, it returns ERROR_WINHTTP_INVALID_URL. This
			/// option is turned off by default.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.GetSet)]
			WINHTTP_OPTION_REJECT_USERPWD_IN_URL = 100,

			/// <summary>This option has been deprecated; it has no effect.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.GetSet)]
			WINHTTP_OPTION_REQUEST_PRIORITY = 58,

			/// <summary>Retreives statistics for the request. For a list of the available statistics, see WINHTTP_REQUEST_STATS.</summary>
			[CorrespondingType(typeof(WINHTTP_REQUEST_STATS), CorrespondingAction.Get)]
			WINHTTP_OPTION_REQUEST_STATS = 146,

			/// <summary>Retreives timing information for the request. For a list of the available timings, see WINHTTP_REQUEST_TIMES.</summary>
			[CorrespondingType(typeof(WINHTTP_REQUEST_TIMES), CorrespondingAction.Get)]
			WINHTTP_OPTION_REQUEST_TIMES = 142,

			/// <summary>
			/// This option tells WinHttp to ignore "Content-Length" response headers, and continue receiving on a stream until the
			/// END_STREAM flag is received.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_REQUIRE_STREAM_END = 160,

			/// <summary>
			/// This option can be set on a WinHttp request handle before it has been sent. If set, WinHttp will use the caller-provided
			/// string as the hostname for DNS resolution.
			/// </summary>
			[CorrespondingType(typeof(string), CorrespondingAction.Set)]
			WINHTTP_OPTION_RESOLUTION_HOSTNAME = 165,

			/// <summary>
			/// Sets or retrieves an unsigned long integer value that contains the time-out value, in milliseconds, to resolve a host name.
			/// The default timeout value is INFINITE. If a non-default value is specified, there is an overhead of one thread-creation per
			/// name resolution.
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_RESOLVE_TIMEOUT = 2,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_RESOLVER_CACHE_CONFIG = 170,

			/// <summary>
			/// Sets an unsigned long integer value that specifies which secure protocols are acceptable. By default only SSL3 and TLS1 are
			/// enabled in Windows 7 and Windows 8. By default only SSL3, TLS1.0, TLS1.1, and TLS1.2 are enabled in Windows 8.1 and Windows 10.
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_FLAG_SECURE_PROTOCOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_SECURE_PROTOCOLS = 84,

			/// <summary>
			/// Retrieves the certificate for a SSL/TLS server into the WINHTTP_CERTIFICATE_INFO structure. The application must free the
			/// lpszSubjectInfo and lpszIssuerInfo members with LocalFree.
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_CERTIFICATE_INFO), CorrespondingAction.Get)]
			WINHTTP_OPTION_SECURITY_CERTIFICATE_STRUCT = 32,

			/// <summary>Sets or retrieves an unsigned long integer value that contains the security flags for a handle.</summary>
			[CorrespondingType(typeof(SECURITY_FLAG))]
			WINHTTP_OPTION_SECURITY_FLAGS = 31,

			/// <summary>Retreives the SChannel connection and cipher information for a request.</summary>
			[CorrespondingType(typeof(WINHTTP_SECURITY_INFO), CorrespondingAction.Get)]
			WINHTTP_OPTION_SECURITY_INFO = 151,

			/// <summary>
			/// Retrieves an unsigned long integer value that contains the cipher strength of the encryption key. A larger number indicates
			/// stronger cipher strength encryption.
			/// </summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Get)]
			WINHTTP_OPTION_SECURITY_KEY_BITNESS = 36,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(WINHTTP_PROXY_SETTINGS))]
			WINHTTP_OPTION_SELECTED_PROXY_CONFIG_INFO = 182,

			/// <summary>
			/// Sets or retrieves an unsigned long integer value that contains the time-out value, in milliseconds, to send a request or
			/// write some data. If sending the request takes longer than the timeout, the send operation is canceled. The default timeout is
			/// 30 seconds.
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_SEND_TIMEOUT = 5,

			/// <summary>
			/// Gets a pointer to SecPkgContext_Bindings structure that specifies a Channel Binding Token (CBT).
			/// <para>
			/// A Channel Binding Token is a property of a secure transport channel and is used to bind an authentication channel to the
			/// secure transport channel. This token can only be obtained by this option after an SSL connection has been established.
			/// </para>
			/// <note type="note">Passing this option and a null value for lpBuffer to WinHttpQueryOption will return
			/// ERROR_INSUFFICIENT_BUFFER and the required byte size for the buffer in the lpdwBufferLength parameter.This returned buffer
			/// size value can be passed in a subsequent call to query for the Channel Binding Token.These steps are necessary when handling
			/// WINHTTP_CALLBACK_STATUS_REQUEST if you want to modify request headers based on the Channel Binding Token. Note that Windows
			/// XP and Vista do not support modifying request headers during this callback.</note>
			/// </summary>
			[CorrespondingType(typeof(Secur32.SecPkgContext_Bindings), CorrespondingAction.Get)]
			WINHTTP_OPTION_SERVER_CBT = 108,

			/// <summary>
			/// Retrieves the server certification chain context. WINHTTP_OPTION_SERVER_CERT_CHAIN_CONTEXT can be passed to obtain a
			/// duplicated pointer to the CERT_CHAIN_CONTEXT for a server certificate chain received during a negotiated SSL connection. The
			/// client must call CertFreeCertificateContext on the returned PCCERT_CONTEXT pointer that is filled into the buffer.
			/// </summary>
			[CorrespondingType(typeof(Crypt32.PCCERT_CHAIN_CONTEXT), CorrespondingAction.Get)]
			WINHTTP_OPTION_SERVER_CERT_CHAIN_CONTEXT = 147,

			/// <summary>
			/// Retrieves the server certification context. WINHTTP_OPTION_SERVER_CERT_CONTEXT can be passed to obtain a duplicated pointer
			/// to the CERT CONTEXT for a server certificate received during a negotiated SSL connection. The client must call
			/// CertFreeCertificateContext on the returned PCCERT_CONTEXT pointer that is filled into the buffer.
			/// </summary>
			[CorrespondingType(typeof(Crypt32.PCCERT_CONTEXT), CorrespondingAction.Get)]
			WINHTTP_OPTION_SERVER_CERT_CONTEXT = 78,

			/// <summary>
			/// Gets the server Server Principal Name that WinHTTP supplied to SSPI during authentication. This string value can be passed to
			/// SspiPromptForCredentials after an authentication failure.
			/// </summary>
			[CorrespondingType(typeof(string), CorrespondingAction.Get)]
			WINHTTP_OPTION_SERVER_SPN_USED = 106,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_SET_GLOBAL_CALLBACK = 163,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_SET_TOKEN_BINDING = 166,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_SOURCE_ADDRESS = 156,

			/// <summary>
			/// Includes or removes the server port number when the SPN (service principal name) is built for Kerberos or Negotiate Kerberos authentication.
			/// </summary>
			[CorrespondingType(typeof(WINHTTP_SPN), CorrespondingAction.Set)]
			WINHTTP_OPTION_SPN = 96,

			/// <summary>
			/// This option can be queried on a WinHttp request handle, and will return the error code indicated by a RST_STREAM frame
			/// received on an HTTP stream.
			/// </summary>
			[CorrespondingType(typeof(Win32Error), CorrespondingAction.Get)]
			WINHTTP_OPTION_STREAM_ERROR_CODE = 159,

			/// <summary>Enables TCP Fast Open for the connection.</summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_TCP_FAST_OPEN = 153,

			/// <summary>
			/// This option can be set on a WinHttp session handle to enable TCP keep-alive behavior on the underlying socket. Takes a
			/// tcp_keepalive struct.
			/// </summary>
			[CorrespondingType(typeof(tcp_keepalive), CorrespondingAction.Set)]
			WINHTTP_OPTION_TCP_KEEPALIVE = 152,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_TCP_PRIORITY_HINT = 128,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(ulong), CorrespondingAction.GetSet)]
			WINHTTP_OPTION_TCP_PRIORITY_STATUS = 177,

			/// <summary>Enables TLS False Start for the connection.</summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_TLS_FALSE_START = 154,

			/// <summary>
			/// This option can be set on a WinHttp session handle to control whether fallback to TLS 1.0 is allowed if there is a TLS
			/// handshake failure with a newer protocol version.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_TLS_PROTOCOL_INSECURE_FALLBACK = 158,

			/// <summary>Undocumented.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.GetSet)]
			WINHTTP_OPTION_TOKEN_BINDING_PUBLIC_KEY = 167,

			/// <summary>
			/// Takes an event that will be set when the last callback has completed for a particular session. This flag must be must be used
			/// on a session handle. The event cannot be closed until after it has been set by WinHTTP.
			/// </summary>
			[CorrespondingType(typeof(HEVENT), CorrespondingAction.Set)]
			WINHTTP_OPTION_UNLOAD_NOTIFY_EVENT = 99,

			/// <summary>This option is reserved for internal use and should not be called.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_UNSAFE_HEADER_PARSING = 110,

			/// <summary>Instructs the stack to start a WebSocket handshake process with WinHttpSendRequest. This option takes no parameters.</summary>
			[CorrespondingType(null, CorrespondingAction.Set)]
			WINHTTP_OPTION_UPGRADE_TO_WEB_SOCKET = 114,

			/// <summary>
			/// Retrieves a string value that contains the full URL of a downloaded resource. If the original URL contained any extra data,
			/// such as search strings or anchors, or if the call was redirected, the URL returned differs from the original. The application
			/// should pass in a buffer, sized in bytes, that is big enough to hold the returned URL in wide char.
			/// </summary>
			[CorrespondingType(typeof(string), CorrespondingAction.Get)]
			WINHTTP_OPTION_URL = 34,

			/// <summary>
			/// Takes a BOOL and can be set only a session handle. It will only propagate down to handles created from the session handle
			/// after the option has been set. If TRUE, this option causes as a last resort the use of global server credentials that were
			/// pushed down from WinInet. The default for this option is FALSE. This option requires registry key
			/// HKLM\Software\Microsoft\Windows\CurrentVersion\Internet Settings!ShareCredsWithWinHttp. This registry key is not present by
			/// default. When it is set, WinINet will send credentials down to WinHTTP. Whenever WinHttp gets an authentication challenge and
			/// if there are no credentials set on the current handle, it will use the credentials provided by WinINet.
			/// </summary>
			[CorrespondingType(typeof(BOOL), CorrespondingAction.Set)]
			WINHTTP_OPTION_USE_GLOBAL_SERVER_CREDENTIALS = 101,

			/// <summary>
			/// Sets or retrieves the user agent string on handles supplied by WinHttpOpen and used in subsequent WinHttpSendRequest
			/// functions, as long as it is not overridden by a header added by WinHttpAddRequestHeaders or WinHttpSendRequest. When
			/// retrieving a user agent, the application should pass in a buffer, sized in bytes, that is big enough to hold the returned URL
			/// in wide char. When setting the user agent, the buffer size is the length of the string, in characters, plus the NULL terminator.
			/// </summary>
			[CorrespondingType(typeof(string), CorrespondingAction.GetSet)]
			WINHTTP_OPTION_USER_AGENT = 41,

			/// <summary>Sets or retrieves a string that contains the user name.</summary>
			[CorrespondingType(typeof(string), CorrespondingAction.GetSet)]
			WINHTTP_OPTION_USERNAME = 0x1000,

			/// <summary>
			/// Sets the time, in milliseconds, that WinHttpWebSocketClose should wait to complete the close handshake. The default is 10 seconds.
			/// </summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_WEB_SOCKET_CLOSE_TIMEOUT = 115,

			/// <summary>
			/// Sets the interval, in milliseconds, to send a keep-alive packet over the connection. The default interval is 30000 (30
			/// seconds). The minimum interval is 15000 (15 seconds). Using WinHttpSetOption to set a value lower than 15000 will return with
			/// ERROR_INVALID_PARAMETER. <note type="note">The default value for WINHTTP_OPTION_WEB_SOCKET_KEEPALIVE_INTERVAL is read from
			/// HKLM:\SOFTWARE\Microsoft\WebSocket\KeepaliveInterval. If a value is not set, the default value of 30000 will be used. It is
			/// not possible to have a lower keepalive interval than 15000 milliseconds.</note>
			/// </summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_WEB_SOCKET_KEEPALIVE_INTERVAL = 116,

			/// <summary>Sets or retrieves a DWORD which specifies the receive buffer size to be used on WebSocket connections.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.GetSet)]
			WINHTTP_OPTION_WEB_SOCKET_RECEIVE_BUFFER_SIZE = 122,

			/// <summary>Sets or retrieves a DWORD which specifies the send buffer size to be used on WebSocket connections.</summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.GetSet)]
			WINHTTP_OPTION_WEB_SOCKET_SEND_BUFFER_SIZE = 123,

			/// <summary>
			/// Sets an unsigned long integer value that specifies the number of worker threads the thread pool should use for asynchronous
			/// completions. The default value of this option is zero, which specifies that the number of worker threads is equal to the
			/// number of CPUs on the system. This option can only be set on a NULL HINTERNET handle before an asynchronous operation has
			/// occurred. This option can only be set once.
			/// <para>Windows Server 2008 R2 and Windows 7: This flag is obsolete.</para>
			/// </summary>
			[CorrespondingType(typeof(uint), CorrespondingAction.Set)]
			WINHTTP_OPTION_WORKER_THREAD_COUNT = 80,

			/// <summary>This option has been deprecated; it has no effect.</summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_OPTION_WRITE_BUFFER_SIZE = 13,
		}

		/// <summary>The behavior of WinHTTP regarding the handling of a 30x HTTP redirect status code.</summary>
		[PInvokeData("winhttp.h")]
		public enum WINHTTP_OPTION_REDIRECT_POLICY : uint
		{
			/// <summary>WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP</summary>
			WINHTTP_OPTION_REDIRECT_POLICY_DEFAULT = WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP,

			/// <summary>Redirects are never followed. The 30x status is returned to the application.</summary>
			WINHTTP_OPTION_REDIRECT_POLICY_NEVER = 0,

			/// <summary>
			/// All redirects are followed, except those that originate from a secure (https) URL to an unsecure (http) URL. This is the
			/// default setting.
			/// </summary>
			WINHTTP_OPTION_REDIRECT_POLICY_DISALLOW_HTTPS_TO_HTTP = 1,

			/// <summary>All redirects are followed automatically.</summary>
			WINHTTP_OPTION_REDIRECT_POLICY_ALWAYS = 2,
		}

		/// <summary>Bitmask of acceptable advanced HTTP versions.</summary>
		[PInvokeData("winhttp.h")]
		[Flags]
		public enum WINHTTP_PROTOCOL_FLAG : uint
		{
			/// <summary>Restricts the request to HTTP/1.1 and prior.</summary>
			None = 0,

			/// <summary>Enables HTTP/2 for the request.</summary>
			WINHTTP_PROTOCOL_FLAG_HTTP2 = 0x1,

			/// <summary>Enables HTTP/3 for the request.</summary>
			WINHTTP_PROTOCOL_FLAG_HTTP3 = 0x2,
		}

		/// <summary>Defines constants that specify proxy settings types for extended proxy settings APIs.</summary>
		// https://learn.microsoft.com/en-us/windows/win32/api/winhttp/ne-winhttp-winhttp_proxy_settings_type typedef enum
		// _WINHTTP_PROXY_SETTINGS_TYPE { WinHttpProxySettingsTypeUnknown, WinHttpProxySettingsTypeWsl, WinHttpProxySettingsTypeWsa }
		// WINHTTP_PROXY_SETTINGS_TYPE, *PWINHTTP_PROXY_SETTINGS_TYPE;
		[PInvokeData("winhttp.h", MSDNShortId = "NE:winhttp._WINHTTP_PROXY_SETTINGS_TYPE")]
		public enum WINHTTP_PROXY_SETTINGS_TYPE
		{
			/// <summary>Specifies an unknown type.</summary>
			WinHttpProxySettingsTypeUnknown,

			/// <summary>Specifies settings for Windows Subsystem for Linux (WSL).</summary>
			WinHttpProxySettingsTypeWsl,

			/// <summary>Specifies settings for Windows Subsystem for Android (WSA).</summary>
			WinHttpProxySettingsTypeWsa,
		}

		/// <summary></summary>
		[Flags]
		public enum WINHTTP_PROXY_TYPE : ulong
		{
			/// <summary>Direct to net</summary>
			WINHTTP_PROXY_TYPE_DIRECT = 0x00000001,

			/// <summary>Via named proxy</summary>
			WINHTTP_PROXY_TYPE_PROXY = 0x00000002,

			/// <summary>Autoproxy URL</summary>
			WINHTTP_PROXY_TYPE_AUTO_PROXY_URL = 0x00000004,

			/// <summary>Use autoproxy detection</summary>
			WINHTTP_PROXY_TYPE_AUTO_DETECT = 0x00000008,
		}

		/// <summary>
		/// <para>These attributes and modifiers are used by WinHttpQueryHeaders.</para>
		/// <para>
		/// The attribute flags are used by WinHttpQueryHeaders to indicate what information to retrieve. Most of the attribute flags map
		/// directly to a specific HTTP header. There are also some special flags, such as WINHTTP_QUERY_RAW_HEADERS, that are not related to
		/// a specific header.
		/// </para>
		/// <para>
		/// The modifier flags are used in conjunction with an attribute flag to modify the request. Modifier flags either modify the format
		/// of the data returned or indicate where the WinHttpQueryHeaders function should search for the information.
		/// </para>
		/// </summary>
		[PInvokeData("winhttp.h")]
		[Flags]
		public enum WINHTTP_QUERY : uint
		{
			/// <summary>Retrieves the acceptable media types for the response.</summary>
			WINHTTP_QUERY_ACCEPT = 24,

			/// <summary>Retrieves the acceptable character sets for the response.</summary>
			WINHTTP_QUERY_ACCEPT_CHARSET = 25,

			/// <summary>Retrieves the acceptable content-coding values for the response.</summary>
			WINHTTP_QUERY_ACCEPT_ENCODING = 26,

			/// <summary>Retrieves the acceptable natural languages for the response.</summary>
			WINHTTP_QUERY_ACCEPT_LANGUAGE = 27,

			/// <summary>Retrieves the types of range requests that are accepted for a resource.</summary>
			WINHTTP_QUERY_ACCEPT_RANGES = 42,

			/// <summary>
			/// Retrieves the Age response-header field, which contains the sender's estimate of the amount of time since the response was
			/// generated at the originating server.
			/// </summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_QUERY_AGE = 48,

			/// <summary>Receives the HTTP verbs supported by the server.</summary>
			WINHTTP_QUERY_ALLOW = 7,

			/// <summary>Retrieves the Authentication-Info header.</summary>
			WINHTTP_QUERY_AUTHENTICATION_INFO = 76,

			/// <summary>Retrieves the authorization credentials used for a request.</summary>
			WINHTTP_QUERY_AUTHORIZATION = 28,

			/// <summary>Retrieves the cache control directives.</summary>
			WINHTTP_QUERY_CACHE_CONTROL = 49,

			/// <summary>
			/// Retrieves any options that are specified for a particular connection and must not be communicated by proxies over further connections.
			/// </summary>
			WINHTTP_QUERY_CONNECTION = 23,

			/// <summary>Retrieves the base Uniform Resource Identifier (URI) to resolve relative URLs within the entity.</summary>
			WINHTTP_QUERY_CONTENT_BASE = 50,

			/// <summary>Obsolete. Maintained for legacy application compatibility.</summary>
			WINHTTP_QUERY_CONTENT_DESCRIPTION = 4,

			/// <summary>Obsolete. Maintained for legacy application compatibility.</summary>
			WINHTTP_QUERY_CONTENT_DISPOSITION = 47,

			/// <summary>Retrieves additional content coding that has been applied to the entire resource.</summary>
			WINHTTP_QUERY_CONTENT_ENCODING = 29,

			/// <summary>Retrieves the content identification.</summary>
			WINHTTP_QUERY_CONTENT_ID = 3,

			/// <summary>Retrieves the language that the content is written in.</summary>
			WINHTTP_QUERY_CONTENT_LANGUAGE = 6,

			/// <summary>Retrieves the size of the resource, in bytes.</summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_QUERY_CONTENT_LENGTH = 5,

			/// <summary>Retrieves the resource location for the entity enclosed in the message.</summary>
			WINHTTP_QUERY_CONTENT_LOCATION = 51,

			/// <summary>
			/// Retrieves an MD5 digest of the entity body for the purpose of providing an end-to-end message integrity check for the entity
			/// body. For more information, see RFC 1864.
			/// </summary>
			WINHTTP_QUERY_CONTENT_MD5 = 52,

			/// <summary>
			/// Retrieves the location in the full entity body where the partial entity body should be inserted and the total size of the
			/// full entity body.
			/// </summary>
			WINHTTP_QUERY_CONTENT_RANGE = 53,

			/// <summary>
			/// Retrieves an encoding transformation applicable to an entity-body. It may already have been applied, may need to be applied,
			/// or may be optionally applicable.
			/// </summary>
			WINHTTP_QUERY_CONTENT_TRANSFER_ENCODING = 2,

			/// <summary>Receives the content type of the resource, such as text or html.</summary>
			WINHTTP_QUERY_CONTENT_TYPE = 1,

			/// <summary>Retrieves any cookies associated with the request.</summary>
			WINHTTP_QUERY_COOKIE = 44,

			/// <summary>Not supported.</summary>
			WINHTTP_QUERY_COST = 15,

			/// <summary>
			/// Causes WinHttpQueryHeaders to search for the header name specified in the pwszName parameter and store the header information
			/// in lpBuffer. An application can use WINHTTP_OPTION_RECEIVE_RESPONSE_TIMEOUT to limit the maximum time this query waits for
			/// all headers to be received.
			/// </summary>
			WINHTTP_QUERY_CUSTOM = 65535,

			/// <summary>Receives the date and time at which the message was originated.</summary>
			[CorrespondingType(typeof(SYSTEMTIME))]
			WINHTTP_QUERY_DATE = 9,

			/// <summary>Not supported.</summary>
			WINHTTP_QUERY_DERIVED_FROM = 14,

			/// <summary>Retrieves the entity tag for the associated entity.</summary>
			WINHTTP_QUERY_ETAG = 54,

			/// <summary>Retrieves the Expect header, which indicates whether the client application should expect 100 series responses.</summary>
			WINHTTP_QUERY_EXPECT = 68,

			/// <summary>Receives the date and time after which the resource should be considered outdated.</summary>
			[CorrespondingType(typeof(SYSTEMTIME))]
			WINHTTP_QUERY_EXPIRES = 10,

			/// <summary>Obsolete. Maintained for legacy application compatibility.</summary>
			WINHTTP_QUERY_FORWARDED = 30,

			/// <summary>Retrieves the e-mail address for the user who controls the requesting user agent if the From header is given.</summary>
			WINHTTP_QUERY_FROM = 31,

			/// <summary>Retrieves the Internet host and port number of the resource being requested.</summary>
			WINHTTP_QUERY_HOST = 55,

			/// <summary>Retrieves the contents of the If-Match request-header field.</summary>
			WINHTTP_QUERY_IF_MATCH = 56,

			/// <summary>Retrieves the contents of the If-Modified-Since header.</summary>
			[CorrespondingType(typeof(SYSTEMTIME))]
			WINHTTP_QUERY_IF_MODIFIED_SINCE = 32,

			/// <summary>Retrieves the contents of the If-None-Match request-header field.</summary>
			WINHTTP_QUERY_IF_NONE_MATCH = 57,

			/// <summary>
			/// Retrieves the contents of the If-Range request-header field. This header allows the client application to check if the entity
			/// related to a partial copy of the entity in the client application's cache has not been updated. If the entity has not been
			/// updated, send the parts that the client application is missing. If the entity has been updated, send the entire updated entity.
			/// </summary>
			WINHTTP_QUERY_IF_RANGE = 58,

			/// <summary>Retrieves the contents of the If-Unmodified-Since request-header field.</summary>
			[CorrespondingType(typeof(SYSTEMTIME))]
			WINHTTP_QUERY_IF_UNMODIFIED_SINCE = 59,

			/// <summary>Obsolete. Maintained for legacy application compatibility.</summary>
			WINHTTP_QUERY_LINK = 11,

			/// <summary>Receives the date and time at which the resource was last modified. The date and time are determined by the server.</summary>
			[CorrespondingType(typeof(SYSTEMTIME))]
			WINHTTP_QUERY_LAST_MODIFIED = 16,

			/// <summary>Retrieves the absolute URI used in a Location response-header.</summary>
			WINHTTP_QUERY_LOCATION = 33,

			/// <summary>Indicates the maximum value of a WINHTTP_QUERY_* value. Not a query flag.</summary>
			WINHTTP_QUERY_MAX = 78,

			/// <summary>Retrieves the number of proxies or gateways that can forward the request to the next inbound server.</summary>
			[CorrespondingType(typeof(uint))]
			WINHTTP_QUERY_MAX_FORWARDS = 60,

			/// <summary>Not supported.</summary>
			WINHTTP_QUERY_MESSAGE_ID = 12,

			/// <summary>
			/// Receives the version of the Multipurpose Internet Mail Extensions (MIME) protocol that was used to construct the message.
			/// </summary>
			WINHTTP_QUERY_MIME_VERSION = 0,

			/// <summary>Obsolete. Maintained for legacy application compatibility.</summary>
			WINHTTP_QUERY_ORIG_URI = 34,

			/// <summary>
			/// Receives the implementation-specific directives that might apply to any recipient along the request/response chain.
			/// </summary>
			WINHTTP_QUERY_PRAGMA = 17,

			/// <summary>Retrieves the authentication scheme and realm returned by the proxy.</summary>
			WINHTTP_QUERY_PROXY_AUTHENTICATE = 41,

			/// <summary>
			/// Retrieves the header that is used to identify the user to a proxy that requires authentication. This header can only be
			/// retrieved before the request is sent to the server.
			/// </summary>
			WINHTTP_QUERY_PROXY_AUTHORIZATION = 61,

			/// <summary>Retrieves the Proxy-Connection header.</summary>
			WINHTTP_QUERY_PROXY_CONNECTION = 69,

			/// <summary>Retrieves the Proxy-Support header.</summary>
			WINHTTP_QUERY_PROXY_SUPPORT = 75,

			/// <summary>Receives HTTP verbs available at this server.</summary>
			WINHTTP_QUERY_PUBLIC = 8,

			/// <summary>Retrieves the byte range of an entity.</summary>
			WINHTTP_QUERY_RANGE = 62,

			/// <summary>
			/// Receives all the headers returned by the server. Each header is terminated by "\0". An additional "\0" terminates the list of headers.
			/// </summary>
			[CorrespondingType(typeof(string[]))]
			WINHTTP_QUERY_RAW_HEADERS = 21,

			/// <summary>
			/// Receives all the headers returned by the server. Each header is separated by a carriage return/line feed (CR/LF) sequence.
			/// </summary>
			[CorrespondingType(typeof(string))]
			WINHTTP_QUERY_RAW_HEADERS_CRLF = 22,

			/// <summary>Receives the URI of the resource where the requested URI was obtained.</summary>
			[CorrespondingType(typeof(string))]
			WINHTTP_QUERY_REFERER = 35,

			/// <summary>Obsolete. Maintained for legacy application compatibility.</summary>
			WINHTTP_QUERY_REFRESH = 46,

			/// <summary>Receives the HTTP verb that is being used in the request, typically GET or POST.</summary>
			[CorrespondingType(typeof(string))]
			WINHTTP_QUERY_REQUEST_METHOD = 45,

			/// <summary>Retrieves the amount of time the service is expected to be unavailable.</summary>
			WINHTTP_QUERY_RETRY_AFTER = 36,

			/// <summary>Retrieves information about the software used by the originating server to handle the request.</summary>
			WINHTTP_QUERY_SERVER = 37,

			/// <summary>Receives the value of the cookie set for the request.</summary>
			WINHTTP_QUERY_SET_COOKIE = 43,

			/// <summary>Receives the status code returned by the server. For a list of possible values, see HTTP Status Codes.</summary>
			[CorrespondingType(typeof(HTTP_STATUS))]
			WINHTTP_QUERY_STATUS_CODE = 19,

			/// <summary>Receives additional text returned by the server on the response line.</summary>
			WINHTTP_QUERY_STATUS_TEXT = 20,

			/// <summary>Obsolete. Maintained for legacy application compatibility.</summary>
			WINHTTP_QUERY_TITLE = 38,

			/// <summary>
			/// Retrieves the type of transformation that has been applied to the message body so it can be safely transferred between the
			/// sender and recipient.
			/// </summary>
			WINHTTP_QUERY_TRANSFER_ENCODING = 63,

			/// <summary>Retrieves the Unless-Modified-Since header.</summary>
			WINHTTP_QUERY_UNLESS_MODIFIED_SINCE = 70,

			/// <summary>Retrieves the additional communication protocols that are supported by the server.</summary>
			WINHTTP_QUERY_UPGRADE = 64,

			/// <summary>Receives some or all of the URI by which the Request-URI resource can be identified.</summary>
			WINHTTP_QUERY_URI = 13,

			/// <summary>Retrieves information about the user agent that made the request.</summary>
			WINHTTP_QUERY_USER_AGENT = 39,

			/// <summary>
			/// Retrieves the header that indicates that the entity was selected from a number of available representations of the response
			/// using server-driven negotiation.
			/// </summary>
			WINHTTP_QUERY_VARY = 65,

			/// <summary>Retrieves the HTTP version that is present in the status line.</summary>
			WINHTTP_QUERY_VERSION = 18,

			/// <summary>
			/// Retrieves the intermediate protocols and recipients between the user agent and the server on requests, and between the origin
			/// server and the client on responses.
			/// </summary>
			WINHTTP_QUERY_VIA = 66,

			/// <summary>
			/// Retrieves additional information about the status of a response that might not be reflected by the response status code.
			/// </summary>
			WINHTTP_QUERY_WARNING = 67,

			/// <summary>Retrieves the authentication scheme and realm returned by the server.</summary>
			WINHTTP_QUERY_WWW_AUTHENTICATE = 40,

			/// <summary>Returns the data as a 32-bit number for headers whose value is a number, such as the status code.</summary>
			WINHTTP_QUERY_FLAG_NUMBER = 0x20000000,

			/// <summary>Queries request headers only.</summary>
			WINHTTP_QUERY_FLAG_REQUEST_HEADERS = 0x80000000,

			/// <summary>
			/// Returns the header value as a SYSTEMTIME structure, which does not require the application to parse the data. Use for headers
			/// whose value is a date/time string, such as "Last-Modified-Time".
			/// </summary>
			WINHTTP_QUERY_FLAG_SYSTEMTIME = 0x40000000,

			/// <summary>
			/// Queries response trailers. Prior to querying response trailers, you must call WinHttpReadData until it returns 0 bytes read.
			/// </summary>
			WINHTTP_QUERY_FLAG_TRAILERS = 0x02000000,

			/// <summary>
			/// By default, WinHttpQueryHeaders performs a Unicode conversion before returning the header that was queried. If this flag is
			/// set, WinHttp returns the header to the caller without performing this conversion.
			/// </summary>
			WINHTTP_QUERY_FLAG_WIRE_ENCODING = 0x01000000,

			/// <summary/>
			WINHTTP_QUERY_EX_ALL_HEADERS = WINHTTP_QUERY_RAW_HEADERS,

			/// <summary>Returns the data as a 64-bit number for headers whose value is a number, such as the status code.</summary>
			WINHTTP_QUERY_FLAG_NUMBER64 = 0x08000000,
		}

		/// <summary>Flags for WinHttpQueryConnectionGroup.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NF:winhttp.WinHttpQueryConnectionGroup")]
		[Flags]
		public enum WINHTTP_QUERY_CONNECTION_GROUP_FLAG : ulong
		{
			/// <summary>Indicate that you want non-HTTPS connections (see hInternet).</summary>
			WINHTTP_QUERY_CONNECTION_GROUP_FLAG_INSECURE = 1
		}

		/// <summary>Flags for WinHttpReadDataEx.</summary>
		[PInvokeData("winhttp.h")]
		[Flags]
		public enum WINHTTP_READ_DATA_EX_FLAG : ulong
		{
			/// <summary>
			/// WinHttp won't complete the call to <c>WinHttpReadDataEx</c> until the provided data buffer has been filled, or the response
			/// is complete.
			/// </summary>
			WINHTTP_READ_DATA_EX_FLAG_FILL_BUFFER = 0x0000000000000001
		}

		/// <summary>The <c>WINHTTP_REQUEST_STAT_ENTRY</c> enumeration lists the available types of request statistics.</summary>
		/// <remarks>
		/// This structure is used with WinHttpQueryOption to retrieve statistics for a request by specifying the
		/// <c>WINHTTP_OPTION_REQUEST_STATS</c> flag.
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/winhttp/ne-winhttp-winhttp_request_stat_entry typedef enum
		// _WINHTTP_REQUEST_STAT_ENTRY { WinHttpConnectFailureCount = 0, WinHttpProxyFailureCount, WinHttpTlsHandshakeClientLeg1Size,
		// WinHttpTlsHandshakeServerLeg1Size, WinHttpTlsHandshakeClientLeg2Size, WinHttpTlsHandshakeServerLeg2Size,
		// WinHttpRequestHeadersSize, WinHttpRequestHeadersCompressedSize, WinHttpResponseHeadersSize, WinHttpResponseHeadersCompressedSize,
		// WinHttpResponseBodySize, WinHttpResponseBodyCompressedSize, WinHttpProxyTlsHandshakeClientLeg1Size,
		// WinHttpProxyTlsHandshakeServerLeg1Size, WinHttpProxyTlsHandshakeClientLeg2Size, WinHttpProxyTlsHandshakeServerLeg2Size,
		// WinHttpRequestStatLast, WinHttpRequestStatMax = 32 } WINHTTP_REQUEST_STAT_ENTRY;
		[PInvokeData("winhttp.h", MSDNShortId = "NE:winhttp._WINHTTP_REQUEST_STAT_ENTRY")]
		public enum WINHTTP_REQUEST_STAT_ENTRY : uint
		{
			/// <summary>
			/// <para>Value:</para>
			/// <para>0</para>
			/// <para>The number of connection failures during connection establishment.</para>
			/// </summary>
			WinHttpConnectFailureCount = 0,

			/// <summary>The number of proxy connection failures during connection establishment.</summary>
			WinHttpProxyFailureCount,

			/// <summary>The size of the client data for the first leg of the TLS handshake.</summary>
			WinHttpTlsHandshakeClientLeg1Size,

			/// <summary>The size of the server data for the first leg of the TLS handshake.</summary>
			WinHttpTlsHandshakeServerLeg1Size,

			/// <summary>The size of the client data for the second leg of the TLS handshake.</summary>
			WinHttpTlsHandshakeClientLeg2Size,

			/// <summary>The size of the server data for the second leg of the TLS handshake.</summary>
			WinHttpTlsHandshakeServerLeg2Size,

			/// <summary>The size of the request headers.</summary>
			WinHttpRequestHeadersSize,

			/// <summary>The compressed size of the request headers.</summary>
			WinHttpRequestHeadersCompressedSize,

			/// <summary>The size of the response headers.</summary>
			WinHttpResponseHeadersSize,

			/// <summary>The compressed size of the response headers.</summary>
			WinHttpResponseHeadersCompressedSize,

			/// <summary>The size of the response body.</summary>
			WinHttpResponseBodySize,

			/// <summary>The compressed size of the response body.</summary>
			WinHttpResponseBodyCompressedSize,

			/// <summary>The size of the client data for the first leg of the proxy TLS handshake.</summary>
			WinHttpProxyTlsHandshakeClientLeg1Size,

			/// <summary>The size of the server data for the first leg of the proxy TLS handshake.</summary>
			WinHttpProxyTlsHandshakeServerLeg1Size,

			/// <summary>The size of the client data for the second leg of the proxy TLS handshake.</summary>
			WinHttpProxyTlsHandshakeClientLeg2Size,

			/// <summary>The size of the server data for the second leg of the proxy TLS handshake.</summary>
			WinHttpProxyTlsHandshakeServerLeg2Size,

			/// <summary>Marker for the end of the list of available statistics.</summary>
			WinHttpRequestStatLast,

			/// <summary>
			/// <para>Value:</para>
			/// <para>32</para>
			/// <para>The maximum number of statistics available.</para>
			/// </summary>
			WinHttpRequestStatMax = 32,
		}

		/// <summary>Flags containing details on how the request was made.</summary>
		[PInvokeData("winhttp.h")]
		[Flags]
		public enum WINHTTP_REQUEST_STAT_FLAG : ulong
		{
			/// <summary>TCP Fast Open occurred.</summary>
			WINHTTP_REQUEST_STAT_FLAG_TCP_FAST_OPEN = 0x00000001,

			/// <summary>TLS Session Resumption occurred.</summary>
			WINHTTP_REQUEST_STAT_FLAG_TLS_SESSION_RESUMPTION = 0x00000002,

			/// <summary>TLS False Start occurred.</summary>
			WINHTTP_REQUEST_STAT_FLAG_TLS_FALSE_START = 0x00000004,

			/// <summary>TLS Session Resumption occurred for the proxy connection.</summary>
			WINHTTP_REQUEST_STAT_FLAG_PROXY_TLS_SESSION_RESUMPTION = 0x00000008,

			/// <summary>TLS False Start occurred for the proxy connection.</summary>
			WINHTTP_REQUEST_STAT_FLAG_PROXY_TLS_FALSE_START = 0x00000010,

			/// <summary>This is the first request on the connection.</summary>
			WINHTTP_REQUEST_STAT_FLAG_FIRST_REQUEST = 0x00000020,
		}

		/// <summary>The <c>WINHTTP_REQUEST_TIME_ENTRY</c> enumeration lists the available types of request timing information.</summary>
		/// <remarks>
		/// This structure is used with WinHttpQueryOption to retrieve timing information for a request by specifying the
		/// <c>WINHTTP_OPTION_REQUEST_TIMES</c> flag.
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/winhttp/ne-winhttp-winhttp_request_time_entry typedef enum
		// _WINHTTP_REQUEST_TIME_ENTRY { WinHttpProxyDetectionStart = 0, WinHttpProxyDetectionEnd, WinHttpConnectionAcquireStart,
		// WinHttpConnectionAcquireWaitEnd, WinHttpConnectionAcquireEnd, WinHttpNameResolutionStart, WinHttpNameResolutionEnd,
		// WinHttpConnectionEstablishmentStart, WinHttpConnectionEstablishmentEnd, WinHttpTlsHandshakeClientLeg1Start,
		// WinHttpTlsHandshakeClientLeg1End, WinHttpTlsHandshakeClientLeg2Start, WinHttpTlsHandshakeClientLeg2End,
		// WinHttpTlsHandshakeClientLeg3Start, WinHttpTlsHandshakeClientLeg3End, WinHttpStreamWaitStart, WinHttpStreamWaitEnd,
		// WinHttpSendRequestStart, WinHttpSendRequestHeadersCompressionStart, WinHttpSendRequestHeadersCompressionEnd,
		// WinHttpSendRequestHeadersEnd, WinHttpSendRequestEnd, WinHttpReceiveResponseStart, WinHttpReceiveResponseHeadersDecompressionStart,
		// WinHttpReceiveResponseHeadersDecompressionEnd, WinHttpReceiveResponseHeadersEnd, WinHttpReceiveResponseBodyDecompressionDelta,
		// WinHttpReceiveResponseEnd, WinHttpProxyTunnelStart, WinHttpProxyTunnelEnd, WinHttpProxyTlsHandshakeClientLeg1Start,
		// WinHttpProxyTlsHandshakeClientLeg1End, WinHttpProxyTlsHandshakeClientLeg2Start, WinHttpProxyTlsHandshakeClientLeg2End,
		// WinHttpProxyTlsHandshakeClientLeg3Start, WinHttpProxyTlsHandshakeClientLeg3End, WinHttpRequestTimeLast, WinHttpRequestTimeMax = 64
		// } WINHTTP_REQUEST_TIME_ENTRY;
		[PInvokeData("winhttp.h", MSDNShortId = "NE:winhttp._WINHTTP_REQUEST_TIME_ENTRY")]
		public enum WINHTTP_REQUEST_TIME_ENTRY : uint
		{
			/// <summary>
			/// <para>Value:</para>
			/// <para>0</para>
			/// <para>Start of proxy detection.</para>
			/// </summary>
			WinHttpProxyDetectionStart = 0,

			/// <summary>End of proxy detection.</summary>
			WinHttpProxyDetectionEnd,

			/// <summary>Start of connection acquisition.</summary>
			WinHttpConnectionAcquireStart,

			/// <summary>End waiting for an available connection.</summary>
			WinHttpConnectionAcquireWaitEnd,

			/// <summary>End of connection acquisition.</summary>
			WinHttpConnectionAcquireEnd,

			/// <summary>Start of name resolution.</summary>
			WinHttpNameResolutionStart,

			/// <summary>End of name resolution.</summary>
			WinHttpNameResolutionEnd,

			/// <summary>Start of connection establishment.</summary>
			WinHttpConnectionEstablishmentStart,

			/// <summary>End of connection establishment.</summary>
			WinHttpConnectionEstablishmentEnd,

			/// <summary>Start of the first leg of the TLS handshake.</summary>
			WinHttpTlsHandshakeClientLeg1Start,

			/// <summary>End of the first leg of the TLS handshake.</summary>
			WinHttpTlsHandshakeClientLeg1End,

			/// <summary>Start of the second leg of the TLS handshake.</summary>
			WinHttpTlsHandshakeClientLeg2Start,

			/// <summary>End of the second leg of the TLS handshake.</summary>
			WinHttpTlsHandshakeClientLeg2End,

			/// <summary>Start of the third leg of the TLS handshake.</summary>
			WinHttpTlsHandshakeClientLeg3Start,

			/// <summary>End of the third leg of the TLS handshake.</summary>
			WinHttpTlsHandshakeClientLeg3End,

			/// <summary>Start waiting for an available stream.</summary>
			WinHttpStreamWaitStart,

			/// <summary>End waiting for an available stream.</summary>
			WinHttpStreamWaitEnd,

			/// <summary>Start sending a request.</summary>
			WinHttpSendRequestStart,

			/// <summary>Start of request header compression.</summary>
			WinHttpSendRequestHeadersCompressionStart,

			/// <summary>End of request header compression.</summary>
			WinHttpSendRequestHeadersCompressionEnd,

			/// <summary>End sending request headers.</summary>
			WinHttpSendRequestHeadersEnd,

			/// <summary>End sending a request.</summary>
			WinHttpSendRequestEnd,

			/// <summary>Start receiving a response.</summary>
			WinHttpReceiveResponseStart,

			/// <summary>Start of response header decompression.</summary>
			WinHttpReceiveResponseHeadersDecompressionStart,

			/// <summary>End of response header decompression.</summary>
			WinHttpReceiveResponseHeadersDecompressionEnd,

			/// <summary>End receiving response headers.</summary>
			WinHttpReceiveResponseHeadersEnd,

			/// <summary>Delta between start and end times for response body decompression.</summary>
			WinHttpReceiveResponseBodyDecompressionDelta,

			/// <summary>End receiving a response.</summary>
			WinHttpReceiveResponseEnd,

			/// <summary>Start establishing a proxy tunnel.</summary>
			WinHttpProxyTunnelStart,

			/// <summary>End establishing a proxy tunnel.</summary>
			WinHttpProxyTunnelEnd,

			/// <summary>Start of the first leg of the proxy TLS handshake.</summary>
			WinHttpProxyTlsHandshakeClientLeg1Start,

			/// <summary>End of the first leg of the proxy TLS handshake.</summary>
			WinHttpProxyTlsHandshakeClientLeg1End,

			/// <summary>Start of the second leg of the proxy TLS handshake.</summary>
			WinHttpProxyTlsHandshakeClientLeg2Start,

			/// <summary>End of the second leg of the proxy TLS handshake.</summary>
			WinHttpProxyTlsHandshakeClientLeg2End,

			/// <summary>Start of the third leg of the proxy TLS handshake.</summary>
			WinHttpProxyTlsHandshakeClientLeg3Start,

			/// <summary>End of the third leg of the proxy TLS handshake.</summary>
			WinHttpProxyTlsHandshakeClientLeg3End,

			/// <summary>Marker for the end of the list of available timings.</summary>
			WinHttpRequestTimeLast,

			/// <summary>
			/// <para>Value:</para>
			/// <para>64</para>
			/// <para>The maximum number of timings available.</para>
			/// </summary>
			WinHttpRequestTimeMax = 64,
		}

		/// <summary>A set of flags that affects the reset operation.</summary>
		[PInvokeData("winhttp.h", MSDNShortId = "NF:winhttp.WinHttpResetAutoProxy")]
		[Flags]
		public enum WINHTTP_RESET : uint
		{
			/// <summary>Forces a flush and retry of non-persistent proxy information on the current network.</summary>
			WINHTTP_RESET_STATE = 0x00000001,

			/// <summary>Flush the PAD information for the current network.</summary>
			WINHTTP_RESET_SWPAD_CURRENT_NETWORK = 0x00000002,

			/// <summary>Flush the PAD information for all networks.</summary>
			WINHTTP_RESET_SWPAD_ALL = 0x00000004,

			/// <summary>Flush the persistent HTTP cache of proxy scripts.</summary>
			WINHTTP_RESET_SCRIPT_CACHE = 0x00000008,

			/// <summary>Forces a flush and retry of all proxy information on the current network.</summary>
			WINHTTP_RESET_ALL = 0x0000FFFF,

			/// <summary>Flush the current proxy information and notify that the network changed.</summary>
			WINHTTP_RESET_NOTIFY_NETWORK_CHANGED = 0x00010000,

			/// <summary>
			/// Act on the autoproxy service instead of the current process. Applications that use the WinHttpGetProxyForUrl function to
			/// purge in-process caching should close the <c>hInternet</c> handle and open a new handle for future calls.
			/// </summary>
			WINHTTP_RESET_OUT_OF_PROC = 0x00020000,

			/// <summary/>
			WINHTTP_RESET_DISCARD_RESOLVERS = 0x00040000,
		}

		/// <summary>Includes or removes the server port number when the SPN (service principal name) is built for Kerberos or Negotiate Kerberos authentication.</summary>
		[PInvokeData("winhttp.h")]
		[Flags]
		public enum WINHTTP_SPN : uint
		{
			/// <summary>Removes the server port number.</summary>
			WINHTTP_DISABLE_SPN_SERVER_PORT = 0x00000000,

			/// <summary>Includes the server port number.</summary>
			WINHTTP_ENABLE_SPN_SERVER_PORT = 0x00000001,
		}
		/// <summary>The <c>WINHTTP_WEB_SOCKET_BUFFER_TYPE</c> enumeration includes types of WebSocket buffers.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/winhttp/ne-winhttp-winhttp_web_socket_buffer_type typedef enum
		// _WINHTTP_WEB_SOCKET_BUFFER_TYPE { WINHTTP_WEB_SOCKET_BINARY_MESSAGE_BUFFER_TYPE = 0,
		// WINHTTP_WEB_SOCKET_BINARY_FRAGMENT_BUFFER_TYPE = 1, WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE = 2,
		// WINHTTP_WEB_SOCKET_UTF8_FRAGMENT_BUFFER_TYPE = 3, WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE = 4 } WINHTTP_WEB_SOCKET_BUFFER_TYPE;
		[PInvokeData("winhttp.h", MSDNShortId = "NE:winhttp._WINHTTP_WEB_SOCKET_BUFFER_TYPE")]
		public enum WINHTTP_WEB_SOCKET_BUFFER_TYPE
		{
			/// <summary>
			/// <para>Value:</para>
			/// <para>0</para>
			/// <para>Buffer contains either the entire binary message or the last part of it.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_BINARY_MESSAGE_BUFFER_TYPE,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1</para>
			/// <para>Buffer contains only part of a binary message.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_BINARY_FRAGMENT_BUFFER_TYPE,

			/// <summary>
			/// <para>Value:</para>
			/// <para>2</para>
			/// <para>Buffer contains either the entire UTF-8 message or the last part of it.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE,

			/// <summary>
			/// <para>Value:</para>
			/// <para>3</para>
			/// <para>Buffer contains only part of a UTF-8 message.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_UTF8_FRAGMENT_BUFFER_TYPE,

			/// <summary>
			/// <para>Value:</para>
			/// <para>4</para>
			/// <para>The server sent a close frame.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE,
		}

		/// <summary>The <c>WINHTTP_WEB_SOCKET_CLOSE_STATUS</c> enumeration includes the status of a WebSocket close operation.</summary>
		/// <remarks><c>WINHTTP_WEB_SOCKET_CLOSE_STATUS</c> is used by WinHttpWebSocketClose, WinHttpWebSocketShutdown, and WinHttpWebSocketQueryCloseStatus.</remarks>
		// https://docs.microsoft.com/en-us/windows/win32/api/winhttp/ne-winhttp-winhttp_web_socket_close_status typedef enum
		// _WINHTTP_WEB_SOCKET_CLOSE_STATUS { WINHTTP_WEB_SOCKET_SUCCESS_CLOSE_STATUS = 1000,
		// WINHTTP_WEB_SOCKET_ENDPOINT_TERMINATED_CLOSE_STATUS = 1001, WINHTTP_WEB_SOCKET_PROTOCOL_ERROR_CLOSE_STATUS = 1002,
		// WINHTTP_WEB_SOCKET_INVALID_DATA_TYPE_CLOSE_STATUS = 1003, WINHTTP_WEB_SOCKET_EMPTY_CLOSE_STATUS = 1005,
		// WINHTTP_WEB_SOCKET_ABORTED_CLOSE_STATUS = 1006, WINHTTP_WEB_SOCKET_INVALID_PAYLOAD_CLOSE_STATUS = 1007,
		// WINHTTP_WEB_SOCKET_POLICY_VIOLATION_CLOSE_STATUS = 1008, WINHTTP_WEB_SOCKET_MESSAGE_TOO_BIG_CLOSE_STATUS = 1009,
		// WINHTTP_WEB_SOCKET_UNSUPPORTED_EXTENSIONS_CLOSE_STATUS = 1010, WINHTTP_WEB_SOCKET_SERVER_ERROR_CLOSE_STATUS = 1011,
		// WINHTTP_WEB_SOCKET_SECURE_HANDSHAKE_ERROR_CLOSE_STATUS = 1015 } WINHTTP_WEB_SOCKET_CLOSE_STATUS;
		[PInvokeData("winhttp.h", MSDNShortId = "NE:winhttp._WINHTTP_WEB_SOCKET_CLOSE_STATUS")]
		public enum WINHTTP_WEB_SOCKET_CLOSE_STATUS : ushort
		{
			/// <summary>
			/// <para>Value:</para>
			/// <para>1000</para>
			/// <para>The connection closed successfully.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_SUCCESS_CLOSE_STATUS = 1000,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1001</para>
			/// <para>The peer is going away and terminating the connection.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_ENDPOINT_TERMINATED_CLOSE_STATUS,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1002</para>
			/// <para>A protocol error occurred.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_PROTOCOL_ERROR_CLOSE_STATUS,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1003</para>
			/// <para>Invalid data received by the peer.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_INVALID_DATA_TYPE_CLOSE_STATUS,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1005</para>
			/// <para>The close message was empty.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_EMPTY_CLOSE_STATUS = 1005,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1006</para>
			/// <para>The connection was aborted.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_ABORTED_CLOSE_STATUS,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1007</para>
			/// <para>The payload was invalid.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_INVALID_PAYLOAD_CLOSE_STATUS,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1008</para>
			/// <para>The message violates an endpoint's policy.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_POLICY_VIOLATION_CLOSE_STATUS,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1009</para>
			/// <para>The message sent was too large to process.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_MESSAGE_TOO_BIG_CLOSE_STATUS,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1010</para>
			/// <para>
			/// A client endpoint expected the server to negotiate one or more extensions, but the server didn't return them in the response
			/// message of the WebSocket handshake.
			/// </para>
			/// </summary>
			WINHTTP_WEB_SOCKET_UNSUPPORTED_EXTENSIONS_CLOSE_STATUS,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1011</para>
			/// <para>An unexpected condition prevented the server from</para>
			/// <para>fulfilling the request.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_SERVER_ERROR_CLOSE_STATUS,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1015</para>
			/// <para>The TLS handshake could not be completed.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_SECURE_HANDSHAKE_ERROR_CLOSE_STATUS = 1015,
		}

		/// <summary>The <c>WINHTTP_WEB_SOCKET_OPERATION</c> enumeration includes the WebSocket operation type.</summary>
		// https://docs.microsoft.com/en-us/windows/win32/api/winhttp/ne-winhttp-winhttp_web_socket_operation typedef enum
		// _WINHTTP_WEB_SOCKET_OPERATION { WINHTTP_WEB_SOCKET_SEND_OPERATION = 0, WINHTTP_WEB_SOCKET_RECEIVE_OPERATION = 1,
		// WINHTTP_WEB_SOCKET_CLOSE_OPERATION = 2, WINHTTP_WEB_SOCKET_SHUTDOWN_OPERATION = 3 } WINHTTP_WEB_SOCKET_OPERATION;
		[PInvokeData("winhttp.h", MSDNShortId = "NE:winhttp._WINHTTP_WEB_SOCKET_OPERATION")]
		public enum WINHTTP_WEB_SOCKET_OPERATION
		{
			/// <summary>
			/// <para>Value:</para>
			/// <para>0</para>
			/// <para>A</para>
			/// <para>WinHttpWebSocketSend</para>
			/// <para>operation.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_SEND_OPERATION,

			/// <summary>
			/// <para>Value:</para>
			/// <para>1</para>
			/// <para>A</para>
			/// <para>WinHttpWebSocketReceive</para>
			/// <para>operation.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_RECEIVE_OPERATION,

			/// <summary>
			/// <para>Value:</para>
			/// <para>2</para>
			/// <para>A</para>
			/// <para>WinHttpWebSocketClose</para>
			/// <para>operation.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_CLOSE_OPERATION,

			/// <summary>
			/// <para>Value:</para>
			/// <para>3</para>
			/// <para>A</para>
			/// <para>WinHttpWebSocketShutdown</para>
			/// <para>operation.</para>
			/// </summary>
			WINHTTP_WEB_SOCKET_SHUTDOWN_OPERATION,
		}

		/// <summary>The <c>WinHttpRequestAutoLogonPolicy</c> enumeration includes possible settings for the Automatic Logon Policy.</summary>
		/// <remarks>
		/// <para>To set the automatic logon policy, call the <c>SetAutoLogonPolicy</c> method and specify one of the preceding constants.</para>
		/// <para>
		/// <para>Note</para>
		/// <para>For Windows XP and Windows 2000, see the Run-Time Requirements section of the WinHTTP start page.</para>
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/winhttp/winhttprequestautologonpolicy typedef enum WinHttpRequestAutoLogonPolicy {
		// AutoLogonPolicy_Always = 0, AutoLogonPolicy_OnlyIfBypassProxy = 1, AutoLogonPolicy_Never = 2 } WinHttpRequestAutoLogonPolicy;
		[PInvokeData("winhttp.h")]
		public enum WinHttpRequestAutoLogonPolicy
		{
			/// <summary>An authenticated log on, using the default credentials, is performed for all requests.</summary>
			AutoLogonPolicy_Always,

			/// <summary>
			/// An authenticated log on, using the default credentials, is performed only for requests on the local intranet. The local
			/// intranet is considered to be any server on the proxy bypass list in the current proxy configuration.
			/// </summary>
			AutoLogonPolicy_OnlyIfBypassProxy,

			/// <summary>Authentication is not used automatically.</summary>
			AutoLogonPolicy_Never,
		}

		/// <summary>
		/// The <c>WinHttpRequestOption</c> enumeration includes options that can be set or retrieved for the current Microsoft Windows HTTP
		/// Services (WinHTTP) session.
		/// </summary>
		/// <remarks>
		/// <para>Set an option by specifying one of the preceding constants as the parameter of the <c>Option</c> property.</para>
		/// <para>
		/// <para>Note</para>
		/// <para>For Windows XP and Windows 2000, see the Run-Time Requirements section of the WinHttp start page.</para>
		/// </para>
		/// </remarks>
		// https://docs.microsoft.com/en-us/windows/win32/winhttp/winhttprequestoption typedef enum WinHttpRequestOption {
		// WinHttpRequestOption_UserAgentString, WinHttpRequestOption_URL, WinHttpRequestOption_URLCodePage,
		// WinHttpRequestOption_EscapePercentInURL, WinHttpRequestOption_SslErrorIgnoreFlags, WinHttpRequestOption_SelectCertificate,
		// WinHttpRequestOption_EnableRedirects, WinHttpRequestOption_UrlEscapeDisable, WinHttpRequestOption_UrlEscapeDisableQuery,
		// WinHttpRequestOption_SecureProtocols, WinHttpRequestOption_EnableTracing, WinHttpRequestOption_RevertImpersonationOverSsl,
		// WinHttpRequestOption_EnableHttpsToHttpRedirects, WinHttpRequestOption_EnablePassportAuthentication,
		// WinHttpRequestOption_MaxAutomaticRedirects, WinHttpRequestOption_MaxResponseHeaderSize, WinHttpRequestOption_MaxResponseDrainSize,
		// WinHttpRequestOption_EnableHttp1_1, WinHttpRequestOption_EnableCertificateRevocationCheck } WinHttpRequestOption;
		[PInvokeData("winhttp.h")]
		public enum WinHttpRequestOption
		{
			/// <summary>Sets or retrieves a <c>VARIANT</c> that contains the user agent string.</summary>
			WinHttpRequestOption_UserAgentString,

			/// <summary>
			/// Retrieves a <c>VARIANT</c> that contains the URL of the resource. This value is read-only; you cannot set the URL using this
			/// property. The URL cannot be read until the <c>Open</c> method is called. This option is useful for checking the URL after the
			/// <c>Send</c> method is finished to verify that any redirection occurred.
			/// </summary>
			WinHttpRequestOption_URL,

			/// <summary>
			/// Sets or retrieves a <c>VARIANT</c> that identifies the code page for the URL string. The default value is the UTF-8 code
			/// page. The code page is used to convert the Unicode URL string, passed in the <c>Open</c> method, to a single-byte string representation.
			/// </summary>
			WinHttpRequestOption_URLCodePage,

			/// <summary>
			/// Sets or retrieves a <c>VARIANT</c> that indicates whether percent characters in the URL string are converted to an escape
			/// sequence. The default value of this option is <c>VARIANT_TRUE</c> which specifies all unsafe American National Standards
			/// Institute (ANSI) characters except the percent symbol are converted to an escape sequence.
			/// </summary>
			WinHttpRequestOption_EscapePercentInURL,

			/// <summary>
			/// <para>
			/// Sets or retrieves a <c>VARIANT</c> that indicates which server certificate errors should be ignored. This can be a
			/// combination of one or more of the following flags.
			/// </para>
			/// <list type="table">
			/// <listheader>
			/// <term>Error</term>
			/// <term>Value</term>
			/// </listheader>
			/// <item>
			/// <term>Unknown certification authority (CA) or untrusted root</term>
			/// <term>0x0100</term>
			/// </item>
			/// <item>
			/// <term>Wrong usage</term>
			/// <term>0x0200</term>
			/// </item>
			/// <item>
			/// <term>Invalid common name (CN)</term>
			/// <term>0x1000</term>
			/// </item>
			/// <item>
			/// <term>Invalid date or certificate expired</term>
			/// <term>0x2000</term>
			/// </item>
			/// </list>
			/// <para>
			/// The default value of this option in Version 5.1 of WinHTTP is zero, which results in no errors being ignored. In earlier
			/// versions of WinHTTP, the default setting was 0x3300, which resulted in all server certificate errors being ignored by default.
			/// </para>
			/// </summary>
			WinHttpRequestOption_SslErrorIgnoreFlags,

			/// <summary>
			/// Sets a <c>VARIANT</c> that specifies the client certificate that is sent to a server for authentication. This option
			/// indicates the location, certificate store, and subject of a client certificate delimited with backslashes. For more
			/// information about selecting a client certificate, see SSL in WinHTTP.
			/// </summary>
			WinHttpRequestOption_SelectCertificate,

			/// <summary>
			/// Sets or retrieves a <c>VARIANT</c> that indicates whether requests are automatically redirected when the server specifies a
			/// new location for the resource. The default value of this option is <c>VARIANT_TRUE</c> to indicate that requests are
			/// automatically redirected.
			/// </summary>
			WinHttpRequestOption_EnableRedirects,

			/// <summary>
			/// Sets or retrieves a <c>VARIANT</c> that indicates whether unsafe characters in the path and query components of a URL are
			/// converted to escape sequences. The default value of this option is <c>VARIANT_TRUE</c>, which specifies that characters in
			/// the path and query are converted.
			/// </summary>
			WinHttpRequestOption_UrlEscapeDisable,

			/// <summary>
			/// Sets or retrieves a <c>VARIANT</c> that indicates whether unsafe characters in the query component of the URL are converted
			/// to escape sequences. The default value of this option is <c>VARIANT_TRUE</c>, which specifies that characters in the query
			/// are converted.
			/// </summary>
			WinHttpRequestOption_UrlEscapeDisableQuery,

			/// <summary>
			/// <para>
			/// Sets or retrieves a <c>VARIANT</c> that indicates which secure protocols can be used. This option selects the protocols
			/// acceptable to the client. The protocol is negotiated during the Secure Sockets Layer (SSL) handshake. This can be a
			/// combination of one or more of the following flags.
			/// </para>
			/// <list type="table">
			/// <listheader>
			/// <term>Protocol</term>
			/// <term>Value</term>
			/// </listheader>
			/// <item>
			/// <term>SSL 2.0</term>
			/// <term>0x0008</term>
			/// </item>
			/// <item>
			/// <term>SSL 3.0</term>
			/// <term>0x0020</term>
			/// </item>
			/// <item>
			/// <term>Transport Layer Security (TLS) 1.0</term>
			/// <term>0x0080</term>
			/// </item>
			/// </list>
			/// <para>
			/// The default value of this option is 0x0028, which indicates that SSL 2.0 or SSL 3.0 can be used. If this option is set to
			/// zero, the client and server are not able to determine an acceptable security protocol and the next <c>Send</c> results in an error.
			/// </para>
			/// </summary>
			WinHttpRequestOption_SecureProtocols,

			/// <summary>
			/// Sets or retrieves a <c>VARIANT</c> that indicates whether tracing is currently enabled. For more information about the trace
			/// facility in Microsoft Windows HTTP Services (WinHTTP), see WinHTTP Trace Facility.
			/// </summary>
			WinHttpRequestOption_EnableTracing,

			/// <summary>
			/// Controls whether the <c>WinHttpRequest</c> object temporarily reverts client impersonation for the duration of the SSL
			/// certificate authentication operations. The default setting for the <c>WinHttpRequest</c> object is <c>TRUE</c>. Set this
			/// option to <c>FALSE</c> to keep impersonation while performing certificate authentication operations.
			/// </summary>
			WinHttpRequestOption_RevertImpersonationOverSsl,

			/// <summary>
			/// Controls whether or not WinHTTP allows redirects. By default, all redirects are automatically followed, except those that
			/// transfer from a secure (https) URL to an non-secure (http) URL. Set this option to <c>TRUE</c> to enable HTTPS to HTTP redirects.
			/// </summary>
			WinHttpRequestOption_EnableHttpsToHttpRedirects,

			/// <summary>
			/// Enables or disables support for Passport authentication. By default, automatic support for Passport authentication is
			/// disabled; set this option to <c>TRUE</c> to enable Passport authentication support.
			/// </summary>
			WinHttpRequestOption_EnablePassportAuthentication,

			/// <summary>
			/// <para>
			/// Sets or retrieves the maximum number of redirects that WinHTTP follows; the default is 10. This limit prevents unauthorized
			/// sites from making the WinHTTP client stall following a large number of redirects.
			/// </para>
			/// <para><c>Windows XP with SP1 and Windows 2000 with SP3:</c> This enumeration value is not supported.</para>
			/// </summary>
			WinHttpRequestOption_MaxAutomaticRedirects,

			/// <summary>
			/// <para>
			/// Sets or retrieves a bound set on the maximum size of the header portion of the server's response. This bound protects the
			/// client from a malicious server attempting to stall the client by sending a response with an infinite amount of header data.
			/// The default value is 64 KB.
			/// </para>
			/// <para><c>Windows XP with SP1 and Windows 2000 with SP3:</c> This enumeration value is not supported.</para>
			/// </summary>
			WinHttpRequestOption_MaxResponseHeaderSize,

			/// <summary>
			/// <para>
			/// Sets or retrieves a bound on the amount of data that will be drained from responses in order to reuse a connection. The
			/// default is 1 MB.
			/// </para>
			/// <para><c>Windows XP with SP1 and Windows 2000 with SP3:</c> This enumeration value is not supported.</para>
			/// </summary>
			WinHttpRequestOption_MaxResponseDrainSize,

			/// <summary>
			/// <para>
			/// Sets or retrieves a boolean value that indicates whether HTTP/1.1 or HTTP/1.0 should be used. The default is <c>TRUE</c>, so
			/// that HTTP/1.1 is used by default.
			/// </para>
			/// <para><c>Windows XP with SP1 and Windows 2000 with SP3:</c> This enumeration value is not supported.</para>
			/// </summary>
			WinHttpRequestOption_EnableHttp1_1,

			/// <summary>
			/// <para>
			/// Enables server certificate revocation checking during SSL negotiation. When the server presents a certificate, a check is
			/// performed to determine whether the certificate has been revoked by its issuer. If the certificate is indeed revoked, or the
			/// revocation check fails because the Certificate Revocation List (CRL) cannot be downloaded, the request fails; such revocation
			/// errors cannot be suppressed.
			/// </para>
			/// <para><c>Windows XP with SP1 and Windows 2000 with SP3:</c> This enumeration value is not supported.</para>
			/// </summary>
			WinHttpRequestOption_EnableCertificateRevocationCheck,
		}
	}
}