// Copyright © 2015, skdltmxn
// Licensed under the MIT License <LICENSE.md>
//! HTTP API specification
pub const HTTP_INITIALIZE_SERVER: ::ULONG = 0x00000001;
pub const HTTP_INITIALIZE_CONFIG: ::ULONG = 0x00000002;
pub const HTTP_DEMAND_CBT: ::ULONG = 0x00000004;
ENUM!{enum HTTP_SERVER_PROPERTY {
    HttpServerAuthenticationProperty,
    HttpServerLoggingProperty,
    HttpServerQosProperty,
    HttpServerTimeoutsProperty,
    HttpServerQueueLengthProperty,
    HttpServerStateProperty,
    HttpServer503VerbosityProperty,
    HttpServerBindingProperty,
    HttpServerExtendedAuthenticationProperty,
    HttpServerListenEndpointProperty,
    HttpServerChannelBindProperty,
    HttpServerProtectionLevelProperty,
}}
pub type PHTTP_SERVER_PROPERTY = *mut HTTP_SERVER_PROPERTY;
STRUCT!{struct HTTP_PROPERTY_FLAGS {
    BitFields: ::ULONG,
}}
BITFIELD!(HTTP_PROPERTY_FLAGS BitFields: ::ULONG [
    Present set_Present[0..1],
]);
pub type PHTTP_PROPERTY_FLAGS = *mut HTTP_PROPERTY_FLAGS;
ENUM!{enum HTTP_ENABLED_STATE {
    HttpEnabledStateActive,
    HttpEnabledStateInactive,
}}
pub type PHTTP_ENABLED_STATE = *mut HTTP_ENABLED_STATE;
STRUCT!{struct HTTP_STATE_INFO {
    Flags: HTTP_PROPERTY_FLAGS,
    State: HTTP_ENABLED_STATE,
}}
pub type PHTTP_STATE_INFO = *mut HTTP_STATE_INFO;
ENUM!{enum HTTP_503_RESPONSE_VERBOSITY {
    Http503ResponseVerbosityBasic,
    Http503ResponseVerbosityLimited,
    Http503ResponseVerbosityFull,
}}
pub type PHTTP_503_RESPONSE_VERBOSITY = *mut HTTP_503_RESPONSE_VERBOSITY;
ENUM!{enum HTTP_QOS_SETTING_TYPE {
    HttpQosSettingTypeBandwidth,
    HttpQosSettingTypeConnectionLimit,
    HttpQosSettingTypeFlowRate,
}}
pub type PHTTP_QOS_SETTING_TYPE = *mut HTTP_QOS_SETTING_TYPE;
STRUCT!{struct HTTP_QOS_SETTING_INFO {
    QosType: HTTP_QOS_SETTING_TYPE,
    QosSetting: ::PVOID,
}}
pub type PHTTP_QOS_SETTING_INFO = *mut HTTP_QOS_SETTING_INFO;
STRUCT!{struct HTTP_CONNECTION_LIMIT_INFO {
    Flags: HTTP_PROPERTY_FLAGS,
    MaxConnections: ::ULONG,
}}
pub type PHTTP_CONNECTION_LIMIT_INFO = *mut HTTP_CONNECTION_LIMIT_INFO;
STRUCT!{struct HTTP_BANDWIDTH_LIMIT_INFO {
    Flags: HTTP_PROPERTY_FLAGS,
    MaxBandwidth: ::ULONG,
}}
pub type PHTTP_BANDWIDTH_LIMIT_INFO = *mut HTTP_BANDWIDTH_LIMIT_INFO;
STRUCT!{struct HTTP_FLOWRATE_INFO {
    Flags: HTTP_PROPERTY_FLAGS,
    MaxBandwidth: ::ULONG,
    MaxPeakBandwidth: ::ULONG,
    BurstSize: ::ULONG,
}}
pub type PHTTP_FLOWRATE_INFO = *mut HTTP_FLOWRATE_INFO;
pub const HTTP_MIN_ALLOWED_BANDWIDTH_THROTTLING_RATE: ::ULONG = 1024;
pub const HTTP_LIMIT_INFINITE: ::ULONG = !0;
ENUM!{enum HTTP_SERVICE_CONFIG_TIMEOUT_KEY {
    IdleConnectionTimeout = 0,
    HeaderWaitTimeout,
}}
pub type PHTTP_SERVICE_CONFIG_TIMEOUT_KEY = *mut HTTP_SERVICE_CONFIG_TIMEOUT_KEY;
pub type HTTP_SERVICE_CONFIG_TIMEOUT_PARAM = ::USHORT;
pub type PHTTP_SERVICE_CONFIG_TIMEOUT_PARAM = *mut ::USHORT;
STRUCT!{struct HTTP_SERVICE_CONFIG_TIMEOUT_SET {
    KeyDesc: HTTP_SERVICE_CONFIG_TIMEOUT_KEY,
    ParamDesc: HTTP_SERVICE_CONFIG_TIMEOUT_PARAM,
}}
pub type PHTTP_SERVICE_CONFIG_TIMEOUT_SET = *mut HTTP_SERVICE_CONFIG_TIMEOUT_SET;
STRUCT!{struct HTTP_TIMEOUT_LIMIT_INFO {
    Flags: HTTP_PROPERTY_FLAGS,
    EntityBody: ::USHORT,
    DrainEntityBody: ::USHORT,
    RequestQueue: ::USHORT,
    IdleConnection: ::USHORT,
    HeaderWait: ::USHORT,
    MinSendRate: ::ULONG,
}}
pub type PHTTP_TIMEOUT_LIMIT_INFO = *mut HTTP_TIMEOUT_LIMIT_INFO;
STRUCT!{struct HTTP_LISTEN_ENDPOINT_INFO {
    Flags: HTTP_PROPERTY_FLAGS,
    EnableSharing: ::BOOLEAN,
}}
pub type PHTTP_LISTEN_ENDPOINT_INFO = *mut HTTP_LISTEN_ENDPOINT_INFO;
STRUCT!{struct HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS {
    DomainNameLength: ::USHORT,
    DomainName: ::PWSTR,
    RealmLength: ::USHORT,
    Realm: ::PWSTR,
}}
pub type PHTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS = *mut HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS;
STRUCT!{struct HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS {
    RealmLength: ::USHORT,
    Realm: ::PWSTR,
}}
pub type PHTTP_SERVER_AUTHENTICATION_BASIC_PARAMS = *mut HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS;
pub const HTTP_AUTH_ENABLE_BASIC: ::ULONG = 0x00000001;
pub const HTTP_AUTH_ENABLE_DIGEST: ::ULONG = 0x00000002;
pub const HTTP_AUTH_ENABLE_NTLM: ::ULONG = 0x00000004;
pub const HTTP_AUTH_ENABLE_NEGOTIATE: ::ULONG = 0x00000008;
pub const HTTP_AUTH_ENABLE_KERBEROS: ::ULONG = 0x00000010;
pub const HTTP_AUTH_ENABLE_ALL: ::ULONG =  HTTP_AUTH_ENABLE_BASIC | HTTP_AUTH_ENABLE_DIGEST |
    HTTP_AUTH_ENABLE_NTLM | HTTP_AUTH_ENABLE_NEGOTIATE | HTTP_AUTH_ENABLE_KERBEROS;
pub const HTTP_AUTH_EX_FLAG_ENABLE_KERBEROS_CREDENTIAL_CACHING: ::UCHAR = 0x01;
pub const HTTP_AUTH_EX_FLAG_CAPTURE_CREDENTIAL: ::UCHAR = 0x02;
STRUCT!{struct HTTP_SERVER_AUTHENTICATION_INFO {
    Flags: HTTP_PROPERTY_FLAGS,
    AuthSchemes: ::ULONG,
    ReceiveMutualAuth: ::BOOLEAN,
    ReceiveContextHandle: ::BOOLEAN,
    DisableNTLMCredentialCaching: ::BOOLEAN,
    ExFlags: ::UCHAR,
    DigestParams: HTTP_SERVER_AUTHENTICATION_DIGEST_PARAMS,
    BasicParams: HTTP_SERVER_AUTHENTICATION_BASIC_PARAMS,
}}
pub type PHTTP_SERVER_AUTHENTICATION_INFO = *mut HTTP_SERVER_AUTHENTICATION_INFO;
ENUM!{enum HTTP_SERVICE_BINDING_TYPE {
    HttpServiceBindingTypeNone = 0,
    HttpServiceBindingTypeW,
    HttpServiceBindingTypeA,
}}
STRUCT!{struct HTTP_SERVICE_BINDING_BASE {
    Type: HTTP_SERVICE_BINDING_TYPE,
}}
pub type PHTTP_SERVICE_BINDING_BASE = *mut HTTP_SERVICE_BINDING_BASE;
STRUCT!{struct HTTP_SERVICE_BINDING_A {
    Base: HTTP_SERVICE_BINDING_BASE,
    Buffer: ::PCHAR,
    BufferSize: ::ULONG,
}}
pub type PHTTP_SERVICE_BINDING_A = *mut HTTP_SERVICE_BINDING_A;
STRUCT!{struct HTTP_SERVICE_BINDING_W {
    Base: HTTP_SERVICE_BINDING_BASE,
    Buffer: ::PWCHAR,
    BufferSize: ::ULONG,
}}
pub type PHTTP_SERVICE_BINDING_W = *mut HTTP_SERVICE_BINDING_W;
ENUM!{enum HTTP_AUTHENTICATION_HARDENING_LEVELS {
    HttpAuthenticationHardeningLegacy = 0,
    HttpAuthenticationHardeningMedium,
    HttpAuthenticationHardeningStrict,
}}
pub const HTTP_CHANNEL_BIND_PROXY: ::ULONG = 0x1;
pub const HTTP_CHANNEL_BIND_PROXY_COHOSTING: ::ULONG = 0x20;
pub const HTTP_CHANNEL_BIND_NO_SERVICE_NAME_CHECK: ::ULONG = 0x2;
pub const HTTP_CHANNEL_BIND_DOTLESS_SERVICE: ::ULONG = 0x4;
pub const HTTP_CHANNEL_BIND_SECURE_CHANNEL_TOKEN: ::ULONG = 0x8;
pub const HTTP_CHANNEL_BIND_CLIENT_SERVICE: ::ULONG = 0x10;
STRUCT!{struct HTTP_CHANNEL_BIND_INFO {
    Hardening: HTTP_AUTHENTICATION_HARDENING_LEVELS,
    Flags: ::ULONG,
    ServiceNames: *mut PHTTP_SERVICE_BINDING_BASE,
    NumberOfServiceNames: ::ULONG,
}}
pub type PHTTP_CHANNEL_BIND_INFO = *mut HTTP_CHANNEL_BIND_INFO;
STRUCT!{struct HTTP_REQUEST_CHANNEL_BIND_STATUS {
    ServiceName: PHTTP_SERVICE_BINDING_BASE,
    ChannelToken: ::PUCHAR,
    ChannelTokenSize: ::ULONG,
    Flags: ::ULONG,
}}
pub type PHTTP_REQUEST_CHANNEL_BIND_STATUS = *mut HTTP_REQUEST_CHANNEL_BIND_STATUS;
pub const HTTP_LOG_FIELD_DATE: ::ULONG = 0x00000001;
pub const HTTP_LOG_FIELD_TIME: ::ULONG = 0x00000002;
pub const HTTP_LOG_FIELD_CLIENT_IP: ::ULONG = 0x00000004;
pub const HTTP_LOG_FIELD_USER_NAME: ::ULONG = 0x00000008;
pub const HTTP_LOG_FIELD_SITE_NAME: ::ULONG = 0x00000010;
pub const HTTP_LOG_FIELD_COMPUTER_NAME: ::ULONG = 0x00000020;
pub const HTTP_LOG_FIELD_SERVER_IP: ::ULONG = 0x00000040;
pub const HTTP_LOG_FIELD_METHOD: ::ULONG = 0x00000080;
pub const HTTP_LOG_FIELD_URI_STEM: ::ULONG = 0x00000100;
pub const HTTP_LOG_FIELD_URI_QUERY: ::ULONG = 0x00000200;
pub const HTTP_LOG_FIELD_STATUS: ::ULONG = 0x00000400;
pub const HTTP_LOG_FIELD_WIN32_STATUS: ::ULONG = 0x00000800;
pub const HTTP_LOG_FIELD_BYTES_SENT: ::ULONG = 0x00001000;
pub const HTTP_LOG_FIELD_BYTES_RECV: ::ULONG = 0x00002000;
pub const HTTP_LOG_FIELD_TIME_TAKEN: ::ULONG = 0x00004000;
pub const HTTP_LOG_FIELD_SERVER_PORT: ::ULONG = 0x00008000;
pub const HTTP_LOG_FIELD_USER_AGENT: ::ULONG = 0x00010000;
pub const HTTP_LOG_FIELD_COOKIE: ::ULONG = 0x00020000;
pub const HTTP_LOG_FIELD_REFERER: ::ULONG = 0x00040000;
pub const HTTP_LOG_FIELD_VERSION: ::ULONG = 0x00080000;
pub const HTTP_LOG_FIELD_HOST: ::ULONG = 0x00100000;
pub const HTTP_LOG_FIELD_SUB_STATUS: ::ULONG = 0x00200000;
pub const HTTP_LOG_FIELD_CLIENT_PORT: ::ULONG = 0x00400000;
pub const HTTP_LOG_FIELD_URI: ::ULONG = 0x00800000;
pub const HTTP_LOG_FIELD_SITE_ID: ::ULONG = 0x01000000;
pub const HTTP_LOG_FIELD_REASON: ::ULONG = 0x02000000;
pub const HTTP_LOG_FIELD_QUEUE_NAME: ::ULONG = 0x04000000;
ENUM!{enum HTTP_LOGGING_TYPE {
    HttpLoggingTypeW3C,
    HttpLoggingTypeIIS,
    HttpLoggingTypeNCSA,
    HttpLoggingTypeRaw,
}}
ENUM!{enum HTTP_LOGGING_ROLLOVER_TYPE {
    HttpLoggingRolloverSize,
    HttpLoggingRolloverDaily,
    HttpLoggingRolloverWeekly,
    HttpLoggingRolloverMonthly,
    HttpLoggingRolloverHourly,
}}
pub const HTTP_MIN_ALLOWED_LOG_FILE_ROLLOVER_SIZE: ::ULONG = (1 * 1024 * 1024) as ::ULONG;
pub const HTTP_LOGGING_FLAG_LOCAL_TIME_ROLLOVER: ::ULONG = 0x00000001;
pub const HTTP_LOGGING_FLAG_USE_UTF8_CONVERSION: ::ULONG = 0x00000002;
pub const HTTP_LOGGING_FLAG_LOG_ERRORS_ONLY: ::ULONG = 0x00000004;
pub const HTTP_LOGGING_FLAG_LOG_SUCCESS_ONLY: ::ULONG = 0x00000008;
STRUCT!{struct HTTP_LOGGING_INFO {
    Flags: HTTP_PROPERTY_FLAGS,
    LoggingFlags: ::ULONG,
    SoftwareName: ::PCWSTR,
    SoftwareNameLength: ::USHORT,
    DirectoryNameLength: ::USHORT,
    DirectoryName: ::PCWSTR,
    Format: HTTP_LOGGING_TYPE,
    Fields: ::ULONG,
    pExtFields: ::PVOID,
    NumOfExtFields: ::USHORT,
    MaxRecordSize: ::USHORT,
    RolloverType: HTTP_LOGGING_ROLLOVER_TYPE,
    RolloverSize: ::ULONG,
    pSecurityDescriptor: ::PSECURITY_DESCRIPTOR,
}}
pub type PHTTP_LOGGING_INFO = *mut HTTP_LOGGING_INFO;
STRUCT!{struct HTTP_BINDING_INFO {
    Flags: HTTP_PROPERTY_FLAGS,
    RequestQueueHandle: ::HANDLE,
}}
pub type PHTTP_BINDING_INFO = *mut HTTP_BINDING_INFO;
ENUM!{enum HTTP_PROTECTION_LEVEL_TYPE {
    HttpProtectionLevelUnrestricted,
    HttpProtectionLevelEdgeRestricted,
    HttpProtectionLevelRestricted,
}}
pub type PHTTP_PROTECTION_LEVEL_TYPE = *mut HTTP_PROTECTION_LEVEL_TYPE;
STRUCT!{struct HTTP_PROTECTION_LEVEL_INFO {
    Flags: HTTP_PROPERTY_FLAGS,
    Level: HTTP_PROTECTION_LEVEL_TYPE,
}}
pub type PHTTP_PROTECTION_LEVEL_INFO = *mut HTTP_PROTECTION_LEVEL_INFO;
pub const HTTP_CREATE_REQUEST_QUEUE_FLAG_OPEN_EXISTING: ::ULONG = 0x00000001;
pub const HTTP_CREATE_REQUEST_QUEUE_FLAG_CONTROLLER: ::ULONG = 0x00000002;
pub const HTTP_RECEIVE_REQUEST_FLAG_COPY_BODY: ::ULONG = 0x00000001;
pub const HTTP_RECEIVE_REQUEST_FLAG_FLUSH_BODY: ::ULONG = 0x00000002;
pub const HTTP_RECEIVE_REQUEST_ENTITY_BODY_FLAG_FILL_BUFFER: ::ULONG = 0x00000001;
pub const HTTP_SEND_RESPONSE_FLAG_DISCONNECT: ::ULONG = 0x00000001;
pub const HTTP_SEND_RESPONSE_FLAG_MORE_DATA: ::ULONG = 0x00000002;
pub const HTTP_SEND_RESPONSE_FLAG_BUFFER_DATA: ::ULONG = 0x00000004;
pub const HTTP_SEND_RESPONSE_FLAG_ENABLE_NAGLING: ::ULONG = 0x00000008;
pub const HTTP_SEND_RESPONSE_FLAG_PROCESS_RANGES: ::ULONG = 0x00000020;
pub const HTTP_SEND_RESPONSE_FLAG_OPAQUE: ::ULONG = 0x00000040;
pub const HTTP_FLUSH_RESPONSE_FLAG_RECURSIVE: ::ULONG = 0x00000001;
pub type HTTP_OPAQUE_ID = ::ULONGLONG;
pub type PHTTP_OPAQUE_ID = *mut ::ULONGLONG;
pub type HTTP_REQUEST_ID = HTTP_OPAQUE_ID;
pub type PHTTP_REQUEST_ID = *mut HTTP_OPAQUE_ID;
pub type HTTP_CONNECTION_ID = HTTP_OPAQUE_ID;
pub type PHTTP_CONNECTION_ID = *mut HTTP_OPAQUE_ID;
pub type HTTP_RAW_CONNECTION_ID = HTTP_OPAQUE_ID;
pub type PHTTP_RAW_CONNECTION_ID = *mut HTTP_OPAQUE_ID;
pub type HTTP_URL_GROUP_ID = HTTP_OPAQUE_ID;
pub type PHTTP_URL_GROUP_ID = *mut HTTP_OPAQUE_ID;
pub type HTTP_SERVER_SESSION_ID = HTTP_OPAQUE_ID;
pub type PHTTP_SERVER_SESSION_ID = *mut HTTP_OPAQUE_ID;
pub const HTTP_BYTE_RANGE_TO_EOF: ::ULONGLONG = !0;
STRUCT!{struct HTTP_BYTE_RANGE {
    StartingOffset: ::ULARGE_INTEGER,
    Length: ::ULARGE_INTEGER,
}}
pub type PHTTP_BYTE_RANGE = *mut HTTP_BYTE_RANGE;
STRUCT!{struct HTTP_VERSION {
    MajorVersion: ::USHORT,
    MinorVersion: ::USHORT,
}}
pub type PHTTP_VERSION = *mut HTTP_VERSION;
pub const HTTP_VERSION_UNKNOWN: HTTP_VERSION = HTTP_VERSION { MajorVersion: 0, MinorVersion: 0 };
pub const HTTP_VERSION_0_9: HTTP_VERSION = HTTP_VERSION { MajorVersion: 0, MinorVersion: 9 };
pub const HTTP_VERSION_1_0: HTTP_VERSION = HTTP_VERSION { MajorVersion: 1, MinorVersion: 0 };
pub const HTTP_VERSION_1_1: HTTP_VERSION = HTTP_VERSION { MajorVersion: 1, MinorVersion: 1 };
#[inline] #[allow(dead_code)]
pub fn HTTP_SET_VERSION(mut version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) {
    version.MajorVersion = major;
    version.MinorVersion = minor;
}
#[inline] #[allow(dead_code)]
pub fn HTTP_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
    version.MajorVersion == major && version.MinorVersion == minor
}
#[inline] #[allow(dead_code)]
pub fn HTTP_GREATER_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
    version.MajorVersion > major || (version.MajorVersion == major && version.MinorVersion > minor)
}
#[inline] #[allow(dead_code)]
pub fn HTTP_LESS_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
    version.MajorVersion < major || (version.MajorVersion == major && version.MinorVersion < minor)
}
#[inline] #[allow(dead_code)]
pub fn HTTP_NOT_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
    !HTTP_EQUAL_VERSION(version, major, minor)
}
#[inline] #[allow(dead_code)]
pub fn HTTP_GREATER_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
    !HTTP_LESS_VERSION(version, major, minor)
}
#[inline] #[allow(dead_code)]
pub fn HTTP_LESS_EQUAL_VERSION(version: HTTP_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
    !HTTP_GREATER_VERSION(version, major, minor)
}
ENUM!{enum HTTP_VERB {
    HttpVerbUnparsed,
    HttpVerbUnknown,
    HttpVerbInvalid,
    HttpVerbOPTIONS,
    HttpVerbGET,
    HttpVerbHEAD,
    HttpVerbPOST,
    HttpVerbPUT,
    HttpVerbDELETE,
    HttpVerbTRACE,
    HttpVerbCONNECT,
    HttpVerbTRACK,
    HttpVerbMOVE,
    HttpVerbCOPY,
    HttpVerbPROPFIND,
    HttpVerbPROPPATCH,
    HttpVerbMKCOL,
    HttpVerbLOCK,
    HttpVerbUNLOCK,
    HttpVerbSEARCH,
    HttpVerbMaximum,
}}
pub type PHTTP_VERB = *mut HTTP_VERB;
ENUM!{enum HTTP_HEADER_ID {
    HttpHeaderCacheControl = 0,
    HttpHeaderConnection = 1,
    HttpHeaderDate = 2,
    HttpHeaderKeepAlive = 3,
    HttpHeaderPragma = 4,
    HttpHeaderTrailer = 5,
    HttpHeaderTransferEncoding = 6,
    HttpHeaderUpgrade = 7,
    HttpHeaderVia = 8,
    HttpHeaderWarning = 9,
    HttpHeaderAllow = 10,
    HttpHeaderContentLength = 11,
    HttpHeaderContentType = 12,
    HttpHeaderContentEncoding = 13,
    HttpHeaderContentLanguage = 14,
    HttpHeaderContentLocation = 15,
    HttpHeaderContentMd5 = 16,
    HttpHeaderContentRange = 17,
    HttpHeaderExpires = 18,
    HttpHeaderLastModified = 19,
    HttpHeaderAccept = 20,
    HttpHeaderAcceptCharset = 21,
    HttpHeaderAcceptEncoding = 22,
    HttpHeaderAcceptLanguage = 23,
    HttpHeaderAuthorization = 24,
    HttpHeaderCookie = 25,
    HttpHeaderExpect = 26,
    HttpHeaderFrom = 27,
    HttpHeaderHost = 28,
    HttpHeaderIfMatch = 29,
    HttpHeaderIfModifiedSince = 30,
    HttpHeaderIfNoneMatch = 31,
    HttpHeaderIfRange = 32,
    HttpHeaderIfUnmodifiedSince = 33,
    HttpHeaderMaxForwards = 34,
    HttpHeaderProxyAuthorization = 35,
    HttpHeaderReferer = 36,
    HttpHeaderRange = 37,
    HttpHeaderTe = 38,
    HttpHeaderTranslate = 39,
    HttpHeaderUserAgent = 40,
    HttpHeaderRequestMaximum = 41,
    HttpHeaderAcceptRanges = 20,
    HttpHeaderAge = 21,
    HttpHeaderEtag = 22,
    HttpHeaderLocation = 23,
    HttpHeaderProxyAuthenticate = 24,
    HttpHeaderRetryAfter = 25,
    HttpHeaderServer = 26,
    HttpHeaderSetCookie = 27,
    HttpHeaderVary = 28,
    HttpHeaderWwwAuthenticate = 29,
    HttpHeaderResponseMaximum = 30,
    HttpHeaderMaximum = 41,
}}
pub type PHTTP_HEADER_ID = *mut HTTP_HEADER_ID;
STRUCT!{struct HTTP_KNOWN_HEADER {
    RawValueLength: ::USHORT,
    pRawValue: ::PCSTR,
}}
pub type PHTTP_KNOWN_HEADER = *mut HTTP_KNOWN_HEADER;
STRUCT!{struct HTTP_UNKNOWN_HEADER {
    NameLength: ::USHORT,
    RawValueLength: ::USHORT,
    pName: ::PCSTR,
    pRawValue: ::PCSTR,
}}
pub type PHTTP_UNKNOWN_HEADER = *mut HTTP_UNKNOWN_HEADER;
ENUM!{enum HTTP_LOG_DATA_TYPE {
    HttpLogDataTypeFields = 0,
}}
pub type PHTTP_LOG_DATA_TYPE = *mut HTTP_LOG_DATA_TYPE;
STRUCT!{struct HTTP_LOG_DATA {
    Type: HTTP_LOG_DATA_TYPE,
}}
pub type PHTTP_LOG_DATA = *mut HTTP_LOG_DATA;
STRUCT!{struct HTTP_LOG_FIELDS_DATA {
    Base: HTTP_LOG_DATA,
    UserNameLength: ::USHORT,
    UriStemLength: ::USHORT,
    ClientIpLength: ::USHORT,
    ServerNameLength: ::USHORT,
    ServiceNameLength: ::USHORT,
    ServerIpLength: ::USHORT,
    MethodLength: ::USHORT,
    UriQueryLength: ::USHORT,
    HostLength: ::USHORT,
    UserAgentLength: ::USHORT,
    CookieLength: ::USHORT,
    ReferrerLength: ::USHORT,
    UserName: ::PWCHAR,
    UriStem: ::PWCHAR,
    ClientIp: ::PCHAR,
    ServerName: ::PCHAR,
    ServiceName: ::PCHAR,
    ServerIp: ::PCHAR,
    Method: ::PCHAR,
    UriQuery: ::PCHAR,
    Host: ::PCHAR,
    UserAgent: ::PCHAR,
    Cookie: ::PCHAR,
    Referrer: ::PCHAR,
    ServerPort: ::USHORT,
    ProtocolStatus: ::USHORT,
    Win32Status: ::ULONG,
    MethodNum: HTTP_VERB,
    SubStatus: ::USHORT,
}}
pub type PHTTP_LOG_FIELDS_DATA = *mut HTTP_LOG_FIELDS_DATA;
ENUM!{enum HTTP_DATA_CHUNK_TYPE {
    HttpDataChunkFromMemory,
    HttpDataChunkFromFileHandle,
    HttpDataChunkFromFragmentCache,
    HttpDataChunkFromFragmentCacheEx,
    HttpDataChunkMaximum,
}}
pub type PHTTP_DATA_CHUNK_TYPE = *mut HTTP_DATA_CHUNK_TYPE;
STRUCT!{struct HTTP_DATA_CHUNK_FromMemory {
    pBuffer: ::PVOID,
    BufferLength: ::ULONG,
}}
STRUCT!{struct HTTP_DATA_CHUNK_FromFileHandle {
    ByteRange: HTTP_BYTE_RANGE,
    FileHandle: ::HANDLE,
}}
STRUCT!{struct HTTP_DATA_CHUNK_FromFragmentCache {
    FragmentNameLength: ::USHORT,
    pFragmentName: ::PCWSTR,
}}
STRUCT!{struct HTTP_DATA_CHUNK_FromFragmentCacheEx {
    ByteRange: HTTP_BYTE_RANGE,
    pFragmentName: ::PCWSTR,
}}
STRUCT!{struct HTTP_DATA_CHUNK {
    DataChunkType: HTTP_DATA_CHUNK_TYPE,
    FromFileHandle: HTTP_DATA_CHUNK_FromFileHandle,
}}
UNION!(HTTP_DATA_CHUNK, FromFileHandle, FromMemory, FromMemory_mut, HTTP_DATA_CHUNK_FromMemory);
UNION!(
    HTTP_DATA_CHUNK, FromFileHandle, FromFragmentCache, FromFragmentCache_mut,
    HTTP_DATA_CHUNK_FromFragmentCache
);
UNION!(
    HTTP_DATA_CHUNK, FromFileHandle, FromFragmentCacheEx, FromFragmentCacheEx_mut,
    HTTP_DATA_CHUNK_FromFragmentCacheEx
);
pub type PHTTP_DATA_CHUNK = *mut HTTP_DATA_CHUNK;
STRUCT!{nodebug struct HTTP_REQUEST_HEADERS {
    UnknownHeaderCount: ::USHORT,
    pUnknownHeaders: PHTTP_UNKNOWN_HEADER,
    TrailerCount: ::USHORT,
    pTrailers: PHTTP_UNKNOWN_HEADER,
    KnownHeaders: [HTTP_KNOWN_HEADER; 41], // FIXME HttpHeaderRequestMaximum
}}
pub type PHTTP_REQUEST_HEADERS = *mut HTTP_REQUEST_HEADERS;
STRUCT!{nodebug struct HTTP_RESPONSE_HEADERS {
    UnknownHeaderCount: ::USHORT,
    pUnknownHeaders: PHTTP_UNKNOWN_HEADER,
    TrailerCount: ::USHORT,
    pTrailers: PHTTP_UNKNOWN_HEADER,
    KnownHeaders: [HTTP_KNOWN_HEADER; 30], // FIXME HttpHeaderResponseMaximum
}}
pub type PHTTP_RESPONSE_HEADERS = *mut HTTP_RESPONSE_HEADERS;
STRUCT!{struct HTTP_TRANSPORT_ADDRESS {
    pRemoteAddress: ::PSOCKADDR,
    pLocalAddress: ::PSOCKADDR,
}}
pub type PHTTP_TRANSPORT_ADDRESS = *mut HTTP_TRANSPORT_ADDRESS;
STRUCT!{struct HTTP_COOKED_URL {
    FullUrlLength: ::USHORT,
    HostLength: ::USHORT,
    AbsPathLength: ::USHORT,
    QueryStringLength: ::USHORT,
    pFullUrl: ::PCWSTR,
    pHost: ::PCWSTR,
    pAbsPath: ::PCWSTR,
    pQueryString: ::PCWSTR,
}}
pub type PHTTP_COOKED_URL = *mut HTTP_COOKED_URL;
pub type HTTP_URL_CONTEXT = ::ULONGLONG;
pub const HTTP_URL_FLAG_REMOVE_ALL: ::ULONG = 0x00000001;
ENUM!{enum HTTP_AUTH_STATUS {
    HttpAuthStatusSuccess,
    HttpAuthStatusNotAuthenticated,
    HttpAuthStatusFailure,
}}
pub type PHTTP_AUTH_STATUS = *mut HTTP_AUTH_STATUS;
ENUM!{enum HTTP_REQUEST_AUTH_TYPE {
    HttpRequestAuthTypeNone = 0,
    HttpRequestAuthTypeBasic,
    HttpRequestAuthTypeDigest,
    HttpRequestAuthTypeNTLM,
    HttpRequestAuthTypeNegotiate,
    HttpRequestAuthTypeKerberos,
}}
pub type PHTTP_REQUEST_AUTH_TYPE = *mut HTTP_REQUEST_AUTH_TYPE;
STRUCT!{struct HTTP_SSL_CLIENT_CERT_INFO {
    CertFlags: ::ULONG,
    CertEncodedSize: ::ULONG,
    pCertEncoded: ::PUCHAR,
    Token: ::HANDLE,
    CertDeniedByMapper: ::BOOLEAN,
}}
pub type PHTTP_SSL_CLIENT_CERT_INFO = *mut HTTP_SSL_CLIENT_CERT_INFO;
pub const HTTP_RECEIVE_SECURE_CHANNEL_TOKEN: ::ULONG = 0x1;
STRUCT!{struct HTTP_SSL_INFO {
    ServerCertKeySize: ::USHORT,
    ConnectionKeySize: ::USHORT,
    ServerCertIssuerSize: ::ULONG,
    ServerCertSubjectSize: ::ULONG,
    pServerCertIssuer: ::PCSTR,
    pServerCertSubject: ::PCSTR,
    pClientCertInfo: PHTTP_SSL_CLIENT_CERT_INFO,
    SslClientCertNegotiated: ::ULONG,
}}
pub type PHTTP_SSL_INFO = *mut HTTP_SSL_INFO;
ENUM!{enum HTTP_REQUEST_INFO_TYPE {
    HttpRequestInfoTypeAuth,
    HttpRequestInfoTypeChannelBind,
}}
STRUCT!{struct HTTP_REQUEST_INFO {
    InfoType: HTTP_REQUEST_INFO_TYPE,
    InfoLength: ::ULONG,
    pInfo: ::PVOID,
}}
pub type PHTTP_REQUEST_INFO = *mut HTTP_REQUEST_INFO;
pub const HTTP_REQUEST_AUTH_FLAG_TOKEN_FOR_CACHED_CRED: ::ULONG = 0x00000001;
STRUCT!{struct HTTP_REQUEST_AUTH_INFO {
    AuthStatus: HTTP_AUTH_STATUS,
    SecStatus: ::SECURITY_STATUS,
    Flags: ::ULONG,
    AuthType: HTTP_REQUEST_AUTH_TYPE,
    AccessToken: ::HANDLE,
    ContextAttributes: ::ULONG,
    PackedContextLength: ::ULONG,
    PackedContextType: ::ULONG,
    PackedContext: ::PVOID,
    MutualAuthDataLength: ::ULONG,
    pMutualAuthData: ::PCHAR,
    PackageNameLength: ::USHORT,
    pPackageName: ::PWSTR,
}}
pub type PHTTP_REQUEST_AUTH_INFO = *mut HTTP_REQUEST_AUTH_INFO;
STRUCT!{nodebug struct HTTP_REQUEST_V1 {
    Flags: ::ULONG,
    ConnectionId: HTTP_CONNECTION_ID,
    RequestId: HTTP_REQUEST_ID,
    UrlContext: HTTP_URL_CONTEXT,
    Version: HTTP_VERSION,
    Verb: HTTP_VERB,
    UnknownVerbLength: ::USHORT,
    RawUrlLength: ::USHORT,
    pUnknownVerb: ::PCSTR,
    pRawUrl: ::PCSTR,
    CookedUrl: HTTP_COOKED_URL,
    Address: HTTP_TRANSPORT_ADDRESS,
    Headers: HTTP_REQUEST_HEADERS,
    BytesReceived: ::ULONGLONG,
    EntityChunkCount: ::USHORT,
    pEntityChunks: PHTTP_DATA_CHUNK,
    RawConnectionId: HTTP_RAW_CONNECTION_ID,
    pSslInfo: PHTTP_SSL_INFO,
}}
pub type PHTTP_REQUEST_V1 = *mut HTTP_REQUEST_V1;
STRUCT!{nodebug struct HTTP_REQUEST_V2 {
    Base: HTTP_REQUEST_V1,
    RequestInfoCount: ::USHORT,
    pRequestInfo: PHTTP_REQUEST_INFO,
}}
pub type PHTTP_REQUEST_V2 = *mut HTTP_REQUEST_V2;
pub type HTTP_REQUEST = HTTP_REQUEST_V2;
pub type PHTTP_REQUEST = *mut HTTP_REQUEST;
pub const HTTP_REQUEST_FLAG_MORE_ENTITY_BODY_EXISTS: ::ULONG = 0x00000001;
pub const HTTP_REQUEST_FLAG_IP_ROUTED: ::ULONG = 0x00000002;
STRUCT!{nodebug struct HTTP_RESPONSE_V1 {
    Flags: ::ULONG,
    Version: HTTP_VERSION,
    StatusCode: ::USHORT,
    ReasonLength: ::USHORT,
    pReason: ::PCSTR,
    Headers: HTTP_RESPONSE_HEADERS,
    EntityChunkCount: ::USHORT,
    pEntityChunks: PHTTP_DATA_CHUNK,
}}
pub type PHTTP_RESPONSE_V1 = *mut HTTP_RESPONSE_V1;
pub const HTTP_RESPONSE_FLAG_MULTIPLE_ENCODINGS_AVAILABLE: ::ULONG = 0x00000001;
ENUM!{enum HTTP_RESPONSE_INFO_TYPE {
    HttpResponseInfoTypeMultipleKnownHeaders,
    HttpResponseInfoTypeAuthenticationProperty,
    HttpResponseInfoTypeQoSProperty,
    HttpResponseInfoTypeChannelBind,
}}
pub type PHTTP_RESPONSE_INFO_TYPE = *mut HTTP_RESPONSE_INFO_TYPE;
STRUCT!{struct HTTP_RESPONSE_INFO {
    Type: HTTP_RESPONSE_INFO_TYPE,
    Length: ::ULONG,
    pInfo: ::PVOID,
}}
pub type PHTTP_RESPONSE_INFO = *mut HTTP_RESPONSE_INFO;
pub const HTTP_RESPONSE_INFO_FLAGS_PRESERVE_ORDER: ::ULONG = 0x00000001;
STRUCT!{struct HTTP_MULTIPLE_KNOWN_HEADERS {
    HeaderId: HTTP_HEADER_ID,
    Flags: ::ULONG,
    KnownHeaderCount: ::USHORT,
    KnownHeaders: PHTTP_KNOWN_HEADER,
}}
pub type PHTTP_MULTIPLE_KNOWN_HEADERS = *mut HTTP_MULTIPLE_KNOWN_HEADERS;
STRUCT!{nodebug struct HTTP_RESPONSE_V2 {
    Base: HTTP_RESPONSE_V1,
    ResponseInfoCount: ::USHORT,
    pResponseInfo: PHTTP_RESPONSE_INFO,
}}
pub type PHTTP_RESPONSE_V2 = *mut HTTP_RESPONSE_V2;
pub type HTTP_RESPONSE = HTTP_RESPONSE_V2;
pub type PHTTP_RESPONSE = *mut HTTP_RESPONSE;
STRUCT!{struct HTTPAPI_VERSION {
    HttpApiMajorVersion: ::USHORT,
    HttpApiMinorVersion: ::USHORT,
}}
pub type PHTTPAPI_VERSION = *mut HTTPAPI_VERSION;
pub const HTTPAPI_VERSION_2: HTTPAPI_VERSION = HTTPAPI_VERSION {
    HttpApiMajorVersion: 2, HttpApiMinorVersion: 0,
};
pub const HTTPAPI_VERSION_1: HTTPAPI_VERSION = HTTPAPI_VERSION {
    HttpApiMajorVersion: 1, HttpApiMinorVersion: 0,
};
#[inline] #[allow(dead_code)]
pub fn HTTPAPI_EQUAL_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
    version.HttpApiMajorVersion == major && version.HttpApiMinorVersion == minor
}
#[inline] #[allow(dead_code)]
pub fn HTTPAPI_GREATER_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
    version.HttpApiMajorVersion > major ||
    (version.HttpApiMajorVersion == major && version.HttpApiMinorVersion > minor)
}
#[inline] #[allow(dead_code)]
pub fn HTTPAPI_LESS_VERSION(version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT) -> bool {
    version.HttpApiMajorVersion < major ||
    (version.HttpApiMajorVersion == major && version.HttpApiMinorVersion < minor)
}
#[inline] #[allow(dead_code)]
pub fn HTTPAPI_VERSION_GREATER_OR_EQUAL(
    version: HTTPAPI_VERSION, major: ::USHORT, minor: ::USHORT
) -> bool {
    !HTTPAPI_LESS_VERSION(version, major, minor)
}
ENUM!{enum HTTP_CACHE_POLICY_TYPE {
    HttpCachePolicyNocache,
    HttpCachePolicyUserInvalidates,
    HttpCachePolicyTimeToLive,
    HttpCachePolicyMaximum,
}}
pub type PHTTP_CACHE_POLICY_TYPE = *mut HTTP_CACHE_POLICY_TYPE;
STRUCT!{struct HTTP_CACHE_POLICY {
    Policy: HTTP_CACHE_POLICY_TYPE,
    SecondsToLive: ::ULONG,
}}
pub type PHTTP_CACHE_POLICY = *mut HTTP_CACHE_POLICY;
ENUM!{enum HTTP_SERVICE_CONFIG_ID {
    HttpServiceConfigIPListenList,
    HttpServiceConfigSSLCertInfo,
    HttpServiceConfigUrlAclInfo,
    HttpServiceConfigTimeout,
    HttpServiceConfigCache,
    HttpServiceConfigSslSniCertInfo,
    HttpServiceConfigSslCcsCertInfo,
    HttpServiceConfigMax,
}}
pub type PHTTP_SERVICE_CONFIG_ID = *mut HTTP_SERVICE_CONFIG_ID;
ENUM!{enum HTTP_SERVICE_CONFIG_QUERY_TYPE {
    HttpServiceConfigQueryExact,
    HttpServiceConfigQueryNext,
    HttpServiceConfigQueryMax,
}}
pub type PHTTP_SERVICE_CONFIG_QUERY_TYPE = *mut HTTP_SERVICE_CONFIG_QUERY_TYPE;
STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_KEY {
    pIpPort: ::PSOCKADDR,
}}
pub type PHTTP_SERVICE_CONFIG_SSL_KEY = *mut HTTP_SERVICE_CONFIG_SSL_KEY;
STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_SNI_KEY {
    IpPort: ::SOCKADDR_STORAGE,
    Host: ::PWSTR,
}}
pub type PHTTP_SERVICE_CONFIG_SSL_SNI_KEY = *mut HTTP_SERVICE_CONFIG_SSL_SNI_KEY;
STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_CCS_KEY {
    LocalAddress: ::SOCKADDR_STORAGE,
}}
pub type PHTTP_SERVICE_CONFIG_SSL_CCS_KEY = *mut HTTP_SERVICE_CONFIG_SSL_CCS_KEY;
STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_PARAM {
    SslHashLength: ::ULONG,
    pSslHash: ::PVOID,
    AppId: ::GUID,
    pSslCertStoreName: ::PWSTR,
    DefaultCertCheckMode: ::DWORD,
    DefaultRevocationFreshnessTime: ::DWORD,
    DefaultRevocationUrlRetrievalTimeout: ::DWORD,
    pDefaultSslCtlIdentifier: ::PWSTR,
    pDefaultSslCtlStoreName: ::PWSTR,
    DefaultFlags: ::DWORD,
}}
pub type PHTTP_SERVICE_CONFIG_SSL_PARAM = *mut HTTP_SERVICE_CONFIG_SSL_PARAM;
pub const HTTP_SERVICE_CONFIG_SSL_FLAG_USE_DS_MAPPER: ::DWORD = 0x00000001;
pub const HTTP_SERVICE_CONFIG_SSL_FLAG_NEGOTIATE_CLIENT_CERT: ::DWORD = 0x00000002;
pub const HTTP_SERVICE_CONFIG_SSL_FLAG_NO_RAW_FILTER: ::DWORD = 0x00000004;
STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_SET {
    KeyDesc: HTTP_SERVICE_CONFIG_SSL_KEY,
    ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
}}
pub type PHTTP_SERVICE_CONFIG_SSL_SET = *mut HTTP_SERVICE_CONFIG_SSL_SET;
STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_SNI_SET {
    KeyDesc: HTTP_SERVICE_CONFIG_SSL_SNI_KEY,
    ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
}}
pub type PHTTP_SERVICE_CONFIG_SSL_SNI_SET = *mut HTTP_SERVICE_CONFIG_SSL_SNI_SET;
STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_CCS_SET {
    KeyDesc: HTTP_SERVICE_CONFIG_SSL_CCS_KEY,
    ParamDesc: HTTP_SERVICE_CONFIG_SSL_PARAM,
}}
pub type PHTTP_SERVICE_CONFIG_SSL_CCS_SET = *mut HTTP_SERVICE_CONFIG_SSL_CCS_SET;
STRUCT!{struct HTTP_SERVICE_CONFIG_SSL_QUERY {
    QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
    KeyDesc: HTTP_SERVICE_CONFIG_SSL_KEY,
    dwToken: ::DWORD,
}}
pub type PHTTP_SERVICE_CONFIG_SSL_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_QUERY;
STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_SNI_QUERY {
    QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
    KeyDesc: HTTP_SERVICE_CONFIG_SSL_SNI_KEY,
    dwToken: ::DWORD,
}}
pub type PHTTP_SERVICE_CONFIG_SSL_SNI_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_SNI_QUERY;
STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_SSL_CCS_QUERY {
    QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
    KeyDesc: HTTP_SERVICE_CONFIG_SSL_CCS_KEY,
    dwToken: ::DWORD,
}}
pub type PHTTP_SERVICE_CONFIG_SSL_CCS_QUERY = *mut HTTP_SERVICE_CONFIG_SSL_CCS_QUERY;
STRUCT!{struct HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM {
    AddrLength: ::USHORT,
    pAddress: ::PSOCKADDR,
}}
pub type PHTTP_SERVICE_CONFIG_IP_LISTEN_PARAM = *mut HTTP_SERVICE_CONFIG_IP_LISTEN_PARAM;
STRUCT!{nodebug struct HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY {
    AddrCount: ::ULONG,
    AddrList: [::SOCKADDR_STORAGE; ::ANYSIZE_ARRAY],
}}
pub type PHTTP_SERVICE_CONFIG_IP_LISTEN_QUERY = *mut HTTP_SERVICE_CONFIG_IP_LISTEN_QUERY;
STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_KEY {
    pUrlPrefix: ::PWSTR,
}}
pub type PHTTP_SERVICE_CONFIG_URLACL_KEY = *mut HTTP_SERVICE_CONFIG_URLACL_KEY;
STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_PARAM {
    pStringSecurityDescriptor: ::PWSTR,
}}
pub type PHTTP_SERVICE_CONFIG_URLACL_PARAM = *mut HTTP_SERVICE_CONFIG_URLACL_PARAM;
STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_SET {
    KeyDesc: HTTP_SERVICE_CONFIG_URLACL_KEY,
    ParamDesc: HTTP_SERVICE_CONFIG_URLACL_PARAM,
}}
pub type PHTTP_SERVICE_CONFIG_URLACL_SET = *mut HTTP_SERVICE_CONFIG_URLACL_SET;
STRUCT!{struct HTTP_SERVICE_CONFIG_URLACL_QUERY {
    QueryDesc: HTTP_SERVICE_CONFIG_QUERY_TYPE,
    KeyDesc: HTTP_SERVICE_CONFIG_URLACL_KEY,
    dwToken: ::DWORD,
}}
pub type PHTTP_SERVICE_CONFIG_URLACL_QUERY = *mut HTTP_SERVICE_CONFIG_URLACL_QUERY;
ENUM!{enum HTTP_SERVICE_CONFIG_CACHE_KEY {
    MaxCacheResponseSize = 0,
    CacheRangeChunkSize,
}}
pub type PHTTP_SERVICE_CONFIG_CACHE_KEY = *mut HTTP_SERVICE_CONFIG_CACHE_KEY;
pub type HTTP_SERVICE_CONFIG_CACHE_PARAM = ::ULONG;
pub type PHTTP_SERVICE_CONFIG_CACHE_PARAM = *mut ::ULONG;
STRUCT!{struct HTTP_SERVICE_CONFIG_CACHE_SET {
    KeyDesc: HTTP_SERVICE_CONFIG_CACHE_KEY,
    ParamDesc: HTTP_SERVICE_CONFIG_CACHE_PARAM,
}}
pub type PHTTP_SERVICE_CONFIG_CACHE_SET = *mut HTTP_SERVICE_CONFIG_CACHE_SET;